From 43b246e17b31df997312bb27f1264736ab359a0b Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Sun, 16 Aug 2026 15:34:47 +0000
Subject: [PATCH 1/4] fix(ui): show analysis-run digest prefixes on detail

The #89 review asked for 12-character code and config prefixes so an
operator can match the approved revision. Full digests stay on the API
only. Do not merge until this review item is checked.

Co-authored-by: Seongho Bae <seonghobae@users.noreply.github.com>
---
 frontend/src/App.test.tsx | 10 ++++++++++
 frontend/src/App.tsx      | 13 +++++++++++++
 frontend/src/api.ts       |  2 ++
 3 files changed, 25 insertions(+)

diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index a3da5de6b..570d9a684 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -190,6 +190,9 @@ describe("App, authenticated", () => {
               },
             ],
             visible_posts: [{ post_id: "post-1", post_title: "Public post" }],
+            code_revision_sha: "abcdef0123456789deadbeefcafebabe",
+            configuration_sha256:
+              "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
             status_history: [
               {
                 status_ordinal: 1,
@@ -1386,6 +1389,13 @@ describe("App, authenticated", () => {
     expect(await screen.findByRole("heading", { name: "Lineage reconstruction · Succeeded · Demo Corp" })).toBeInTheDocument();
     expect(screen.getByText(/Cutoff 2026-01-12/)).toBeInTheDocument();
     expect(screen.getByText(/Requested 2026-01-12/)).toBeInTheDocument();
+    const digests = screen.getByLabelText("Analysis run reproducibility digests");
+    expect(digests).toHaveTextContent("Code abcdef012345");
+    expect(digests).toHaveTextContent("Config 0123456789ab");
+    expect(digests).not.toHaveTextContent("abcdef0123456789deadbeefcafebabe");
+    expect(digests).not.toHaveTextContent(
+      "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+    );
     const history = screen.getByRole("list", { name: "Analysis run status history" });
     expect(history).toHaveTextContent("Pending 2026-01-12 12:31");
     expect(history).toHaveTextContent("Running 2026-01-12 12:32");
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index f866bb302..3952de96c 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1431,6 +1431,19 @@ function AnalysisRunsPanel({
             {" · "}
             Requested {selected.requested_at.slice(0, 10)}
           </p>
+          {(selected.code_revision_sha || selected.configuration_sha256) && (
+            <p className="post-meta" aria-label="Analysis run reproducibility digests">
+              {selected.code_revision_sha
+                ? `Code ${selected.code_revision_sha.slice(0, 12)}`
+                : ""}
+              {selected.code_revision_sha && selected.configuration_sha256
+                ? " · "
+                : ""}
+              {selected.configuration_sha256
+                ? `Config ${selected.configuration_sha256.slice(0, 12)}`
+                : ""}
+            </p>
+          )}
           <ul>
             {selected.source_counts.map((count) => (
               <li key={count.count_type_code}>
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index 3dacb054c..740529cba 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -521,6 +521,8 @@ export interface AnalysisRun {
   source_counts: AnalysisRunCount[];
   status_history?: AnalysisRunStatusEvent[];
   visible_posts?: { post_id: string; post_title: string }[];
+  code_revision_sha?: string;
+  configuration_sha256?: string;
 }
 
 export function fetchAnalysisRuns(accessToken: string): Promise<{ analysis_runs: AnalysisRun[] }> {

From d2574d25536c7be5c1297d5f68856b2eb2059ee3 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Sun, 16 Aug 2026 15:44:03 +0000
Subject: [PATCH 2/4] fix(ui): keep analysis-run digests audible and warn on
 live posts

aria-label on the digest paragraph hid the prefixes from assistive
technology. Move the label to a group, keep prefixes as visible text,
and put the full digest on hover. Tell the operator that a cutoff
title opens the live body so they compare it with the run clock.

Co-authored-by: Seongho Bae <seonghobae@users.noreply.github.com>
---
 ARCHITECTURE.md                               |  6 +-
 .../0.84.1-analysis-run-digest-a11y.md        |  5 ++
 CHANGELOG.md                                  | 13 ++++
 CLAUDE.md                                     |  3 +
 ...016-analysis-run-knowledge-cutoff-posts.md | 20 ++++-
 .../ANALYSIS_RUN_REGISTRY_REFERENCES.md       |  6 +-
 frontend/package.json                         |  2 +-
 frontend/src/App.css                          | 21 ++++-
 frontend/src/App.test.tsx                     | 31 +++++++-
 frontend/src/App.tsx                          | 76 +++++++++++++++----
 lineageweave/__init__.py                      |  2 +-
 pyproject.toml                                |  2 +-
 uv.lock                                       |  2 +-
 13 files changed, 161 insertions(+), 28 deletions(-)
 create mode 100644 CHANGELOG.d/0.84.1-analysis-run-digest-a11y.md

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index b662b00b1..ef6799146 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -471,8 +471,10 @@ revision and configuration digest prefixes.
 `tepp_client` on that same snapshot; the default transport is
 unavailable, so that run is Failed rather than a fabricated score.
 The home list is clickable: `GET /api/analysis-runs/{id}` fills a
-labeled detail (cutoff, requested date, counts, status history)
-without exposing a DSN or raw record. Status history is detail-only
+labeled detail (cutoff, requested date, 12-character digest prefixes
+with full digests on hover, counts, status history)
+without exposing a DSN or raw record. Opening a cutoff title warns
+that the live body may have changed after the run. Status history is detail-only
 and uses lookup labels plus occurrence times; a failure event keeps
 its machine `failure_code` rather than an invented caption. Failed
 list rows add a next-action line (open the run, then connect the
diff --git a/CHANGELOG.d/0.84.1-analysis-run-digest-a11y.md b/CHANGELOG.d/0.84.1-analysis-run-digest-a11y.md
new file mode 100644
index 000000000..213eb5451
--- /dev/null
+++ b/CHANGELOG.d/0.84.1-analysis-run-digest-a11y.md
@@ -0,0 +1,5 @@
+# 0.84.1 Analysis-run digest a11y and live-body warning
+
+Detail prefixes stay audible and hoverable. Open a cutoff title only
+after reading that the live body may have changed since the run.
+The list stays aggregates-only.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 22f4878b4..167fcdea0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,19 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.84.1] - 2026-08-16
+
+### Fixed
+
+- Analysis-run detail keeps 12-character digest prefixes as visible
+  text (so assistive technology hears `Code` / `Config` values) and
+  puts the full digest on hover. Open the Demo Corp lineage run, hover
+  a prefix, and match it to the API payload. The home list still hides
+  digests even when the list JSON includes them.
+- Opening a cutoff title now says the live body may have changed after
+  that run. Compare the opened post with the cutoff date before you
+  treat it as reconstructed evidence (ADR 0016).
+
 ## [0.84.0] - 2026-08-16
 
 ### Added
diff --git a/CLAUDE.md b/CLAUDE.md
index 3af72ad45..bfbd099ae 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -12,3 +12,6 @@ transport or an unused accepted envelope is Failed
 theta or a local psychometric substitute. The home list caption stays
 `kind · status · entity`; the machine failure code is detail-only
 (ADR 0014). Open the Failed row, then connect a live TEPP transport.
+Digest prefixes stay audible; hover a prefix to read the full digest.
+Opening a cutoff title shows the live post -- compare it with the
+cutoff before treating the body as reconstructed evidence (ADR 0016).
diff --git a/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md b/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
index d6ac70db8..f9c82a86d 100644
--- a/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
+++ b/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
@@ -25,7 +25,15 @@ every scope branch (corporate entity, process unit, thread group, and
 all-visible). ABAC visibility is applied after that temporal gate.
 Click-through still opens the live post body -- post versioning is a
 later slice -- but the run list itself must not advertise a post the
-run was not allowed to know.
+run was not allowed to know. The detail must say that next action
+plainly: compare the opened body with this cutoff before treating it
+as reconstructed evidence.
+
+Reproducibility digests on the same detail use a labeled group whose
+accessible name does not replace the visible prefixes (W3C Accessible
+Name and Description Computation 1.1). Full digests stay on `title`
+for hover verification and on the API payload; the home list stays
+aggregates-only.
 
 Seed and API fixtures backdate in-cutoff posts. A late own-corp private
 post remains on the live post list and stays out of the January 2026
@@ -36,8 +44,10 @@ run.
 - After `make seed`, the Demo Corp lineage run lists Demo public post
   and other in-cutoff Demo Corp titles. The later fixture account-review
   post (2026-02-10) does not appear.
-- Open the run, then open a listed post, to inspect what that cutoff
-  actually reconstructed.
+- Open the run, read the live-body warning, then open a listed post
+  and compare it with the cutoff date.
+- Hover a digest prefix to read the full code or configuration digest
+  when you need to match the API payload.
 - Post-body versioning at the cutoff remains future work.
 
 ## References
@@ -48,3 +58,7 @@ rules* (confirmed 2024; Amendment 1:2022).
 
 World Wide Web Consortium. (2022). *Time ontology in OWL* (W3C
 Recommendation). https://www.w3.org/TR/owl-time/
+
+World Wide Web Consortium. (2018). *Accessible name and description
+computation 1.1* (W3C Recommendation).
+https://www.w3.org/TR/accname-1.1/
diff --git a/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md b/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
index a1dc73957..b41b31c17 100644
--- a/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
+++ b/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
@@ -8,7 +8,8 @@
 | Source | Product implication | Implemented evidence |
 |---|---|---|
 | W3C PROV-DM and PROV-O | Preserve identifiable entities, activities, agents, generation/use, and derivation without flattening provenance into display-only edges. | `analysis_source_snapshot`, `analysis_run`, authenticated requester, append-only status events, immutable digests; later product bindings continue to use the separate `provenance_*` layer from ADR 0011. |
-| W3C Time Ontology in OWL | Keep temporal concepts explicit and avoid collapsing distinct clocks. | Evidence availability and snapshot capture remain on `analysis_source_snapshot`; analysis knowledge cutoff and request time remain on `analysis_run`; status occurrence and database record time remain distinct. `GET /api/analysis-runs/{id}` visible posts apply `created_at <= knowledge_cutoff` (ADR 0016). |
+| W3C Time Ontology in OWL | Keep temporal concepts explicit and avoid collapsing distinct clocks. | Evidence availability and snapshot capture remain on `analysis_source_snapshot`; analysis knowledge cutoff and request time remain on `analysis_run`; status occurrence and database record time remain distinct. `GET /api/analysis-runs/{id}` visible posts apply `created_at <= knowledge_cutoff` (ADR 0016). Opening a listed title warns that the live body may have changed after that cutoff. |
+| W3C Accessible Name and Description Computation 1.1 | Do not let `aria-label` replace visible text the operator must hear. | Analysis-run digest prefixes live in a labeled group; the prefixes remain the accessible contents and the full digest is on `title` for hover verification. |
 | ISO 8601-1:2019 | Use unambiguous timestamp representation and timezone-aware persistence. | PostgreSQL `timestamptz` for availability, capture, cutoff, request, occurrence, and record clocks; tests use explicit `Z` offsets. |
 | PostgreSQL 18 constraints and trigger contracts | Put integrity close to durable truth and use constraints for row shape while triggers enforce cross-row state and serialization. | Digest/check constraints, category allowlists, account-scoped uniqueness, shape constraints, immutable-row triggers, shared snapshot-row locking, and serialized status transitions. |
 | NIST SP 800-92 | Treat audit records as bounded, protected operational evidence rather than unstructured application logging. | Append-only status events, machine failure codes, actor identity, occurrence/record clocks, fail-closed rollback, and exclusion of raw source/provider payloads. |
@@ -98,5 +99,8 @@ PostgreSQL Global Development Group. (2026). *PostgreSQL 18 documentation:
 World Wide Web Consortium. (2013). *PROV-O: The PROV ontology* (W3C
 Recommendation). https://www.w3.org/TR/prov-o/
 
+World Wide Web Consortium. (2018). *Accessible name and description
+computation 1.1* (W3C Recommendation). https://www.w3.org/TR/accname-1.1/
+
 World Wide Web Consortium. (2022). *Time ontology in OWL* (W3C Recommendation).
 https://www.w3.org/TR/owl-time/
diff --git a/frontend/package.json b/frontend/package.json
index c21ed209f..8ce5f334b 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,7 +1,7 @@
 {
   "name": "frontend",
   "private": true,
-  "version": "0.84.0",
+  "version": "0.84.1",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/frontend/src/App.css b/frontend/src/App.css
index dfd0f2e81..8f38b4dd0 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -85,9 +85,26 @@
   cursor: pointer;
 }
 
+:root {
+  --lw-opacity-meta: 0.7;
+  --lw-font-size-meta: 0.85rem;
+}
+
 .post-meta {
-  opacity: 0.7;
-  font-size: 0.85rem;
+  opacity: var(--lw-opacity-meta);
+  font-size: var(--lw-font-size-meta);
+}
+
+.visually-hidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
 }
 
 .post-body {
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 65763b7fa..927a13144 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -283,6 +283,9 @@ describe("App, authenticated", () => {
                     count_value: 3,
                   },
                 ],
+                code_revision_sha: "abcdef0123456789deadbeefcafebabe",
+                configuration_sha256:
+                  "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
               },
               {
                 analysis_run_id: "run-demo-tepp",
@@ -1448,6 +1451,12 @@ describe("App, authenticated", () => {
     expect(list).toHaveTextContent("3 documents");
     expect(list).not.toHaveTextContent("postgresql://");
     expect(list).not.toHaveTextContent("select ");
+    expect(list).not.toHaveTextContent("Code abcdef012345");
+    expect(list).not.toHaveTextContent("Config 0123456789ab");
+    expect(list).not.toHaveTextContent("abcdef0123456789deadbeefcafebabe");
+    expect(list).not.toHaveTextContent(
+      "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+    );
 
     await userEvent.click(
       screen.getByRole("button", {
@@ -1458,21 +1467,39 @@ describe("App, authenticated", () => {
     expect(screen.getByText(/Cutoff 2026-01-12/)).toBeInTheDocument();
     expect(screen.getByText(/Requested 2026-01-12/)).toBeInTheDocument();
     const digests = screen.getByLabelText("Analysis run reproducibility digests");
+    expect(digests).toHaveTextContent("Hover a prefix to read the full digest for verification.");
     expect(digests).toHaveTextContent("Code abcdef012345");
     expect(digests).toHaveTextContent("Config 0123456789ab");
     expect(digests).not.toHaveTextContent("abcdef0123456789deadbeefcafebabe");
     expect(digests).not.toHaveTextContent(
       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
     );
+    expect(screen.getByTitle("abcdef0123456789deadbeefcafebabe")).toHaveTextContent("Code abcdef012345");
+    expect(
+      screen.getByTitle("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
+    ).toHaveTextContent("Config 0123456789ab");
     const history = screen.getByRole("list", { name: "Analysis run status history" });
     expect(history).toHaveTextContent("Pending 2026-01-12 12:31");
     expect(history).toHaveTextContent("Running 2026-01-12 12:32");
     expect(history).toHaveTextContent("Succeeded 2026-01-12 12:33");
     expect(screen.getByRole("list", { name: "Posts known at this run cutoff" })).toBeInTheDocument();
-    expect(screen.getByRole("button", { name: "Open run post: Public post" })).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        "Opening a title shows the live post. Compare it with cutoff 2026-01-12 before you treat the body as reconstructed evidence — it may have changed after this run.",
+      ),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", {
+        name: "Open live post (may have changed after cutoff): Public post",
+      }),
+    ).toBeInTheDocument();
     expect(screen.queryByText(/postgresql:\/\//)).not.toBeInTheDocument();
 
-    await userEvent.click(screen.getByRole("button", { name: "Open run post: Public post" }));
+    await userEvent.click(
+      screen.getByRole("button", {
+        name: "Open live post (may have changed after cutoff): Public post",
+      }),
+    );
     await waitFor(() => expect(screen.getByText("The full body text.")).toBeInTheDocument());
 
     await userEvent.click(
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 9d947ee47..fda1cdd57 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1395,6 +1395,62 @@ function analysisRunCorpusHint(run: AnalysisRun): string | null {
   );
 }
 
+/** Git-style prefix. The full digest stays on `title` for verification. */
+const ANALYSIS_RUN_DIGEST_PREFIX_LENGTH = 12;
+
+function analysisRunDigestPrefix(digest: string): string {
+  return digest.slice(0, ANALYSIS_RUN_DIGEST_PREFIX_LENGTH);
+}
+
+/**
+ * Next action when a cutoff title opens the live post (ADR 0016).
+ *
+ * Post-body versioning is a later slice. Until then the operator must
+ * compare the opened body with this run's cutoff instead of treating
+ * today's text as reconstructed evidence.
+ */
+function analysisRunLivePostWarning(cutoffIso: string): string {
+  const cutoffDate = cutoffIso.slice(0, 10);
+  return (
+    `Opening a title shows the live post. Compare it with cutoff ${cutoffDate} ` +
+    "before you treat the body as reconstructed evidence — it may have changed after this run."
+  );
+}
+
+function analysisRunLivePostButtonLabel(postTitle: string): string {
+  return `Open live post (may have changed after cutoff): ${postTitle}`;
+}
+
+function AnalysisRunReproducibilityDigests({
+  codeRevisionSha,
+  configurationSha256,
+}: {
+  codeRevisionSha?: string;
+  configurationSha256?: string;
+}) {
+  if (!codeRevisionSha && !configurationSha256) {
+    return null;
+  }
+  return (
+    <div role="group" aria-label="Analysis run reproducibility digests">
+      <p className="post-meta">
+        <span className="visually-hidden">
+          Hover a prefix to read the full digest for verification.{" "}
+        </span>
+        {codeRevisionSha ? (
+          <span title={codeRevisionSha}>{`Code ${analysisRunDigestPrefix(codeRevisionSha)}`}</span>
+        ) : null}
+        {codeRevisionSha && configurationSha256 ? " · " : null}
+        {configurationSha256 ? (
+          <span title={configurationSha256}>
+            {`Config ${analysisRunDigestPrefix(configurationSha256)}`}
+          </span>
+        ) : null}
+      </p>
+    </div>
+  );
+}
+
 function AnalysisRunsPanel({
   accessToken,
   onSelectPost,
@@ -1477,19 +1533,10 @@ function AnalysisRunsPanel({
             {" · "}
             Requested {selected.requested_at.slice(0, 10)}
           </p>
-          {(selected.code_revision_sha || selected.configuration_sha256) && (
-            <p className="post-meta" aria-label="Analysis run reproducibility digests">
-              {selected.code_revision_sha
-                ? `Code ${selected.code_revision_sha.slice(0, 12)}`
-                : ""}
-              {selected.code_revision_sha && selected.configuration_sha256
-                ? " · "
-                : ""}
-              {selected.configuration_sha256
-                ? `Config ${selected.configuration_sha256.slice(0, 12)}`
-                : ""}
-            </p>
-          )}
+          <AnalysisRunReproducibilityDigests
+            codeRevisionSha={selected.code_revision_sha}
+            configurationSha256={selected.configuration_sha256}
+          />
           <ul>
             {selected.source_counts.map((count) => (
               <li key={count.count_type_code}>
@@ -1510,12 +1557,13 @@ function AnalysisRunsPanel({
           {selected.visible_posts && selected.visible_posts.length > 0 ? (
             <>
               {corpusHint && <p className="post-meta">{corpusHint}</p>}
+              <p className="post-meta">{analysisRunLivePostWarning(selected.knowledge_cutoff)}</p>
               <ul aria-label="Posts known at this run cutoff">
                 {selected.visible_posts.map((post) => (
                   <li key={post.post_id}>
                     <button
                       className="keyman-select"
-                      aria-label={`Open run post: ${post.post_title}`}
+                      aria-label={analysisRunLivePostButtonLabel(post.post_title)}
                       onClick={() => onSelectPost(post.post_id)}
                     >
                       {post.post_title}
diff --git a/lineageweave/__init__.py b/lineageweave/__init__.py
index e89edfd07..65fa5d182 100644
--- a/lineageweave/__init__.py
+++ b/lineageweave/__init__.py
@@ -55,4 +55,4 @@
     "sentence_excerpts",
 ]
 
-__version__ = "0.84.0"
+__version__ = "0.84.1"
diff --git a/pyproject.toml b/pyproject.toml
index ed229d426..b27655c2b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "lineageweave"
-version = "0.84.0"
+version = "0.84.1"
 description = "Reconstructs git-branch-style lineage DAGs from scattered short records using multi-channel score fusion and LLM adjudication."
 readme = "README.md"
 license = { text = "MIT" }
diff --git a/uv.lock b/uv.lock
index 411243f56..156b0813d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -454,7 +454,7 @@ wheels = [
 
 [[package]]
 name = "lineageweave"
-version = "0.84.0"
+version = "0.84.1"
 source = { virtual = "." }
 dependencies = [
     { name = "certifi" },

From 85d39735db51590fee9efdfe5592cc1047355ee4 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Sun, 16 Aug 2026 15:44:11 +0000
Subject: [PATCH 3/4] docs: mark analysis-run seed pointer as v0.84.1

Co-authored-by: Seongho Bae <seonghobae@users.noreply.github.com>
---
 CLAUDE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index bfbd099ae..6f7f076f5 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -3,7 +3,7 @@
 Tool-specific pointer. Policy lives in [AGENTS.md](AGENTS.md) and the
 ADRs under `docs/adr/`. Do not fork those rules here.
 
-## Analysis-run seed (v0.84.0)
+## Analysis-run seed (v0.84.1)
 
 `make seed` writes a Demo Corp lineage run and a TEPP run on the same
 snapshot (ADR 0013). The TEPP path goes through `tepp_client`. A missing

From a3c26009506b0728a8676ab7531a937d06e33502 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Sun, 16 Aug 2026 15:53:20 +0000
Subject: [PATCH 4/4] feat: compare live post write clock with analysis-run
 cutoff

Opening a cutoff title still loads today's body. Surface source_post.updated_at
against the run clock so an operator can refuse a later rewrite as
reconstructed evidence. Historical seed rows keep updated_at = created_at.

Co-authored-by: Seongho Bae <seonghobae@users.noreply.github.com>
---
 ARCHITECTURE.md                               |  5 ++-
 .../0.84.2-analysis-run-live-write-clock.md   |  4 ++
 CHANGELOG.md                                  | 14 +++++++
 CLAUDE.md                                     |  7 ++--
 backend/app/analysis_run_ingestion.py         | 18 ++++++---
 backend/app/main.py                           | 11 ++++--
 ...016-analysis-run-knowledge-cutoff-posts.md |  9 +++--
 .../ANALYSIS_RUN_REGISTRY_REFERENCES.md       |  2 +-
 frontend/package.json                         |  2 +-
 frontend/src/App.test.tsx                     | 31 +++++++++++++++
 frontend/src/App.tsx                          | 38 ++++++++++++++-----
 frontend/src/analysisRunLiveBody.test.ts      | 20 ++++++++++
 frontend/src/analysisRunLiveBody.ts           | 31 +++++++++++++++
 frontend/src/api.ts                           |  3 +-
 lineageweave/__init__.py                      |  4 +-
 lineageweave/analysis_run_live_body.py        | 30 +++++++++++++++
 migrations/0019_source_post_write_clock.sql   | 22 +++++++++++
 .../rollback/0019_source_post_write_clock.sql |  5 +++
 pyproject.toml                                |  2 +-
 scripts/seed_demo_data.py                     | 31 ++++++++-------
 tests/test_analysis_run_live_body.py          | 32 ++++++++++++++++
 uv.lock                                       |  2 +-
 22 files changed, 280 insertions(+), 43 deletions(-)
 create mode 100644 CHANGELOG.d/0.84.2-analysis-run-live-write-clock.md
 create mode 100644 frontend/src/analysisRunLiveBody.test.ts
 create mode 100644 frontend/src/analysisRunLiveBody.ts
 create mode 100644 lineageweave/analysis_run_live_body.py
 create mode 100644 migrations/0019_source_post_write_clock.sql
 create mode 100644 migrations/rollback/0019_source_post_write_clock.sql
 create mode 100644 tests/test_analysis_run_live_body.py

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index ef6799146..044ba479c 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -474,7 +474,10 @@ The home list is clickable: `GET /api/analysis-runs/{id}` fills a
 labeled detail (cutoff, requested date, 12-character digest prefixes
 with full digests on hover, counts, status history)
 without exposing a DSN or raw record. Opening a cutoff title warns
-that the live body may have changed after the run. Status history is detail-only
+that the live body may have changed after the run, then compares the
+live ``updated_at`` write clock with that cutoff so the operator can
+decide whether to treat the opened text as reconstructed evidence.
+Status history is detail-only
 and uses lookup labels plus occurrence times; a failure event keeps
 its machine `failure_code` rather than an invented caption. Failed
 list rows add a next-action line (open the run, then connect the
diff --git a/CHANGELOG.d/0.84.2-analysis-run-live-write-clock.md b/CHANGELOG.d/0.84.2-analysis-run-live-write-clock.md
new file mode 100644
index 000000000..22216cf67
--- /dev/null
+++ b/CHANGELOG.d/0.84.2-analysis-run-live-write-clock.md
@@ -0,0 +1,4 @@
+# 0.84.2 Analysis-run live write clock
+
+Open a cutoff title, then read whether the live body was written after
+that run. Do not treat a later rewrite as reconstructed evidence.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 167fcdea0..767a80ecc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,20 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.84.2] - 2026-08-16
+
+### Added
+
+- Opening a cutoff title now compares the live `source_post.updated_at`
+  write clock with that run's knowledge cutoff. Open the Demo Corp
+  lineage run, then a listed title: if the body was rewritten after
+  2026-01-12, do not treat it as reconstructed evidence. A write clock
+  at or before the cutoff tells you the opened text is still the
+  cutoff corpus. Post-body versioning remains later work (ADR 0016).
+- `GET /api/posts` and `GET /api/posts/{id}` include `updated_at`.
+  Seed historical Demo posts keep `updated_at = created_at` so the
+  January run does not look rewritten at seed time.
+
 ## [0.84.1] - 2026-08-16
 
 ### Fixed
diff --git a/CLAUDE.md b/CLAUDE.md
index 6f7f076f5..ca0564826 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -3,7 +3,7 @@
 Tool-specific pointer. Policy lives in [AGENTS.md](AGENTS.md) and the
 ADRs under `docs/adr/`. Do not fork those rules here.
 
-## Analysis-run seed (v0.84.1)
+## Analysis-run seed (v0.84.2)
 
 `make seed` writes a Demo Corp lineage run and a TEPP run on the same
 snapshot (ADR 0013). The TEPP path goes through `tepp_client`. A missing
@@ -13,5 +13,6 @@ theta or a local psychometric substitute. The home list caption stays
 `kind · status · entity`; the machine failure code is detail-only
 (ADR 0014). Open the Failed row, then connect a live TEPP transport.
 Digest prefixes stay audible; hover a prefix to read the full digest.
-Opening a cutoff title shows the live post -- compare it with the
-cutoff before treating the body as reconstructed evidence (ADR 0016).
+Opening a cutoff title shows the live post and compares its
+``updated_at`` write clock with the run cutoff before you treat the
+body as reconstructed evidence (ADR 0016).
diff --git a/backend/app/analysis_run_ingestion.py b/backend/app/analysis_run_ingestion.py
index e96c2b7c4..d72d877be 100644
--- a/backend/app/analysis_run_ingestion.py
+++ b/backend/app/analysis_run_ingestion.py
@@ -244,10 +244,12 @@ async def fetch_visible_scope_posts(
 
     ``knowledge_cutoff`` is the analysis clock (W3C Time / ISO 8601-1:2019;
     ADR 0013/0016). A later live post must not appear inside an earlier run.
+    ``updated_at`` is the live write clock so the operator can compare
+    today's body with that cutoff before treating it as evidence.
     """
     if scope_kind_code == "analysis_scope_corporate_entity" and corporate_entity_id:
         rows = await conn.fetch(
-            "select post_id, post_title, visibility_code, corporate_entity_id "
+            "select post_id, post_title, visibility_code, corporate_entity_id, updated_at "
             "from source_post where corporate_entity_id = $1 "
             "and created_at <= $2 "
             "order by created_at, post_title",
@@ -256,7 +258,7 @@ async def fetch_visible_scope_posts(
         )
     elif scope_kind_code == "analysis_scope_process_unit" and process_unit_id:
         rows = await conn.fetch(
-            "select post_id, post_title, visibility_code, corporate_entity_id "
+            "select post_id, post_title, visibility_code, corporate_entity_id, updated_at "
             "from source_post where process_unit_id = $1 "
             "and created_at <= $2 "
             "order by created_at, post_title",
@@ -265,7 +267,7 @@ async def fetch_visible_scope_posts(
         )
     elif scope_kind_code == "analysis_scope_thread_group" and scope_key:
         rows = await conn.fetch(
-            "select post_id, post_title, visibility_code, corporate_entity_id "
+            "select post_id, post_title, visibility_code, corporate_entity_id, updated_at "
             "from source_post where thread_group_key = $1 "
             "and created_at <= $2 "
             "order by created_at, post_title",
@@ -274,7 +276,7 @@ async def fetch_visible_scope_posts(
         )
     elif scope_kind_code == "analysis_scope_all_visible":
         rows = await conn.fetch(
-            "select post_id, post_title, visibility_code, corporate_entity_id "
+            "select post_id, post_title, visibility_code, corporate_entity_id, updated_at "
             "from source_post where created_at <= $1 "
             "order by created_at, post_title",
             knowledge_cutoff,
@@ -287,5 +289,11 @@ async def fetch_visible_scope_posts(
         visible = row["visibility_code"] == "public" or str(row["corporate_entity_id"]) in affiliated
         if not visible:
             continue
-        posts.append({"post_id": str(row["post_id"]), "post_title": row["post_title"]})
+        posts.append(
+            {
+                "post_id": str(row["post_id"]),
+                "post_title": row["post_title"],
+                "updated_at": _iso(row["updated_at"]),
+            }
+        )
     return posts
diff --git a/backend/app/main.py b/backend/app/main.py
index e77b173bc..746890162 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -278,7 +278,11 @@ def _can_see_post(account: CurrentAccount, post: asyncpg.Record) -> bool:
 
 
 def _serialize_post(post: asyncpg.Record, labels: dict[str, str] | None = None) -> dict[str, Any]:
-    """Turn a ``source_post`` row into the public JSON shape."""
+    """Turn a ``source_post`` row into the public JSON shape.
+
+    ``updated_at`` is the live write clock the analysis-run popup
+    compares with ``knowledge_cutoff`` (ADR 0016).
+    """
     resolved = labels or {}
     voc = post["voc_type_code"]
     visibility = post["visibility_code"]
@@ -290,6 +294,7 @@ def _serialize_post(post: asyncpg.Record, labels: dict[str, str] | None = None)
         "visibility_code": visibility,
         "visibility_label": resolved.get(visibility, visibility),
         "created_at": post["created_at"].isoformat(),
+        "updated_at": post["updated_at"].isoformat(),
     }
 
 
@@ -351,7 +356,7 @@ async def list_posts(
     _require_post_read(account)
     async with pool.acquire() as conn:
         rows = await conn.fetch(
-            "select post_id, post_title, voc_type_code, visibility_code, corporate_entity_id, created_at "
+            "select post_id, post_title, voc_type_code, visibility_code, corporate_entity_id, created_at, updated_at "
             "from source_post order by created_at desc"
         )
         visible = [row for row in rows if _can_see_post(account, row)]
@@ -369,7 +374,7 @@ async def read_post(
     _require_post_read(account)
     async with pool.acquire() as conn:
         row = await conn.fetchrow(
-            "select post_id, post_title, post_body, voc_type_code, visibility_code, corporate_entity_id, created_at "
+            "select post_id, post_title, post_body, voc_type_code, visibility_code, corporate_entity_id, created_at, updated_at "
             "from source_post where post_id = $1",
             post_id,
         )
diff --git a/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md b/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
index f9c82a86d..dbb48eebd 100644
--- a/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
+++ b/docs/adr/0016-analysis-run-knowledge-cutoff-posts.md
@@ -44,11 +44,14 @@ run.
 - After `make seed`, the Demo Corp lineage run lists Demo public post
   and other in-cutoff Demo Corp titles. The later fixture account-review
   post (2026-02-10) does not appear.
-- Open the run, read the live-body warning, then open a listed post
-  and compare it with the cutoff date.
+- Open the run, read the live-body warning, then open a listed post.
+  The opened popup compares ``source_post.updated_at`` with this
+  cutoff. If the live row was written after the run, do not treat the
+  body as reconstructed evidence.
 - Hover a digest prefix to read the full code or configuration digest
   when you need to match the API payload.
-- Post-body versioning at the cutoff remains future work.
+- Post-body versioning at the cutoff remains future work. The write
+  clock comparison is the operator action until that snapshot exists.
 
 ## References
 
diff --git a/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md b/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
index b41b31c17..74c308d25 100644
--- a/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
+++ b/docs/doctoring/ANALYSIS_RUN_REGISTRY_REFERENCES.md
@@ -8,7 +8,7 @@
 | Source | Product implication | Implemented evidence |
 |---|---|---|
 | W3C PROV-DM and PROV-O | Preserve identifiable entities, activities, agents, generation/use, and derivation without flattening provenance into display-only edges. | `analysis_source_snapshot`, `analysis_run`, authenticated requester, append-only status events, immutable digests; later product bindings continue to use the separate `provenance_*` layer from ADR 0011. |
-| W3C Time Ontology in OWL | Keep temporal concepts explicit and avoid collapsing distinct clocks. | Evidence availability and snapshot capture remain on `analysis_source_snapshot`; analysis knowledge cutoff and request time remain on `analysis_run`; status occurrence and database record time remain distinct. `GET /api/analysis-runs/{id}` visible posts apply `created_at <= knowledge_cutoff` (ADR 0016). Opening a listed title warns that the live body may have changed after that cutoff. |
+| W3C Time Ontology in OWL | Keep temporal concepts explicit and avoid collapsing distinct clocks. | Evidence availability and snapshot capture remain on `analysis_source_snapshot`; analysis knowledge cutoff and request time remain on `analysis_run`; status occurrence and database record time remain distinct. `GET /api/analysis-runs/{id}` visible posts apply `created_at <= knowledge_cutoff` (ADR 0016). Opening a listed title compares the live `updated_at` write clock with that cutoff. |
 | W3C Accessible Name and Description Computation 1.1 | Do not let `aria-label` replace visible text the operator must hear. | Analysis-run digest prefixes live in a labeled group; the prefixes remain the accessible contents and the full digest is on `title` for hover verification. |
 | ISO 8601-1:2019 | Use unambiguous timestamp representation and timezone-aware persistence. | PostgreSQL `timestamptz` for availability, capture, cutoff, request, occurrence, and record clocks; tests use explicit `Z` offsets. |
 | PostgreSQL 18 constraints and trigger contracts | Put integrity close to durable truth and use constraints for row shape while triggers enforce cross-row state and serialization. | Digest/check constraints, category allowlists, account-scoped uniqueness, shape constraints, immutable-row triggers, shared snapshot-row locking, and serialized status transitions. |
diff --git a/frontend/package.json b/frontend/package.json
index 8ce5f334b..72de2d8af 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,7 +1,7 @@
 {
   "name": "frontend",
   "private": true,
-  "version": "0.84.1",
+  "version": "0.84.2",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 927a13144..bba17b3d7 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -59,6 +59,7 @@ describe("App, authenticated", () => {
     chatUnavailable?: boolean;
     searchUnavailable?: boolean;
     verificationEvidenceUrl?: string | null;
+    postUpdatedAt?: string;
   }) {
     const statusLabel: Record<string, string> = {
       open: "Open",
@@ -550,6 +551,7 @@ describe("App, authenticated", () => {
             visibility_code: "public",
             visibility_label: "Public",
             created_at: "2026-01-01T00:00:00Z",
+            updated_at: options?.postUpdatedAt ?? "2026-01-01T00:00:00Z",
           }),
         );
       }
@@ -1516,6 +1518,35 @@ describe("App, authenticated", () => {
     expect(teppHistory).not.toHaveTextContent("Succeeded");
   });
 
+  it("compares the live write clock with the run cutoff when a cutoff title is opened", async () => {
+    stubBackend({ postUpdatedAt: "2026-02-01T00:00:00Z" });
+    render(<App />);
+
+    await userEvent.click(
+      await screen.findByRole("button", {
+        name: "Open analysis run: Lineage reconstruction · Succeeded · Demo Corp",
+      }),
+    );
+    await userEvent.click(
+      screen.getByRole("button", {
+        name: "Open live post (may have changed after cutoff): Public post",
+      }),
+    );
+    expect(
+      await screen.findByText(
+        "This live body was last written after cutoff 2026-01-12. Do not treat it as reconstructed evidence.",
+      ),
+    ).toBeInTheDocument();
+
+    await userEvent.click(screen.getByRole("button", { name: "Close" }));
+    await userEvent.click(await screen.findByRole("button", { name: "View post: Public post" }));
+    await waitFor(() => expect(screen.getByText("The full body text.")).toBeInTheDocument());
+    expect(
+      screen.queryByText(/This live body was last written after cutoff/),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText(/has not been written since cutoff/)).not.toBeInTheDocument();
+  });
+
   it("shows the calibrated period-report mean theta on the home page", async () => {
     stubBackend();
     render(<App />);
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index fda1cdd57..272a40403 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -55,6 +55,7 @@ import {
   type RelatedNode,
   type VocEvidence,
 } from "./api";
+import { analysisRunLiveBodyComparison } from "./analysisRunLiveBody";
 import { LineageDag } from "./LineageDag";
 import { subgraphForPost } from "./lineageLayout";
 import "./App.css";
@@ -1106,6 +1107,7 @@ function PostDetailPopup({
   accessToken,
   canExtract,
   graph,
+  knowledgeCutoff,
   onClose,
   onSelectPost,
 }: {
@@ -1113,6 +1115,7 @@ function PostDetailPopup({
   accessToken: string;
   canExtract: boolean;
   graph: LineageGraph | null;
+  knowledgeCutoff?: string | null;
   onClose: () => void;
   onSelectPost?: (postId: string) => void;
 }) {
@@ -1187,6 +1190,11 @@ function PostDetailPopup({
               {post.visibility_label ?? post.visibility_code} &middot;{" "}
               {new Date(post.created_at).toLocaleString()}
             </p>
+            {knowledgeCutoff && post.updated_at ? (
+              <p className="post-meta">
+                {analysisRunLiveBodyComparison(knowledgeCutoff, post.updated_at)}
+              </p>
+            ) : null}
             <p className="post-body">{post.post_body}</p>
 
             <section className="popup-section">
@@ -1456,7 +1464,7 @@ function AnalysisRunsPanel({
   onSelectPost,
 }: {
   accessToken: string;
-  onSelectPost: (postId: string) => void;
+  onSelectPost: (postId: string, knowledgeCutoff?: string) => void;
 }) {
   const [runs, setRuns] = useState<AnalysisRun[] | null>(null);
   const [selected, setSelected] = useState<AnalysisRun | null>(null);
@@ -1564,7 +1572,7 @@ function AnalysisRunsPanel({
                     <button
                       className="keyman-select"
                       aria-label={analysisRunLivePostButtonLabel(post.post_title)}
-                      onClick={() => onSelectPost(post.post_id)}
+                      onClick={() => onSelectPost(post.post_id, selected.knowledge_cutoff)}
                     >
                       {post.post_title}
                     </button>
@@ -1837,10 +1845,21 @@ function PostList({ accessToken }: { accessToken: string }) {
   const [graph, setGraph] = useState<LineageGraph | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [selectedPostId, setSelectedPostId] = useState<string | null>(null);
+  const [openedFromCutoff, setOpenedFromCutoff] = useState<string | null>(null);
   const [canRebuild, setCanRebuild] = useState(false);
   const [rebuilding, setRebuilding] = useState(false);
   const [rebuildError, setRebuildError] = useState<string | null>(null);
 
+  function selectPost(postId: string, knowledgeCutoff?: string) {
+    setSelectedPostId(postId);
+    setOpenedFromCutoff(knowledgeCutoff ?? null);
+  }
+
+  function closePost() {
+    setSelectedPostId(null);
+    setOpenedFromCutoff(null);
+  }
+
   useEffect(() => {
     fetchPosts(accessToken).then(setPosts).catch((err) => setError(String(err)));
     fetchLineageGraph(accessToken).then(setGraph).catch(() => setGraph({ nodes: [], edges: [] }));
@@ -1868,9 +1887,9 @@ function PostList({ accessToken }: { accessToken: string }) {
 
   return (
     <>
-      <CalendarPanel accessToken={accessToken} onSelectPost={setSelectedPostId} />
-      <AnalysisRunsPanel accessToken={accessToken} onSelectPost={setSelectedPostId} />
-      <ReportsPanel accessToken={accessToken} canRebuild={canRebuild} onSelectPost={setSelectedPostId} />
+      <CalendarPanel accessToken={accessToken} onSelectPost={selectPost} />
+      <AnalysisRunsPanel accessToken={accessToken} onSelectPost={selectPost} />
+      <ReportsPanel accessToken={accessToken} canRebuild={canRebuild} onSelectPost={selectPost} />
       <section className="popup-section lineage-home">
         <div className="lineage-home-header">
           <h2>Event Lineage</h2>
@@ -1882,7 +1901,7 @@ function PostList({ accessToken }: { accessToken: string }) {
         </div>
         {rebuildError && <p className="error">{rebuildError}</p>}
         {!graph && <p>Loading lineage graph...</p>}
-        {graph && <LineageDag graph={graph} onSelectPost={setSelectedPostId} />}
+        {graph && <LineageDag graph={graph} onSelectPost={selectPost} />}
       </section>
       <ul className="post-list">
         {posts.map((post) => (
@@ -1890,7 +1909,7 @@ function PostList({ accessToken }: { accessToken: string }) {
             <button
               className="post-list-item"
               aria-label={`View post: ${post.post_title}`}
-              onClick={() => setSelectedPostId(post.post_id)}
+              onClick={() => selectPost(post.post_id)}
             >
               <span className="post-title">{post.post_title}</span>
               <span className="post-badge">{post.voc_type_label ?? post.voc_type_code}</span>
@@ -1905,8 +1924,9 @@ function PostList({ accessToken }: { accessToken: string }) {
           accessToken={accessToken}
           canExtract={canRebuild}
           graph={graph}
-          onClose={() => setSelectedPostId(null)}
-          onSelectPost={setSelectedPostId}
+          knowledgeCutoff={openedFromCutoff}
+          onClose={closePost}
+          onSelectPost={(postId) => selectPost(postId)}
         />
       )}
     </>
diff --git a/frontend/src/analysisRunLiveBody.test.ts b/frontend/src/analysisRunLiveBody.test.ts
new file mode 100644
index 000000000..8c2af1840
--- /dev/null
+++ b/frontend/src/analysisRunLiveBody.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { analysisRunLiveBodyComparison } from "./analysisRunLiveBody";
+
+describe("analysisRunLiveBodyComparison", () => {
+  it("tells the operator not to treat a post-cutoff rewrite as evidence", () => {
+    expect(
+      analysisRunLiveBodyComparison("2026-01-12T12:00:00Z", "2026-02-01T00:00:00Z"),
+    ).toBe(
+      "This live body was last written after cutoff 2026-01-12. Do not treat it as reconstructed evidence.",
+    );
+  });
+
+  it("confirms a write clock that is still inside the cutoff", () => {
+    expect(
+      analysisRunLiveBodyComparison("2026-01-12T12:00:00Z", "2026-01-10T12:00:00Z"),
+    ).toBe(
+      "This live body has not been written since cutoff 2026-01-12. You can treat the opened text as the cutoff corpus for this run.",
+    );
+  });
+});
diff --git a/frontend/src/analysisRunLiveBody.ts b/frontend/src/analysisRunLiveBody.ts
new file mode 100644
index 000000000..b995f83f1
--- /dev/null
+++ b/frontend/src/analysisRunLiveBody.ts
@@ -0,0 +1,31 @@
+/**
+ * Compare a live post write clock with an analysis-run knowledge cutoff.
+ *
+ * Post-body versioning is later work (ADR 0016). Until a cutoff snapshot
+ * exists, the operator must see whether today's row was written after
+ * the analysis clock before treating the opened text as evidence.
+ *
+ * World Wide Web Consortium. (2022). *Time ontology in OWL* (W3C
+ * Recommendation). https://www.w3.org/TR/owl-time/
+ *
+ * International Organization for Standardization. (2019).
+ * *ISO 8601-1:2019: Date and time—Representations for information
+ * interchange—Part 1: Basic rules*.
+ */
+export function analysisRunLiveBodyComparison(
+  knowledgeCutoffIso: string,
+  updatedAtIso: string,
+): string {
+  const cutoffDate = knowledgeCutoffIso.slice(0, 10);
+  const writtenAfterCutoff = Date.parse(updatedAtIso) > Date.parse(knowledgeCutoffIso);
+  if (writtenAfterCutoff) {
+    return (
+      `This live body was last written after cutoff ${cutoffDate}. ` +
+      "Do not treat it as reconstructed evidence."
+    );
+  }
+  return (
+    `This live body has not been written since cutoff ${cutoffDate}. ` +
+    "You can treat the opened text as the cutoff corpus for this run."
+  );
+}
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index 740529cba..33de7d85d 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -8,6 +8,7 @@ export interface PostSummary {
   visibility_code: string;
   visibility_label?: string;
   created_at: string;
+  updated_at?: string;
 }
 
 export interface PostDetail extends PostSummary {
@@ -520,7 +521,7 @@ export interface AnalysisRun {
   requested_at: string;
   source_counts: AnalysisRunCount[];
   status_history?: AnalysisRunStatusEvent[];
-  visible_posts?: { post_id: string; post_title: string }[];
+  visible_posts?: { post_id: string; post_title: string; updated_at?: string }[];
   code_revision_sha?: string;
   configuration_sha256?: string;
 }
diff --git a/lineageweave/__init__.py b/lineageweave/__init__.py
index 65fa5d182..7db806e74 100644
--- a/lineageweave/__init__.py
+++ b/lineageweave/__init__.py
@@ -8,6 +8,7 @@
 """
 
 from .affiliate_tree import build_affiliate_forest
+from .analysis_run_live_body import live_body_written_after_cutoff
 from .corporate_hierarchy_resolution import resolve_corporate_entity
 from .entity_relationship_classification import OrganizationRelationship
 from .knowledge_graph import random_walk_with_restart, select_related_nodes
@@ -46,6 +47,7 @@
     "Record",
     "Tree",
     "build_affiliate_forest",
+    "live_body_written_after_cutoff",
     "cited_post_summaries",
     "lineage_edge_specs",
     "random_walk_with_restart",
@@ -55,4 +57,4 @@
     "sentence_excerpts",
 ]
 
-__version__ = "0.84.1"
+__version__ = "0.84.2"
diff --git a/lineageweave/analysis_run_live_body.py b/lineageweave/analysis_run_live_body.py
new file mode 100644
index 000000000..c89bf1ca3
--- /dev/null
+++ b/lineageweave/analysis_run_live_body.py
@@ -0,0 +1,30 @@
+"""Compare a live ``source_post`` write clock with an analysis-run cutoff.
+
+The registry lists titles by ``created_at <= knowledge_cutoff`` (ADR 0016).
+That inclusion clock is not the live row's write clock. A later rewrite
+of an in-cutoff title must not be treated as reconstructed evidence.
+
+World Wide Web Consortium. (2022). *Time ontology in OWL* (W3C
+Recommendation). https://www.w3.org/TR/owl-time/
+
+International Organization for Standardization. (2019). *ISO 8601-1:2019:
+Date and time—Representations for information interchange—Part 1: Basic
+rules* (confirmed 2024; Amendment 1:2022).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+
+def live_body_written_after_cutoff(
+    knowledge_cutoff: datetime,
+    updated_at: datetime,
+) -> bool:
+    """Return True when the live row was written after the analysis clock.
+
+    Both arguments must be timezone-aware instants. A write exactly at
+    the cutoff stays inside the run (the same ``<=`` gate as title
+    inclusion).
+    """
+    return updated_at > knowledge_cutoff
diff --git a/migrations/0019_source_post_write_clock.sql b/migrations/0019_source_post_write_clock.sql
new file mode 100644
index 000000000..e57e85d5b
--- /dev/null
+++ b/migrations/0019_source_post_write_clock.sql
@@ -0,0 +1,22 @@
+-- Keep source_post.updated_at as the live write clock (ADR 0016).
+-- An explicit updated_at in the UPDATE is honored so historical seed
+-- rows can keep their authoring instant. Otherwise the trigger stamps
+-- now(). Two-word relation and column names stay snake_case.
+
+create or replace function set_source_post_updated_at()
+returns trigger
+language plpgsql
+as $$
+begin
+    if new.updated_at is not distinct from old.updated_at then
+        new.updated_at = now();
+    end if;
+    return new;
+end;
+$$;
+
+drop trigger if exists source_post_set_updated_at on source_post;
+create trigger source_post_set_updated_at
+    before update on source_post
+    for each row
+    execute function set_source_post_updated_at();
diff --git a/migrations/rollback/0019_source_post_write_clock.sql b/migrations/rollback/0019_source_post_write_clock.sql
new file mode 100644
index 000000000..bb105e80e
--- /dev/null
+++ b/migrations/rollback/0019_source_post_write_clock.sql
@@ -0,0 +1,5 @@
+-- Remove the live write-clock trigger. The updated_at column remains
+-- on source_post from the initial schema.
+
+drop trigger if exists source_post_set_updated_at on source_post;
+drop function if exists set_source_post_updated_at();
diff --git a/pyproject.toml b/pyproject.toml
index b27655c2b..06b75e404 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "lineageweave"
-version = "0.84.1"
+version = "0.84.2"
 description = "Reconstructs git-branch-style lineage DAGs from scattered short records using multi-channel score fusion and LLM adjudication."
 readme = "README.md"
 license = { text = "MIT" }
diff --git a/scripts/seed_demo_data.py b/scripts/seed_demo_data.py
index f6f575ccc..a92d00773 100644
--- a/scripts/seed_demo_data.py
+++ b/scripts/seed_demo_data.py
@@ -120,6 +120,7 @@ def seed(
             cur.execute((migrations / "0015_organization_name_resolution.sql").read_text())
             cur.execute((migrations / "0016_cross_post_actor_identity.sql").read_text())
             cur.execute((migrations / "0018_analysis_run_registry.sql").read_text())
+            cur.execute((migrations / "0019_source_post_write_clock.sql").read_text())
             cur.execute(
                 """
                 insert into common_lookup_value (lookup_category, lookup_code, lookup_label, display_order) values
@@ -231,27 +232,28 @@ def seed(
             cur.execute("select post_id from source_post where post_title = 'Demo public post'")
             if cur.fetchone() is None:
                 cur.execute(
-                    "insert into source_post (author_account_id, corporate_entity_id, process_unit_id, post_title, post_body, voc_type_code, visibility_code, created_at) "
+                    "insert into source_post (author_account_id, corporate_entity_id, process_unit_id, post_title, post_body, voc_type_code, visibility_code, created_at, updated_at) "
                     "values (%s, %s, %s, 'Demo public post', "
                     "'Ada West at Demo Corp followed up with Priya Nair at Northridge Grid about the delayed shipment.', "
-                    "'voc', 'public', '2026-01-10T12:00:00Z')",
+                    "'voc', 'public', '2026-01-10T12:00:00Z', '2026-01-10T12:00:00Z')",
                     (account_ids["demo.analyst"], corporate_entity_id, process_units["DEMO-PU-A"]),
                 )
                 cur.execute(
-                    "insert into source_post (author_account_id, corporate_entity_id, process_unit_id, post_title, post_body, voc_type_code, visibility_code, created_at) "
-                    "values (%s, %s, %s, 'Demo private post', 'A synthetic private post scoped to Demo Corp accounts.', 'vom', 'private', '2026-01-10T12:00:00Z')",
+                    "insert into source_post (author_account_id, corporate_entity_id, process_unit_id, post_title, post_body, voc_type_code, visibility_code, created_at, updated_at) "
+                    "values (%s, %s, %s, 'Demo private post', 'A synthetic private post scoped to Demo Corp accounts.', 'vom', 'private', '2026-01-10T12:00:00Z', '2026-01-10T12:00:00Z')",
                     (account_ids["demo.admin"], corporate_entity_id, process_units["DEMO-PU-HQ"]),
                 )
 
             cur.execute(
-                "update source_post set created_at = '2026-01-10T12:00:00Z' "
+                "update source_post set created_at = '2026-01-10T12:00:00Z', "
+                "updated_at = '2026-01-10T12:00:00Z' "
                 "where post_title in ('Demo public post', 'Demo private post') "
                 "and created_at > '2026-01-12T12:00:00Z'"
             )
             cur.execute("select post_id from source_post where post_title = 'Demo public post'")
             demo_public_post_id = cur.fetchone()[0]
             cur.execute(
-                "update source_post set post_body = %s where post_id = %s",
+                "update source_post set post_body = %s, updated_at = created_at where post_id = %s",
                 (
                     "Ada West at Demo Corp followed up with Priya Nair at Northridge Grid about the delayed shipment.",
                     demo_public_post_id,
@@ -375,8 +377,8 @@ def insert_fixture_source_posts(cur, author_account_id, corporate_entity_id, pro
             "insert into source_post "
             "(author_account_id, corporate_entity_id, process_unit_id, "
             " post_title, post_body, voc_type_code, visibility_code, "
-            " thread_group_key, secondary_grouping_key, created_at) "
-            "values (%s, %s, %s, %s, %s, %s, 'public', %s, %s, %s) returning post_id",
+            " thread_group_key, secondary_grouping_key, created_at, updated_at) "
+            "values (%s, %s, %s, %s, %s, %s, 'public', %s, %s, %s, %s) returning post_id",
             (
                 author_account_id,
                 corporate_entity_id,
@@ -387,6 +389,7 @@ def insert_fixture_source_posts(cur, author_account_id, corporate_entity_id, pro
                 rec.group_key,
                 rec.secondary_key,
                 occurred,
+                occurred,
             ),
         )
         post_id = str(cur.fetchone()[0])
@@ -706,7 +709,7 @@ def _seed_fixture_keymen_and_voc(cur, corporate_entity_id) -> None:
         post_id = str(row[0])
         if cast.body is not None:
             cur.execute(
-                "update source_post set post_body = %s where post_id = %s",
+                "update source_post set post_body = %s, updated_at = created_at where post_id = %s",
                 (cast.body, post_id),
             )
         mentioned: list[str] = []
@@ -787,8 +790,8 @@ def _seed_demo_calendar_commitment(cur, author_account_id, corporate_entity_id,
             "insert into source_post "
             "(author_account_id, corporate_entity_id, process_unit_id, "
             " post_title, post_body, voc_type_code, visibility_code, "
-            " thread_group_key, created_at) "
-            "values (%s, %s, %s, %s, %s, 'voc', 'public', 'A-100', %s) "
+            " thread_group_key, created_at, updated_at) "
+            "values (%s, %s, %s, %s, %s, 'voc', 'public', 'A-100', %s, %s) "
             "returning post_id",
             (
                 author_account_id,
@@ -797,6 +800,7 @@ def _seed_demo_calendar_commitment(cur, author_account_id, corporate_entity_id,
                 title,
                 body,
                 calendar_commitment_occurred_at().replace(tzinfo=timezone.utc),
+                calendar_commitment_occurred_at().replace(tzinfo=timezone.utc),
             ),
         )
         post_id = cur.fetchone()[0]
@@ -971,8 +975,8 @@ def _ensure_eval_posts(
                 "insert into source_post "
                 "(author_account_id, corporate_entity_id, process_unit_id, "
                 " post_title, post_body, voc_type_code, visibility_code, "
-                " thread_group_key, created_at) "
-                "values (%s, %s, %s, %s, 'body', 'voc', 'public', %s, %s) returning post_id",
+                " thread_group_key, created_at, updated_at) "
+                "values (%s, %s, %s, %s, 'body', 'voc', 'public', %s, %s, %s) returning post_id",
                 (
                     author_account_id,
                     corporate_entity_id,
@@ -980,6 +984,7 @@ def _ensure_eval_posts(
                     title,
                     thread_group_key,
                     created,
+                    created,
                 ),
             )
             post_id = str(cur.fetchone()[0])
diff --git a/tests/test_analysis_run_live_body.py b/tests/test_analysis_run_live_body.py
new file mode 100644
index 000000000..c8b2fb564
--- /dev/null
+++ b/tests/test_analysis_run_live_body.py
@@ -0,0 +1,32 @@
+"""True write-clock comparison against an analysis-run knowledge cutoff.
+
+A January 2026 run must not treat an August rewrite of an in-cutoff title
+as reconstructed evidence. W3C Time / ISO 8601-1:2019 keep the analysis
+clock and the live row write clock distinct (ADR 0016).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from lineageweave.analysis_run_live_body import live_body_written_after_cutoff
+
+
+def test_rewritten_in_cutoff_title_is_not_reconstructed_evidence() -> None:
+    """created_at can precede the cutoff while updated_at does not."""
+    cutoff = datetime(2026, 1, 12, 12, 0, tzinfo=timezone.utc)
+    created_at = datetime(2026, 1, 10, 12, 0, tzinfo=timezone.utc)
+    rewritten_at = datetime(2026, 2, 1, 0, 0, tzinfo=timezone.utc)
+    assert created_at <= cutoff
+    assert live_body_written_after_cutoff(cutoff, rewritten_at) is True
+
+
+def test_backdated_write_clock_stays_inside_the_cutoff() -> None:
+    cutoff = datetime(2026, 1, 12, 12, 0, tzinfo=timezone.utc)
+    updated_at = datetime(2026, 1, 10, 12, 0, tzinfo=timezone.utc)
+    assert live_body_written_after_cutoff(cutoff, updated_at) is False
+
+
+def test_write_clock_equal_to_cutoff_stays_inside() -> None:
+    cutoff = datetime(2026, 1, 12, 12, 0, tzinfo=timezone.utc)
+    assert live_body_written_after_cutoff(cutoff, cutoff) is False
diff --git a/uv.lock b/uv.lock
index 156b0813d..4048e7ba1 100644
--- a/uv.lock
+++ b/uv.lock
@@ -454,7 +454,7 @@ wheels = [
 
 [[package]]
 name = "lineageweave"
-version = "0.84.1"
+version = "0.84.2"
 source = { virtual = "." }
 dependencies = [
     { name = "certifi" },