diff --git a/.changeset/collapsed-attribution-footers.md b/.changeset/collapsed-attribution-footers.md
new file mode 100644
index 00000000..a68c9463
--- /dev/null
+++ b/.changeset/collapsed-attribution-footers.md
@@ -0,0 +1,26 @@
+---
+"review": minor
+---
+
+review: name the producing reviewer on every posted finding, in footers collapsed by default
+
+Every inline review comment and pr-level body fold now ends with a collapsed
+`<details>` attribution footer (summary chip `review details`) naming the
+reviewer that produced the finding and, when cross-source dedup merged
+duplicates into it, each other reviewer that flagged the same defect, with its
+differing anchor line and (for clusterer-merged copies) its own subject.
+Collapsed one-liners (the low-confidence section, a hold comment's claim list)
+carry a short trailing `<sub>(<source>)</sub>` tag instead.
+
+The dedup merge record moves from a prose note appended to the survivor's
+`discussion` to a structured `also_flagged_by` field on the claim, rendered at
+the posting surface (`submission.ts`): the claim-validator's
+`corrected.discussion` rewrite could previously drop the note silently, and
+the old "Also flagged by" wording never named the surviving reviewer at all.
+
+The version/config footer on review bodies and the guidance comment is wrapped
+in the same collapsed block (`details`/`summary`/`sub` are all on the ingest
+sanitizer's allowed-tag list, so the block survives posting). Text-similarity
+comparisons against previously posted bodies (open-thread suppression, the
+adjudicated corpus) strip the footers first, so boilerplate shared by every
+bot comment cannot inflate similarity between unrelated findings.
diff --git a/workflows/review/README.md b/workflows/review/README.md
index a7c9aba0..b5fbbe9a 100644
--- a/workflows/review/README.md
+++ b/workflows/review/README.md
@@ -726,12 +726,15 @@ v1.4.0 shipped still pointing at v1.2.2, before the sync existed).
 Semver is the behavior contract: a release that changes the reviewer's behavior bumps
 the major version, so a consumer pinned to `review-v<major>` can assume the fundamental
 behavior holds within a major. For attribution and rollback, every submitted review
-body and the risks/patterns guidance comment (Step 7) end with a visible one-line
-footer, rendered in code by `lib/version-footer.ts` from the pinned checkout's
-`package.json` and the staged run files (never composed by the model):
+body and the risks/patterns guidance comment (Step 7) end with a footer collapsed
+inside a `<details>` block (summary chip `review details`), rendered in code by
+`lib/version-footer.ts` from the pinned checkout's `package.json` and the staged
+run files (never composed by the model):
 
 ```
+<details><summary><sub>review details</sub></summary>
 <sub>review-v<major>.<minor>.<patch> | schema <n> | depth <depth> | re-review <mode> [blocking-only] | enable <reviewer,...></sub>
+</details>
 ```
 
 `schema` is the finding-schema version (`FINDING_SCHEMA_VERSION` in
@@ -742,11 +745,25 @@ the staging cannot state is omitted rather than guessed. A bad reviewer release
 rolls back by re-pinning the previous tag; the footer on each posted review makes
 attribution immediate.
 
-The footer is visible by necessity, not preference: attribution originally rode a
-hidden HTML marker (`<!-- pr-reviewer:version ... -->`), but gh-aw's safe-output
+The footer posts (collapsed, expandable) by necessity, not preference:
+attribution originally rode a hidden HTML marker
+(`<!-- pr-reviewer:version ... -->`), but gh-aw's safe-output
 ingest sanitizer deletes ALL XML/HTML comments (`removeXmlComments` in
 `sanitize_content_core.cjs`, the same strip documented for the fingerprint stamp
-in `lib/rereview-mode.ts`), so the marker never reached a posted comment; `<sub>`
-is on the sanitizer's allowed-tag list and survives ingest. There is no separate
-config-hash or drift-stamp mechanism; the release tag plus the footer's config
-segments are the version surface.
+in `lib/rereview-mode.ts`), so the marker never reached a posted comment; `sub`,
+`details`, and `summary` are on the sanitizer's allowed-tag list and survive
+ingest. There is no separate config-hash or drift-stamp mechanism; the release
+tag plus the footer's config segments are the version surface.
+
+Every inline review comment (and each pr-level finding folded into the review
+body) additionally ends with a per-comment attribution footer in the same
+collapsed block, naming the reviewer that produced the finding and, when
+cross-source dedup merged duplicates into it, each other reviewer that flagged
+the same defect (`lib/attribution.ts`; the merge record is the structured
+`also_flagged_by` field on the claim, so a validator discussion rewrite cannot
+drop it). Collapsed one-liners (the low-confidence `<details>` section and a
+hold comment's claim list) carry the short form, a trailing
+`<sub>(<source>)</sub>` tag. Text-similarity comparisons against
+previously-posted bodies (open-thread suppression, the adjudicated corpus)
+strip these footers first, so the shared boilerplate cannot inflate similarity
+between unrelated findings.
diff --git a/workflows/review/eval/live-dedup.ts b/workflows/review/eval/live-dedup.ts
index 46ead928..4f963c91 100644
--- a/workflows/review/eval/live-dedup.ts
+++ b/workflows/review/eval/live-dedup.ts
@@ -123,14 +123,17 @@ export const dedupeLiveFindings = async (
             ) {
                 return live;
             }
-            // The survivor's claim carries the "also flagged by" note (the lib
-            // projection puts the prose in `discussion`) and may have adopted a
-            // merged copy's suggestion; both must reach the rendered comment.
+            // The survivor's claim may have adopted a merged copy's
+            // suggestion, which must reach the rendered comment. The "also
+            // flagged by" record is structured (`also_flagged_by`) and is
+            // rendered by production's posting surface (submission.ts's
+            // collapsed attribution footer), which the eval's `renderComment`
+            // does not emulate; the merge itself is measured through
+            // `merges`, so the record adds no report column here.
             return {
                 ...live,
                 finding: {
                     ...live.finding,
-                    model_authored_prose: survivor.discussion,
                     ...(survivor.suggestion !== undefined
                         ? {suggested_patch: survivor.suggestion}
                         : {}),
diff --git a/workflows/review/eval/live-producer.test.ts b/workflows/review/eval/live-producer.test.ts
index 903cac44..cf27577f 100644
--- a/workflows/review/eval/live-producer.test.ts
+++ b/workflows/review/eval/live-producer.test.ts
@@ -746,12 +746,13 @@ describe("produceLive cross-source dedup", () => {
                 ) as string,
             ),
         ).toHaveLength(2);
-        // One finding survives, carrying the attribution note, and the
-        // validator is dispatched over the merged set only.
+        // One finding survives (the merge itself is recorded in the dedup
+        // report; the structured `also_flagged_by` record renders only at
+        // production's posting surface), and the validator is dispatched
+        // over the merged set only.
         expect(result.findings).toHaveLength(1);
-        expect(result.findings[0].finding.model_authored_prose).toContain(
-            "Also flagged by:\n- skill: Declaration doc comment doesn't begin " +
-                "with the symbol name.",
+        expect(result.findings[0].finding.model_authored_prose).not.toContain(
+            "Also flagged by",
         );
         expect(
             JSON.parse(
diff --git a/workflows/review/lib/attribution.test.ts b/workflows/review/lib/attribution.test.ts
new file mode 100644
index 00000000..69ff00e5
--- /dev/null
+++ b/workflows/review/lib/attribution.test.ts
@@ -0,0 +1,129 @@
+import {describe, it, expect} from "vitest";
+
+import {
+    renderAttributionFooter,
+    renderCollapsedFooter,
+    stripFooters,
+} from "./attribution";
+
+describe("renderCollapsedFooter", () => {
+    it("wraps one <sub> line in the shared collapsed block", () => {
+        expect(renderCollapsedFooter("schema 2")).toBe(
+            "<details><summary><sub>review details</sub></summary>\n" +
+                "<sub>schema 2</sub>\n" +
+                "</details>",
+        );
+    });
+
+    it("never emits an HTML comment (the sanitizer would delete it)", () => {
+        expect(renderCollapsedFooter("x")).not.toContain("<!--");
+    });
+});
+
+describe("renderAttributionFooter", () => {
+    it("names the producing reviewer alone when nothing merged", () => {
+        expect(renderAttributionFooter("correctness-reviewer")).toBe(
+            renderCollapsedFooter("found by correctness-reviewer"),
+        );
+    });
+
+    it("appends the merged copies with their differing anchors", () => {
+        expect(
+            renderAttributionFooter("correctness-reviewer", [
+                {source: "completeness"},
+                {source: "skill-auditor (out-of-lane)", line: 58},
+            ]),
+        ).toBe(
+            renderCollapsedFooter(
+                "found by correctness-reviewer | also flagged by " +
+                    "completeness; skill-auditor (out-of-lane) (at line 58)",
+            ),
+        );
+    });
+
+    it("quotes a tier-2 copy's own subject (the ask the survivor may not restate)", () => {
+        expect(
+            renderAttributionFooter("correctness-reviewer", [
+                {
+                    source: "conventions",
+                    subject: "Doc comment doesn't begin with the symbol name.",
+                },
+            ]),
+        ).toBe(
+            renderCollapsedFooter(
+                "found by correctness-reviewer | also flagged by " +
+                    "conventions: Doc comment doesn't begin with the symbol name.",
+            ),
+        );
+    });
+
+    it("escapes HTML in a merged copy's model-authored subject", () => {
+        const footer = renderAttributionFooter("correctness-reviewer", [
+            {
+                source: "conventions",
+                subject: "Unbalanced </details> & a <sub> tag.",
+            },
+        ]);
+        expect(footer).not.toContain("Unbalanced </details>");
+        expect(footer).toContain(
+            "Unbalanced &lt;/details&gt; &amp; a &lt;sub&gt; tag.",
+        );
+        // The block still strips cleanly: the subject cannot close it early.
+        expect(stripFooters(`prose\n${footer}`)).toBe("prose\n");
+    });
+});
+
+describe("stripFooters", () => {
+    it("removes the collapsed footer block from a posted body", () => {
+        const body = `**issue (blocking):** The guard was removed.\n\n${renderAttributionFooter(
+            "correctness-reviewer",
+            [{source: "completeness"}],
+        )}`;
+        const stripped = stripFooters(body);
+        expect(stripped).not.toContain("found by");
+        expect(stripped).not.toContain("review details");
+        expect(stripped).toContain("The guard was removed.");
+    });
+
+    it("tolerates round-tripped whitespace inside the block", () => {
+        const body =
+            "prose\n<details>\n <summary> <sub>review details</sub> </summary>\n<sub>found by x</sub>\n</details>";
+        expect(stripFooters(body)).not.toContain("found by");
+    });
+
+    it("removes bare <sub> spans (version-footer lines, source tags)", () => {
+        expect(
+            stripFooters(
+                "- `a.ts:2` issue (blocking): s <sub>(correctness-reviewer)</sub>",
+            ),
+        ).toBe("- `a.ts:2` issue (blocking): s ");
+        expect(stripFooters("<sub>review-v1.13.0 | schema 2</sub>")).toBe("");
+    });
+
+    it("keeps a quoted <sub> span mid-prose (review content, not a footer)", () => {
+        const body =
+            "The strip targets <sub>spans</sub> quoted inside a sentence.";
+        expect(stripFooters(body)).toBe(body);
+        const backticked =
+            "the footer renders `<sub>content</sub>` inside the block, then prose";
+        expect(stripFooters(backticked)).toBe(backticked);
+    });
+
+    it("leaves other <details> blocks alone", () => {
+        const section =
+            "<details>\n<summary>Lower-confidence observations (2)</summary>\n\n- a\n\n</details>";
+        expect(stripFooters(section)).toBe(section);
+    });
+
+    it("removes every footer when a body carries more than one", () => {
+        const body = [
+            renderAttributionFooter("a"),
+            "prose",
+            renderCollapsedFooter("review-v1 | schema 2"),
+        ].join("\n");
+        const stripped = stripFooters(body);
+        expect(stripped).not.toContain("found by");
+        expect(stripped).not.toContain("schema 2");
+        expect(stripped).toContain("prose");
+    });
+});
diff --git a/workflows/review/lib/attribution.ts b/workflows/review/lib/attribution.ts
new file mode 100644
index 00000000..a1d8b107
--- /dev/null
+++ b/workflows/review/lib/attribution.ts
@@ -0,0 +1,124 @@
+/**
+ * The collapsed footer surfaces: one shared `<details>` wrapper for the
+ * run-level version/config footer (version-footer.ts) and the per-comment
+ * reviewer attribution, plus the strip that keeps footer boilerplate out of
+ * text-similarity comparisons.
+ *
+ * Why collapsed: both footers are metadata, not review content. Rendered
+ * open they add a visible line to every posted surface; wrapped in
+ * `<details>` they collapse to one small summary chip the author can expand.
+ * `details`, `summary`, and `sub` are all on gh-aw's ingest-sanitizer
+ * allowed-tag list (`SANITIZER_ALLOWED_TAGS`, sanitizer-normalize.ts mirrors
+ * sanitize_content_core.cjs v0.83.4), so the block survives ingest
+ * verbatim; that is the same property that made version-footer.ts pick
+ * `<sub>` over the hidden HTML marker the sanitizer deletes.
+ *
+ * Why attribution is rendered HERE (code, at the posting surface) and not
+ * carried in a claim's `discussion`: dedup runs before the claim-validator,
+ * whose `corrected.discussion` rewrite replaces the prose wholesale, so a
+ * merge note appended to `discussion` can be silently dropped. The
+ * structured `also_flagged_by` field on the claim survives every rewrite
+ * (applyVerifications never touches it), and this module turns it into text
+ * only when the comment is composed. Determinism boundary: everything here
+ * is code-owned wrapping around code-recorded facts (source names, line
+ * numbers) plus a merged copy's `subject` quoted verbatim; no prose about
+ * the code under review is synthesised.
+ */
+
+/**
+ * One duplicate copy dedup folded into a surviving claim: the reviewer that
+ * produced it, its own anchor line when it differs from the survivor's, and
+ * (for a tier-2, clusterer-merged copy only) its subject, verbatim, because
+ * the survivor's prose is not known to restate that ask (see dedup.ts).
+ */
+export type AlsoFlagged = {
+    source: string;
+    line?: number;
+    subject?: string;
+};
+
+/** The code-owned summary chip both collapsed footers render under. */
+export const FOOTER_SUMMARY = "review details";
+
+/**
+ * Wrap one `<sub>` content line in the shared collapsed `<details>` block.
+ * The shape is fixed so {@link stripFooters} can remove it mechanically.
+ */
+export const renderCollapsedFooter = (content: string): string =>
+    [
+        `<details><summary><sub>${FOOTER_SUMMARY}</sub></summary>`,
+        `<sub>${content}</sub>`,
+        "</details>",
+    ].join("\n");
+
+/**
+ * A merged copy's `subject` is model-authored text interpolated into the
+ * footer's HTML. Unescaped, a subject containing a literal `</details>`
+ * closes the collapsed block early and truncates {@link stripFooters}'s
+ * non-greedy match. Escape the HTML-significant characters; GitHub renders
+ * the entities back as the literal characters.
+ */
+const escapeHtml = (text: string): string =>
+    text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+const flaggedBy = (entry: AlsoFlagged): string => {
+    const anchor =
+        entry.line === undefined
+            ? entry.source
+            : `${entry.source} (at line ${entry.line})`;
+    return entry.subject === undefined
+        ? anchor
+        : `${anchor}: ${escapeHtml(entry.subject)}`;
+};
+
+/**
+ * The per-comment attribution footer: which reviewer produced the finding,
+ * and (when cross-source dedup merged duplicates into it) which other
+ * reviewers flagged the same defect, each with its differing anchor line and
+ * (tier-2 copies) its own ask. Segments join with ` | ` like the version
+ * footer; merged entries join with `; ` because a quoted subject can carry
+ * commas.
+ */
+export const renderAttributionFooter = (
+    source: string,
+    alsoFlaggedBy: readonly AlsoFlagged[] = [],
+): string => {
+    const segments = [`found by ${source}`];
+    if (alsoFlaggedBy.length > 0) {
+        segments.push(
+            `also flagged by ${alsoFlaggedBy.map(flaggedBy).join("; ")}`,
+        );
+    }
+    return renderCollapsedFooter(segments.join(" | "));
+};
+
+/**
+ * The collapsed-footer block, tolerant of the whitespace GitHub round-trips
+ * may introduce; non-greedy so it stops at the block's own `</details>` (a
+ * footer never nests another details block).
+ */
+const FOOTER_BLOCK_RE = new RegExp(
+    `<details>\\s*<summary>\\s*<sub>${FOOTER_SUMMARY}</sub>\\s*</summary>[\\s\\S]*?</details>`,
+    "gi",
+);
+
+/**
+ * Drop footer boilerplate from a previously-posted bot comment before
+ * text-similarity comparison (dedup.ts's `threadProse`). Every posted
+ * comment carries the same summary chip, `found by <source>` prefix, and
+ * version segments; tokens shared by ALL bot comments would inflate
+ * similarity between unrelated findings, exactly like the label template
+ * and rule-quote lines `threadProse` already strips. Removes the collapsed
+ * block and the two residual bare `<sub>…</sub>` shapes this codebase has
+ * posted: a whole-line span (the pre-collapse version-footer line) and a
+ * parenthesized span at end of line (the source tag on collapsed
+ * one-liners). Deliberately NOT a blanket `<sub>…</sub>` strip: a posted
+ * comment whose own discussion quotes a `<sub>` span mid-prose (even in
+ * backticks) is review content, and deleting it would distort the
+ * similarity text.
+ */
+export const stripFooters = (body: string): string =>
+    body
+        .replace(FOOTER_BLOCK_RE, "")
+        .replace(/^[ \t]*<sub>[^<]*<\/sub>[ \t]*$/gm, "")
+        .replace(/<sub>\([^<]*\)<\/sub>[ \t]*$/gm, "");
diff --git a/workflows/review/lib/dedup-cluster.test.ts b/workflows/review/lib/dedup-cluster.test.ts
index 966bfb87..d065c439 100644
--- a/workflows/review/lib/dedup-cluster.test.ts
+++ b/workflows/review/lib/dedup-cluster.test.ts
@@ -165,22 +165,31 @@ describe("dedupeClaims with model-proposed clusters", () => {
         );
         expect(claims.map((c) => c.id)).toEqual(["correctness-reviewer-3"]);
         // Anchors differ inside the cluster (:8 and :9), which tier 2 does not
-        // care about and the note does report. Each absorbed copy also brings
+        // care about and the record does report. Each absorbed copy also brings
         // its own subject, because tier 2 merged claims whose words the
         // survivor's prose does NOT restate: `conventions` asked for the
         // symbol-name prefix, not for the wrong number, and one rewritten
         // comment discharges both asks only if the author is told about both.
-        expect(claims[0].discussion).toContain(
-            [
-                "Also flagged by:",
-                "- skill-auditor (out-of-lane) (at line 9): The comment on line 8 " +
+        expect(claims[0].also_flagged_by).toEqual([
+            {
+                source: "skill-auditor (out-of-lane)",
+                line: 9,
+                subject:
+                    "The comment on line 8 " +
                     'says "Keeps at most 10 samples per key." but `const maxSamples ' +
                     "= 25`, so the doc and the enforced cap disagree.",
-                "- conventions: Declaration doc comment doesn't begin with the " +
+            },
+            {
+                source: "conventions",
+                subject:
+                    "Declaration doc comment doesn't begin with the " +
                     "symbol name.",
-                "- documentation: Comment states the wrong cap (10 vs 25).",
-            ].join("\n"),
-        );
+            },
+            {
+                source: "documentation",
+                subject: "Comment states the wrong cap (10 vs 25).",
+            },
+        ]);
         expect(merges).toEqual([
             {
                 survivor: "correctness-reviewer-3",
@@ -837,10 +846,13 @@ describe("dedupeClaims with model-proposed clusters", () => {
         );
         expect(claims.map((c) => c.id)).toEqual(["test-adequacy-1"]);
         expect(claims[0].label).toBe("todo (blocking)");
-        expect(claims[0].discussion).toContain(
-            "Also flagged by:\n- first-principles (at line 58): " +
-                "The suite never reaches the delete.",
-        );
+        expect(claims[0].also_flagged_by).toEqual([
+            {
+                source: "first-principles",
+                line: 58,
+                subject: "The suite never reaches the delete.",
+            },
+        ]);
         expect(merges[0].via).toBe("clusterer");
         expect(merges[0].line).toBe(15);
     });
@@ -914,15 +926,16 @@ describe("dedupeClaims with model-proposed clusters", () => {
                 via: "clusterer",
             },
         ]);
-        // The note quotes only the copy tier 2 brought: the survivor's own
+        // The record quotes only the copy tier 2 brought: the survivor's own
         // prose does not restate it, while the tier-1 copy's clearing of the
         // floor is the evidence that it does.
-        expect(claims[0].discussion).toContain(
-            [
-                "Also flagged by:",
-                "- skill-auditor (out-of-lane) (at line 58)",
-                "- first-principles (at line 58): The suite never reaches the delete.",
-            ].join("\n"),
-        );
+        expect(claims[0].also_flagged_by).toEqual([
+            {source: "skill-auditor (out-of-lane)", line: 58},
+            {
+                source: "first-principles",
+                line: 58,
+                subject: "The suite never reaches the delete.",
+            },
+        ]);
     });
 });
diff --git a/workflows/review/lib/dedup.test.ts b/workflows/review/lib/dedup.test.ts
index 88bed023..97cdeaa6 100644
--- a/workflows/review/lib/dedup.test.ts
+++ b/workflows/review/lib/dedup.test.ts
@@ -166,9 +166,11 @@ describe("dedupeClaims", () => {
         expect(claims).toHaveLength(1);
         expect(claims[0].id).toBe("correctness-reviewer-1");
         expect(claims[0].label).toBe("issue (blocking)");
-        expect(claims[0].discussion).toContain(
-            "Also flagged by completeness, first-principles, skill-auditor (out-of-lane).",
-        );
+        expect(claims[0].also_flagged_by).toEqual([
+            {source: "completeness"},
+            {source: "first-principles"},
+            {source: "skill-auditor (out-of-lane)"},
+        ]);
         expect(merges).toEqual([
             {
                 survivor: "correctness-reviewer-1",
@@ -355,12 +357,12 @@ describe("dedupeClaims", () => {
         expect(claims).toHaveLength(1);
         expect(claims[0].id).toBe("correctness-reviewer-3");
         expect(claims[0].label).toBe("todo (blocking)");
-        // The note names the other copy's anchor, since it is not the
+        // The record names the other copy's anchor, since it is not the
         // survivor's: an author reading a merge across 43 lines needs to know
         // the second reviewer was looking somewhere else.
-        expect(claims[0].discussion).toContain(
-            "Also flagged by skill-auditor (out-of-lane) (at line 58).",
-        );
+        expect(claims[0].also_flagged_by).toEqual([
+            {source: "skill-auditor (out-of-lane)", line: 58},
+        ]);
         expect(merges).toEqual([
             {
                 survivor: "correctness-reviewer-3",
@@ -440,10 +442,12 @@ describe("dedupeClaims", () => {
         const {claims, merges} = dedupeClaims(ttlUnitClaims());
         expect(claims).toHaveLength(1);
         expect(claims[0].id).toBe("correctness-reviewer-1");
-        expect(claims[0].discussion).toContain(
-            "Also flagged by skill-auditor (out-of-lane), completeness, " +
-                "holistic, first-principles.",
-        );
+        expect(claims[0].also_flagged_by).toEqual([
+            {source: "skill-auditor (out-of-lane)"},
+            {source: "completeness"},
+            {source: "holistic"},
+            {source: "first-principles"},
+        ]);
         expect(merges).toEqual([
             {
                 survivor: "correctness-reviewer-1",
diff --git a/workflows/review/lib/dedup.ts b/workflows/review/lib/dedup.ts
index 0ed92e47..dec1dcb7 100644
--- a/workflows/review/lib/dedup.ts
+++ b/workflows/review/lib/dedup.ts
@@ -72,10 +72,13 @@
  * pairs that also clear its looser text floor). The line survives as evidence
  * inside tier 1 and as the survivor's posting anchor, and nothing more.
  *
- * The survivor is the highest-severity copy, its discussion gains an "also
- * flagged by" note (naming each other source's anchor when it differs, and
- * quoting the subject of any copy tier 2 absorbed, whose ask the survivor's own
- * prose is not known to restate), and every merge is recorded for
+ * The survivor is the highest-severity copy, it gains a structured
+ * `also_flagged_by` record (naming each other source, its anchor when it
+ * differs, and the subject of any copy tier 2 absorbed, whose ask the
+ * survivor's own prose is not known to restate; the posting surface
+ * renders the record into the comment's collapsed attribution footer,
+ * attribution.ts, so a validator discussion rewrite cannot drop it), and
+ * every merge is recorded for
  * dispatch-result.json with the tier that found it (per group and per absorbed
  * copy), so the merge rate is readable from the artifact rather than from what
  * survives on the PR.
@@ -90,6 +93,7 @@
  * can cost is bounded by code even where its judgment cannot be checked.
  */
 
+import {stripFooters, type AlsoFlagged} from "./attribution";
 import {bigrams, contentTokens, intersectionSize} from "./dedup-text";
 import {isRecord, type Claim, type ProposedCluster} from "./dispatch-contracts";
 import {isBlockingLabel} from "./render-comment";
@@ -289,14 +293,15 @@ export const threadOpenerIsBlocking = (body: string): boolean => {
 
 /**
  * The prose of a previously-posted bot comment, for similarity comparison:
- * the leading `**label:**` template (tolerating the markdown-stripped form
+ * the collapsed attribution/version footers (attribution.ts's strip), the
+ * leading `**label:**` template (tolerating the markdown-stripped form
  * the staged bodies sometimes carry) and everything from the first code
  * fence on (a suggestion block) are dropped, as are rule-quote lines:
  * boilerplate shared by ALL bot comments would inflate similarity between
  * unrelated findings.
  */
 const threadProse = (body: string): string =>
-    body
+    stripFooters(body)
         .split("```")[0]
         .split("\n")
         .filter((line) => !line.trimStart().startsWith(">"))
@@ -865,7 +870,7 @@ export const dedupeClaims = (
         // merge (and to spot a wrong one).
         //
         // A tier-2 copy also carries its own SUBJECT, and only a tier-2 copy
-        // does. What the note must not lose is an ask the survivor's prose
+        // does. What the record must not lose is an ask the survivor's prose
         // does not already make: run 30587343777's `conventions` copy of the
         // wrong-cap defect asked for the symbol-name prefix, not for the
         // number, and one rewritten comment discharges both only if the author
@@ -876,7 +881,14 @@ export const dedupeClaims = (
         // noise into the surviving comment rather than remove it. Tier 2 is
         // the case where that evidence is missing (the floor is what it could
         // not clear), so there the quote is the only thing carrying the ask.
-        const sources: {source: string; line?: number; subject?: string}[] = [];
+        //
+        // Recorded as the structured `also_flagged_by` field, NOT appended to
+        // `discussion`: dedup runs before the claim-validator, whose
+        // `corrected.discussion` rewrite replaces the prose wholesale, so a
+        // note riding the discussion could silently vanish. The posting
+        // surface (submission.ts) renders the field into the comment's
+        // collapsed attribution footer.
+        const sources: AlsoFlagged[] = [];
         for (const {index, via} of others) {
             const claim = claims[index];
             if (
@@ -895,25 +907,6 @@ export const dedupeClaims = (
                     : {}),
             });
         }
-        const flaggedBy = (entry: {source: string; line?: number}): string =>
-            entry.line === undefined
-                ? entry.source
-                : `${entry.source} (at line ${entry.line})`;
-        const alsoFlagged =
-            sources.length === 0
-                ? ""
-                : sources.every((entry) => entry.subject === undefined)
-                ? `\n\nAlso flagged by ${sources.map(flaggedBy).join(", ")}.`
-                : `\n\nAlso flagged by:\n${sources
-                      .map(
-                          (entry) =>
-                              `- ${flaggedBy(entry)}${
-                                  entry.subject === undefined
-                                      ? ""
-                                      : `: ${entry.subject}`
-                              }`,
-                      )
-                      .join("\n")}`;
         const adoptedSuggestion =
             survivor.suggestion === undefined
                 ? otherClaims.find((claim) => claim.suggestion !== undefined)
@@ -927,7 +920,7 @@ export const dedupeClaims = (
                 : undefined;
         replacement.set(survivorIndex, {
             ...survivor,
-            discussion: `${survivor.discussion}${alsoFlagged}`,
+            ...(sources.length > 0 ? {also_flagged_by: sources} : {}),
             ...(adoptedSuggestion !== undefined
                 ? {suggestion: adoptedSuggestion}
                 : {}),
diff --git a/workflows/review/lib/dispatch-cluster.test.ts b/workflows/review/lib/dispatch-cluster.test.ts
index c836aa21..a98b621c 100644
--- a/workflows/review/lib/dispatch-cluster.test.ts
+++ b/workflows/review/lib/dispatch-cluster.test.ts
@@ -224,10 +224,13 @@ describe("runDispatch defect clustering (dedup tier 2)", () => {
         );
         expect(JSON.parse(fs.files[`${REVIEW}/claims.json`])).toHaveLength(1);
         expect(result.claims).toMatchObject([{id: "correctness-reviewer-1"}]);
-        expect(result.claims[0].discussion).toContain(
-            "Also flagged by:\n- skill-auditor: Declaration doc comment " +
-                "doesn't begin with the symbol name.",
-        );
+        expect(result.claims[0].also_flagged_by).toEqual([
+            {
+                source: "skill-auditor",
+                subject:
+                    "Declaration doc comment doesn't begin with the symbol name.",
+            },
+        ]);
         expect(result.merges[0].via).toBe("clusterer");
         // The audit block: candidate count and merge count come from here, not
         // from what survives on the PR.
diff --git a/workflows/review/lib/dispatch-contracts.ts b/workflows/review/lib/dispatch-contracts.ts
index e4383251..ff247fce 100644
--- a/workflows/review/lib/dispatch-contracts.ts
+++ b/workflows/review/lib/dispatch-contracts.ts
@@ -11,6 +11,7 @@
  * code under review.
  */
 
+import type {AlsoFlagged} from "./attribution";
 import {
     validateFinding,
     type Anchor,
@@ -506,6 +507,14 @@ export type Claim = {
     confidence: number;
     author_dispute?: string;
     rule_quote?: string;
+    /**
+     * The cross-source duplicate copies dedup folded into this claim (one
+     * entry per other source; see dedup.ts). Structured rather than appended
+     * to `discussion` so a validator `corrected.discussion` rewrite cannot
+     * silently drop the record; the posting surface (submission.ts) renders
+     * it into the comment's collapsed attribution footer (attribution.ts).
+     */
+    also_flagged_by?: AlsoFlagged[];
 };
 
 export const buildClaims = (candidates: Candidate[]): Claim[] =>
diff --git a/workflows/review/lib/dispatch.test.ts b/workflows/review/lib/dispatch.test.ts
index d3e8a277..990d4f75 100644
--- a/workflows/review/lib/dispatch.test.ts
+++ b/workflows/review/lib/dispatch.test.ts
@@ -683,7 +683,9 @@ describe("runDispatch", () => {
         const result = await runDispatch(options(fs, runner));
         expect(result.merges[0].via).toBe("similarity");
         expect(result.claims).toMatchObject([{id: "correctness-reviewer-1"}]);
-        expect(result.claims[0].discussion).toContain("Also flagged by");
+        expect(result.claims[0].also_flagged_by).toEqual([
+            {source: "skill-auditor"},
+        ]);
         // The validator was dispatched on the merged set, and the merge is
         // recorded in dispatch-result.json for the run report.
         expect(JSON.parse(fs.files[`${REVIEW}/claims.json`])).toHaveLength(1);
diff --git a/workflows/review/lib/submission-blocking-only.test.ts b/workflows/review/lib/submission-blocking-only.test.ts
index 6f02bcf7..499c1184 100644
--- a/workflows/review/lib/submission-blocking-only.test.ts
+++ b/workflows/review/lib/submission-blocking-only.test.ts
@@ -102,16 +102,21 @@ describe("runSubmissionCli: re-review blocking-only", () => {
         );
         const plan = runSubmissionCli(fs);
         // Only the blocking claim posts inline, without the collapsed
-        // section riding it: the section lives in the body.
+        // section riding it: the section lives in the body. (The comment
+        // still carries its own collapsed attribution footer.)
         expect(plan.comments).toHaveLength(1);
         expect(plan.comments[0].body).toContain("**issue (blocking):**");
-        expect(plan.comments[0].body).not.toContain("<details>");
+        expect(plan.comments[0].body).not.toContain(
+            "Non-blocking observations",
+        );
         expect(plan.body).toContain("Non-blocking observations (2)");
         expect(plan.body).toContain(
-            "- `a.ts:9` nitpick (non-blocking): Rename the helper.",
+            "- `a.ts:9` nitpick (non-blocking): Rename the helper. " +
+                "<sub>(correctness-reviewer)</sub>",
         );
         expect(plan.body).toContain(
-            "- note (non-blocking): A cross-file observation.",
+            "- note (non-blocking): A cross-file observation. " +
+                "<sub>(correctness-reviewer)</sub>",
         );
         expect(plan.notes.join(" ")).toContain(
             "2 non-blocking claim(s) collapsed into the body (re-review blocking-only)",
diff --git a/workflows/review/lib/submission-hold.test.ts b/workflows/review/lib/submission-hold.test.ts
index e9e6c038..baa2cc9a 100644
--- a/workflows/review/lib/submission-hold.test.ts
+++ b/workflows/review/lib/submission-hold.test.ts
@@ -144,7 +144,12 @@ describe("the hold path (core dimension unavailable)", () => {
         const plan = runSubmissionCli(fs);
         expect(plan.event).toBe("HOLD_FOR_HUMAN");
         expect(plan.comments).toEqual([]);
-        expect(plan.body).toContain("- `a.ts:2` suggestion (non-blocking): s");
+        // Each folded line carries its one-line source tag (the hold-path
+        // parallel of the collapsed-observations tag).
+        expect(plan.body).toContain(
+            "- `a.ts:2` suggestion (non-blocking): s " +
+                "<sub>(correctness-reviewer)</sub>",
+        );
         expect(
             plan.notes.some((note) =>
                 note.includes("folded into the hold comment"),
@@ -187,7 +192,8 @@ describe("the hold path (core dimension unavailable)", () => {
         const plan = runSubmissionCli(fs);
         expect(plan.event).toBe("HOLD_FOR_HUMAN");
         expect(plan.body).toContain(
-            "- suggestion (non-blocking): spanning concern",
+            "- suggestion (non-blocking): spanning concern " +
+                "<sub>(correctness-reviewer)</sub>",
         );
     });
 
diff --git a/workflows/review/lib/submission.test.ts b/workflows/review/lib/submission.test.ts
index 816402a4..f1afea46 100644
--- a/workflows/review/lib/submission.test.ts
+++ b/workflows/review/lib/submission.test.ts
@@ -102,7 +102,11 @@ describe("runSubmissionCli", () => {
             {
                 path: "a.ts",
                 line: 2,
-                body: "**issue (blocking):** The guard was removed.",
+                body:
+                    "**issue (blocking):** The guard was removed.\n\n" +
+                    "<details><summary><sub>review details</sub></summary>\n" +
+                    "<sub>found by correctness-reviewer</sub>\n" +
+                    "</details>",
             },
         ]);
         expect(plan.resolve).toEqual(["t1"]);
@@ -238,6 +242,7 @@ describe("runSubmissionCli", () => {
                         path: undefined,
                         line: undefined,
                         label: "note (non-blocking)",
+                        also_flagged_by: [{source: "completeness", line: 7}],
                     }),
                 ],
             }),
@@ -247,6 +252,14 @@ describe("runSubmissionCli", () => {
         expect(plan.body).toContain(
             "**note (non-blocking):** The guard was removed.",
         );
+        // The fold carries the same collapsed attribution footer an inline
+        // comment gets (submission.ts's pr-level branch).
+        expect(plan.body).toContain(
+            "<details><summary><sub>review details</sub></summary>\n" +
+                "<sub>found by correctness-reviewer | also flagged by " +
+                "completeness (at line 7)</sub>\n" +
+                "</details>",
+        );
         expect(plan.body).not.toContain("<summary>Full finding</summary>");
         expect(plan.notes.join(" ")).toContain("folded into the review body");
     });
@@ -480,13 +493,16 @@ describe("the gate's plan-match rule (slice 4)", () => {
         );
         const plan = runSubmissionCli(fs);
         const lines = plan.body.split("\n");
-        // Stamp last (hidden), footer directly above it (visible).
+        // Stamp last (hidden), the collapsed footer block directly above it.
         expect(lines.at(-1)).toMatch(/^<!--.*-->$/);
-        expect(lines.at(-2)).toMatch(/^<sub>.*schema \d+.*<\/sub>$/);
-        expect(lines.at(-2)).not.toContain("<!--");
+        expect(lines.at(-2)).toBe("</details>");
+        expect(lines.at(-3)).toMatch(/^<sub>.*schema \d+.*<\/sub>$/);
+        expect(lines.at(-4)).toBe(
+            "<details><summary><sub>review details</sub></summary>",
+        );
         // The CLI also staged the footer file Step 7 pastes.
         expect(fs.files["/tmp/gh-aw/review/version-footer.txt"]).toBe(
-            lines.at(-2),
+            lines.slice(-4, -1).join("\n"),
         );
     });
 
diff --git a/workflows/review/lib/submission.ts b/workflows/review/lib/submission.ts
index 700dd9fb..a8ebf5aa 100644
--- a/workflows/review/lib/submission.ts
+++ b/workflows/review/lib/submission.ts
@@ -60,6 +60,7 @@
  * under review.
  */
 
+import {renderAttributionFooter} from "./attribution";
 import {computeRisksPatternsKey, RISKS_PATTERNS_KEY_PATH} from "./cache-record";
 import type {Claim} from "./dispatch-contracts";
 import {DEFAULT_FINDERS, TRIAGE_DIMENSION} from "./dispatch-roster";
@@ -226,6 +227,15 @@ export const renderPrLevelFold = (claim: Claim): string => {
     ].join("\n");
 };
 
+/**
+ * The one-line source tag for collapsed/hold list entries: the same
+ * attribution the full comments carry, in the smallest form that fits a
+ * one-liner (a whole collapsed footer per list entry would bury the list).
+ * `<sub>` is sanitizer-allowed, and attribution.ts's stripFooters removes
+ * the span before any text-similarity comparison against posted bodies.
+ */
+const sourceTag = (claim: Claim): string => `<sub>(${claim.source})</sub>`;
+
 const lineHasCodeSignal = (line: string): boolean =>
     /\w\(/.test(line) || // a call
     /[{};]/.test(line) || // block/statement punctuation
@@ -517,7 +527,14 @@ export const runSubmissionCli = (
         } else if (blockingOnly && !isBlockingLabel(claim.label)) {
             prLevelCollapsed.push(claim);
         } else {
-            prLevelLines.push(renderPrLevelFold(claim));
+            // The fold carries the same collapsed attribution footer an
+            // inline comment gets: a pr-level finding names its reviewer too.
+            prLevelLines.push(
+                `${renderPrLevelFold(claim)}\n${renderAttributionFooter(
+                    claim.source,
+                    claim.also_flagged_by,
+                )}`,
+            );
             notes.push(
                 `pr-level claim ${claim.id} folded into the review body`,
             );
@@ -625,8 +642,10 @@ export const runSubmissionCli = (
                     `claim ${claim.id} folded into the hold comment (a hold posts no inline comments)`,
                 );
                 return claim.path !== undefined && claim.line !== undefined
-                    ? `- \`${claim.path}:${claim.line}\` ${claim.label}: ${claim.subject}`
-                    : `- ${claim.label}: ${claim.subject}`;
+                    ? `- \`${claim.path}:${claim.line}\` ${claim.label}: ${
+                          claim.subject
+                      } ${sourceTag(claim)}`
+                    : `- ${claim.label}: ${claim.subject} ${sourceTag(claim)}`;
             },
         );
         return stagePlan(fs, {
@@ -679,7 +698,8 @@ export const runSubmissionCli = (
         ...ranked.filter((claim) => !inlineClaims.has(claim)),
         ...prLevelCollapsed,
     ];
-    const inline: PlannedComment[] = [...inlineClaims].map((claim) => ({
+    const inlineList = [...inlineClaims];
+    const inline: PlannedComment[] = inlineList.map((claim) => ({
         path: claim.path as string,
         line: claim.line as number,
         body: renderClaimComment(claim),
@@ -718,8 +738,10 @@ export const runSubmissionCli = (
             "",
             ...collapsed.map((claim) =>
                 claim.path !== undefined && claim.line !== undefined
-                    ? `- \`${claim.path}:${claim.line}\` ${claim.label}: ${claim.subject}`
-                    : `- ${claim.label}: ${claim.subject}`,
+                    ? `- \`${claim.path}:${claim.line}\` ${claim.label}: ${
+                          claim.subject
+                      } ${sourceTag(claim)}`
+                    : `- ${claim.label}: ${claim.subject} ${sourceTag(claim)}`,
             ),
             "",
             "</details>",
@@ -738,6 +760,23 @@ export const runSubmissionCli = (
         );
     }
 
+    // The per-comment attribution footer (attribution.ts): which reviewer
+    // produced the finding, plus dedup's `also_flagged_by` record of every
+    // other reviewer that flagged the same defect. Appended here, after the
+    // collapsed-observations section ride, so the footer is each comment's
+    // final block; appended at the plan surface rather than inside
+    // renderClaimComment so the claim renderer stays byte-identical to
+    // renderComment on the same finding (the layout parity the tests pin).
+    inlineList.forEach((claim, index) => {
+        inline[index] = {
+            ...inline[index],
+            body: `${inline[index].body}\n\n${renderAttributionFooter(
+                claim.source,
+                claim.also_flagged_by,
+            )}`,
+        };
+    });
+
     const event =
         verdict.event === "REQUEST_CHANGES" ? "REQUEST_CHANGES" : "APPROVE";
 
@@ -755,9 +794,10 @@ export const runSubmissionCli = (
     const coreBody = [head, ...prLevelLines, ...noteLines, ...depthNotes]
         .filter((line) => line !== "")
         .join("\n");
-    // The visible attribution footer (version-footer.ts): code-rendered,
-    // sanitizer-surviving (<sub> is on the allowed-tag list; the old hidden
-    // HTML marker never posted). The CLI also stages version-footer.txt for
+    // The version/config footer (version-footer.ts): code-rendered,
+    // collapsed by default (attribution.ts's shared <details> wrapper), and
+    // sanitizer-surviving (details/summary/sub are all allowed tags; the old
+    // hidden HTML marker never posted). The CLI also stages version-footer.txt for
     // Step 7's guidance comment. The depth override hands the footer this
     // run's executed depth from the SAME read that keys the depth Note and
     // blocking-only gating, so the two surfaces cannot contradict; null
diff --git a/workflows/review/lib/version-footer.test.ts b/workflows/review/lib/version-footer.test.ts
index 7c86eb13..ead34b29 100644
--- a/workflows/review/lib/version-footer.test.ts
+++ b/workflows/review/lib/version-footer.test.ts
@@ -1,5 +1,6 @@
 import {describe, it, expect} from "vitest";
 
+import {renderCollapsedFooter} from "./attribution";
 import {FINDING_SCHEMA_VERSION} from "./finding-schema";
 import {
     FOOTER_OUT,
@@ -9,12 +10,15 @@ import {
 } from "./version-footer";
 
 /**
- * The visible attribution footer: the sanitizer-surviving replacement for
+ * The version/config footer: the sanitizer-surviving replacement for
  * the hidden `pr-reviewer:version` HTML marker, which gh-aw's ingest
- * sanitizer stripped from every posted body. Rendering is pure and every
+ * sanitizer stripped from every posted body; wrapped in the shared
+ * collapsed `<details>` block (attribution.ts). Rendering is pure and every
  * unstateable segment is omitted, never guessed.
  */
 
+const wrapped = (content: string): string => renderCollapsedFooter(content);
+
 const makeFakeFs = (
     files: Record<string, string> = {},
 ): VersionFooterFs & {files: Record<string, string>} => {
@@ -38,7 +42,7 @@ const REVIEW = "/tmp/gh-aw/review";
 const LIB = "/lib";
 
 describe("renderVersionFooter", () => {
-    it("renders every segment in order inside one <sub> line", () => {
+    it("renders every segment in order inside one collapsed <sub> line", () => {
         expect(
             renderVersionFooter({
                 version: "1.13.0",
@@ -49,7 +53,9 @@ describe("renderVersionFooter", () => {
                 enabledReviewers: ["holistic", "completeness"],
             }),
         ).toBe(
-            "<sub>review-v1.13.0 | schema 2 | depth scoped | re-review scoped blocking-only | enable holistic,completeness</sub>",
+            wrapped(
+                "review-v1.13.0 | schema 2 | depth scoped | re-review scoped blocking-only | enable holistic,completeness",
+            ),
         );
     });
 
@@ -64,7 +70,7 @@ describe("renderVersionFooter", () => {
                 enabledReviewers: [],
             }),
         ).toBe(
-            "<sub>review-v1.13.0 | schema 2 | depth full | re-review full</sub>",
+            wrapped("review-v1.13.0 | schema 2 | depth full | re-review full"),
         );
     });
 
@@ -78,7 +84,7 @@ describe("renderVersionFooter", () => {
                 blockingOnly: true,
                 enabledReviewers: [],
             }),
-        ).toBe("<sub>schema 2</sub>");
+        ).toBe(wrapped("schema 2"));
     });
 
     it("never emits an HTML comment (the sanitizer would delete it)", () => {
@@ -91,8 +97,8 @@ describe("renderVersionFooter", () => {
             enabledReviewers: ["holistic"],
         });
         expect(footer).not.toContain("<!--");
-        expect(footer.startsWith("<sub>")).toBe(true);
-        expect(footer.endsWith("</sub>")).toBe(true);
+        expect(footer.startsWith("<details>")).toBe(true);
+        expect(footer.endsWith("</details>")).toBe(true);
     });
 });
 
@@ -112,7 +118,9 @@ describe("runVersionFooterCli", () => {
         const fs = makeFakeFs(fullStaging());
         const footer = runVersionFooterCli(fs, LIB);
         expect(footer).toBe(
-            `<sub>review-v1.13.0 | schema ${FINDING_SCHEMA_VERSION} | depth scoped | re-review scoped blocking-only | enable holistic,documentation</sub>`,
+            wrapped(
+                `review-v1.13.0 | schema ${FINDING_SCHEMA_VERSION} | depth scoped | re-review scoped blocking-only | enable holistic,documentation`,
+            ),
         );
         expect(fs.files[FOOTER_OUT]).toBe(footer);
     });
@@ -150,7 +158,7 @@ describe("runVersionFooterCli", () => {
             [`${REVIEW}/routing.json`]: "not json",
         });
         expect(runVersionFooterCli(fs, LIB)).toBe(
-            `<sub>schema ${FINDING_SCHEMA_VERSION}</sub>`,
+            wrapped(`schema ${FINDING_SCHEMA_VERSION}`),
         );
     });
 
diff --git a/workflows/review/lib/version-footer.ts b/workflows/review/lib/version-footer.ts
index 60eae8c7..23b32bd0 100644
--- a/workflows/review/lib/version-footer.ts
+++ b/workflows/review/lib/version-footer.ts
@@ -1,26 +1,31 @@
 /**
- * The visible attribution footer: release version, finding-schema version,
+ * The version/config footer: release version, finding-schema version,
  * executed re-review depth, the repo's re-review mode line, and the ROUTING
- * enable list, rendered as one `<sub>` line appended to every submitted
- * review body and to the risks/patterns guidance comment.
+ * enable list, rendered as one `<sub>` line inside the shared collapsed
+ * `<details>` block (attribution.ts) appended to every submitted review
+ * body and to the risks/patterns guidance comment. Collapsed by default:
+ * the footer is run metadata, not review content, so it renders as one
+ * small summary chip until expanded.
  *
- * Why visible and why code-rendered: the original attribution surface was a
- * hidden HTML marker (`<!-- pr-reviewer:version ... -->`) the orchestrator
- * was prompted to compose, but gh-aw's safe-output ingest sanitizer deletes
- * ALL XML/HTML comments (`removeXmlComments` in `sanitize_content_core.cjs`;
- * the same strip that already killed the fingerprint stamp, see
- * rereview-mode.ts), so the marker never reached a single posted comment:
- * verified on all 9 guidance comments and 13 review bodies posted to
- * Khan/webapp on 2026-08-11/12. `<sub>` is on the sanitizer's allowed-tag
- * list (GFM-safe tags, sanitize_content_core.cjs v0.83.4), so this footer
- * survives ingest byte-for-byte; rendering it in code (from package.json and
- * the staged run files, never from the model's memory) keeps the attribution
- * trustworthy for rollback decisions.
+ * Why posted-and-visible-on-expand, and why code-rendered: the original
+ * attribution surface was a hidden HTML marker
+ * (`<!-- pr-reviewer:version ... -->`) the orchestrator was prompted to
+ * compose, but gh-aw's safe-output ingest sanitizer deletes ALL XML/HTML
+ * comments (`removeXmlComments` in `sanitize_content_core.cjs`; the same
+ * strip that already killed the fingerprint stamp, see rereview-mode.ts),
+ * so the marker never reached a single posted comment: verified on all 9
+ * guidance comments and 13 review bodies posted to Khan/webapp on
+ * 2026-08-11/12. `sub`, `details`, and `summary` are all on the sanitizer's
+ * allowed-tag list (GFM-safe tags, sanitize_content_core.cjs v0.83.4), so
+ * this footer survives ingest byte-for-byte; rendering it in code (from
+ * package.json and the staged run files, never from the model's memory)
+ * keeps the attribution trustworthy for rollback decisions.
  *
  * The hidden version marker instruction is retired from review.md Step 7;
  * the fingerprint stamp emission stays (rereview-mode.ts explains why).
  */
 
+import {renderCollapsedFooter} from "./attribution";
 import {FINDING_SCHEMA_VERSION} from "./finding-schema";
 
 const REVIEW_DIR = "/tmp/gh-aw/review";
@@ -51,10 +56,10 @@ export type VersionFooterInputs = {
 };
 
 /**
- * Render the footer line. Pure; every segment that cannot be stated is
- * omitted rather than guessed, so a degraded staging yields a shorter
- * footer, never a wrong one. Contains no HTML comment by construction (the
- * sanitizer would delete one).
+ * Render the collapsed footer block. Pure; every segment that cannot be
+ * stated is omitted rather than guessed, so a degraded staging yields a
+ * shorter footer, never a wrong one. Contains no HTML comment by
+ * construction (the sanitizer would delete one).
  */
 export const renderVersionFooter = (inputs: VersionFooterInputs): string => {
     const segments: string[] = [];
@@ -75,7 +80,7 @@ export const renderVersionFooter = (inputs: VersionFooterInputs): string => {
     if (inputs.enabledReviewers.length > 0) {
         segments.push(`enable ${inputs.enabledReviewers.join(",")}`);
     }
-    return `<sub>${segments.join(" | ")}</sub>`;
+    return renderCollapsedFooter(segments.join(" | "));
 };
 
 const readJson = (fs: VersionFooterFs, path: string): unknown => {
@@ -91,7 +96,7 @@ const readJson = (fs: VersionFooterFs, path: string): unknown => {
 
 /**
  * Compose the footer from the staged run files and stage it at
- * {@link FOOTER_OUT} (review.md Step 7 pastes the staged line verbatim into
+ * {@link FOOTER_OUT} (review.md Step 7 pastes the staged block verbatim into
  * the guidance comment; the submission CLI appends the returned string to
  * the review body). Reads:
  *
diff --git a/workflows/review/review.md b/workflows/review/review.md
index 7f867cfb..ea4d57a5 100644
--- a/workflows/review/review.md
+++ b/workflows/review/review.md
@@ -649,9 +649,11 @@ cd gh-aw-review-lib && npx -y tsx workflows/review/lib/submission.ts
 ```
    It reads `dispatch-result.json`, renders the accountability section
    (`rereview.json`), computes the verdict (Step 4's mechanical rule plus the
-   reduced-depth flip floor), renders every inline comment and the full
-   review body (note lines, the visible attribution footer, and the
-   fingerprint stamp included), and writes
+   reduced-depth flip floor), renders every inline comment (each with its
+   collapsed per-comment attribution footer naming the producing reviewer
+   and any merged duplicates) and the full review body (note lines, the
+   collapsed version/config footer, and the fingerprint stamp included),
+   and writes
    `/tmp/gh-aw/review/submission-plan.json`. At full depth it also
    stages `/tmp/gh-aw/review/risks-patterns-key.txt`, the code-computed
    canonical signature Step 7 compares (never compose your own signature in
@@ -722,7 +724,7 @@ never add, drop, reword, or re-anchor one.
 
 The review body and event are composed by the plan CLI (Step 3): the verdict
 head, the code-rendered re-review accountability section, every `Note:` line,
-the visible attribution footer, and the hidden fingerprint stamp are all
+the collapsed version/config footer, and the hidden fingerprint stamp are all
 already in the plan's `body`. Submit
 with **one** `submit-pull-request-review` call carrying the plan's `event` and
 `body` verbatim — except under the redundant-approval skip (Step 3), where you
@@ -808,8 +810,8 @@ should only ever be one current risks/patterns comment:
 Begin the comment with the exact marker line below (so the comment is identifiable
 on later runs), then include the Guidance for reviewers team sections and/or the
 common-patterns section. Omit whichever is empty. End the comment with the
-attribution footer: paste the one-line `<sub>...</sub>` footer from
-`/tmp/gh-aw/review/version-footer.txt` **verbatim** as the final line (the plan
+version/config footer: paste the collapsed `<details>` footer block from
+`/tmp/gh-aw/review/version-footer.txt` **verbatim** as the final lines (the plan
 CLI staged it in Step 3; if the file is missing, re-stage it with
 `cd gh-aw-review-lib && npx -y tsx workflows/review/lib/version-footer.ts`).
 Never compose the footer yourself, and never use an HTML comment for it: the
@@ -869,7 +871,9 @@ fully explained by a common pattern above:
 
 </details>
 
+<details><summary><sub>review details</sub></summary>
 <sub>review-v1.14.0 | schema 2 | depth full | re-review scoped blocking-only | enable holistic,completeness</sub>
+</details>
 ````
 
 - Title the comment `## Guidance for reviewers`, follow it with the one-line
@@ -1675,6 +1679,10 @@ Read from disk:
   producer's concrete failing scenario: specific inputs/state, then the wrong
   outcome), `confidence`, an optional
   `suggestion`, when the claim asserts a best-practice skill breach its `skill` name,
+  when cross-source dedup merged duplicate copies into it an `also_flagged_by`
+  list naming each other reviewer (with its anchor line where it differed, and
+  a clusterer-merged copy's own subject; treat those as corroboration to weigh,
+  never as extra claims to validate),
   and — when the claim re-raises a point the PR author has factually disputed in an
   existing review thread — an `author_dispute` quote of the author's grounds.
 - The diff: `/tmp/gh-aw/review/pr.diff`.