From 1953df97eccf5a0620d3004acaa315b104c25b66 Mon Sep 17 00:00:00 2001
From: Courier <courier@localhost>
Date: Tue, 13 Oct 2026 21:11:26 +0000
Subject: [PATCH 1/2] feat(lifecycle): persist idempotent claim and status
 transition evidence (#1202)

Add `IssueLifecycleEvent`, the durable worker-neutral event stream for a
work item: claim, release, status, completion and merge facts in one
append-only table that belongs to the Issue it describes. `Issue` holds only
current state and `AuditLog` is per-request and not deduplicated, so neither
can tell a first claim from a third attempt.

All writers go through one contract (`src/lib/issue-lifecycle.ts`) so the
taxonomy, idempotency rules and timestamps cannot drift per route: claim,
unclaim and the stale-AgentWork sweep (via the shared release core), board
move, manual/agent status, the operator groom route, the hosted groomer, the
reconciler, issue sync (including closed-issue reconciliation, now a shared
store), the GitHub webhook and the worker task report.

Idempotency has two rules, because the writers are not equally repeatable:

- Dispatch-authored writes record only a real transition (a claim also counts
  when ownership changed hands without the status moving), so a redelivered
  claim or a same-column drag records nothing while claim -> release ->
  reclaim keeps both attempts and the first claim.
- Externally observed events carry the source's own identity as a unique
  dedupeKey and upsert with an empty update, so a GitHub redelivery or a
  repeated sync collapses onto the row that already exists.

Observed events keep the source's occurrence time in `occurredAt` and the
wall clock in `observedAt`, and are never replayed onto Issue state, so a late
or out-of-order observation cannot move the present status. Dispatch-authored
writes commit their event in the same transaction as the state they describe;
observed paths (sync, webhook, reconciler, groomer, worker report) record
best-effort so an evidence row can never fail a sync run or a worker report.

Keeps the distinctions the issue asks for separate: claim released, failed or
blocked attempt, kanban done, issue closed and PR merged are distinct kinds,
and a merge is only ever recorded from an observed merged PR - never from a
worker's success report.

No API/worker behaviour change, no new worker requirement, token or model
field; the migration is additive and backfill-free. Taxonomy, idempotency
rules and migration notes are in docs/issue-lifecycle-events.md.
---
 AGENTS.md                                     |   2 +
 docs/issue-lifecycle-events.md                | 128 ++++++
 .../migration.sql                             |  56 +++
 prisma/schema.prisma                          |  64 +++
 .../[agentName]/tasks/report/route.test.ts    |  91 ++++
 .../agents/[agentName]/tasks/report/route.ts  |  34 ++
 src/app/api/issues/claim/route.test.ts        | 100 ++++-
 src/app/api/issues/claim/route.ts             |  29 +-
 src/app/api/issues/groom/route.test.ts        |  68 +++
 src/app/api/issues/groom/route.ts             |  25 +-
 src/app/api/issues/move/route.test.ts         |  66 +++
 src/app/api/issues/move/route.ts              |  24 +-
 src/app/api/issues/reconcile/route.test.ts    | 137 ++++++
 src/app/api/issues/reconcile/route.ts         | 129 +++++-
 src/app/api/issues/status/route.test.ts       |  66 +++
 src/app/api/issues/status/route.ts            |  38 +-
 src/app/api/issues/unclaim/route.test.ts      |  82 ++++
 src/app/api/issues/unclaim/route.ts           |   5 +-
 src/app/api/issues/webhook/route.test.ts      |  94 +++-
 src/app/api/issues/webhook/route.ts           |  68 +++
 src/app/api/sync/scheduled/route.ts           |  16 +-
 src/lib/groomer/run.test.ts                   |  29 ++
 src/lib/groomer/run.ts                        |  25 ++
 src/lib/heartbeat.ts                          |  10 +-
 src/lib/issue-claim.test.ts                   | 120 +++++
 src/lib/issue-claim.ts                        |  94 +++-
 src/lib/issue-lifecycle.test.ts               | 357 +++++++++++++++
 src/lib/issue-lifecycle.ts                    | 424 ++++++++++++++++++
 src/lib/issue-sync.test.ts                    | 131 +++++-
 src/lib/issue-sync.ts                         | 128 +++++-
 src/lib/report-close.test.ts                  |  76 ++++
 src/lib/report-close.ts                       |  34 ++
 src/lib/stale-work.ts                         |  11 +-
 33 files changed, 2681 insertions(+), 80 deletions(-)
 create mode 100644 docs/issue-lifecycle-events.md
 create mode 100644 prisma/migrations/20261013120000_add_issue_lifecycle_events/migration.sql
 create mode 100644 src/lib/issue-lifecycle.test.ts
 create mode 100644 src/lib/issue-lifecycle.ts

diff --git a/AGENTS.md b/AGENTS.md
index 21031f80..d817fe68 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -192,6 +192,7 @@ src/
     github.ts               # GitHub label/comment API helpers
     auth.ts                 # authorizeRequest, getAuthorizedActor (bearer/basic/oidc)
     lease.ts                # Lease TTL, upsert, release, resolveActiveWork
+    issue-lifecycle.ts      # IssueLifecycleEvent taxonomy + idempotent recorder
     agent-work.ts           # AgentWork start/checkpoint/finish, stale recovery
     assignment-conflicts.ts # label conflict analysis (agent/owner add/remove)
     kanban.ts               # getIssuesByStatus, getIssueStatus
@@ -211,6 +212,7 @@ Cross-cutting concerns and where they live. Read these first when working in tha
 | Assign / unassign (label-only, no lease) | `app/api/issues/actions/route.ts`, `app/api/issues/unassign/route.ts`, `lib/assignment-conflicts.ts` |
 | AgentWork lifecycle | `app/api/agent-work/route.ts`, `app/api/agent-work/{start,checkpoint,finish}/route.ts`, `lib/agent-work.ts` |
 | Auth & audit actor identity | `lib/auth.ts` (`authorizeRequest`, `getAuthorizedActor`) |
+| Lifecycle event stream (claim/status evidence, #1202) | `lib/issue-lifecycle.ts`, `docs/issue-lifecycle-events.md` |
 | Board UI component tree | `app/board/page.tsx` → `kanban-board-client.tsx` → `components/kanban-board.tsx` → `components/issue-card.tsx` |
 | App shell / header / nav | `app/layout.tsx` |
 | Label & status constants | `types/index.ts` (`BOARD_COLUMNS`, `StatusLabel`, `AGENT_PREFIX`, `OWNER_PREFIX`) |
diff --git a/docs/issue-lifecycle-events.md b/docs/issue-lifecycle-events.md
new file mode 100644
index 00000000..e36edbf2
--- /dev/null
+++ b/docs/issue-lifecycle-events.md
@@ -0,0 +1,128 @@
+# Issue lifecycle events
+
+`IssueLifecycleEvent` is Dispatch's durable, worker-neutral record of what
+happened to a work item over its life: who claimed it, who let it go, which
+status label moved, and when. It exists because the current state and the audit
+log cannot answer a claim-to-merge question:
+
+- `Issue` holds only the *current* status, so the first claim is
+  indistinguishable from the third.
+- `AuditLog` is per-request, is not deduplicated, and is written by each writer
+  in its own vocabulary. A redelivered claim, a repeated sync and a real second
+  attempt all look alike.
+
+The stream is append-only, belongs to the `Issue` it describes (there is no
+product-specific table or side channel), and is written through one contract —
+`src/lib/issue-lifecycle.ts` — so the taxonomy, the idempotency rules and the
+timestamps cannot drift between routes.
+
+Non-goals for now: PR merge/link backfill, a duration API or UI, and worker
+attempt telemetry/cohorts.
+
+## Taxonomy
+
+| Kind | Meaning | Typical source |
+|---|---|---|
+| `claim` | An agent took ownership. Recorded when the status label moved **or** the `agent/*` label changed (a force-claim between agents moves no status). | `api:claim` |
+| `claim_released` | Ownership was given up. Kept distinct from a failed attempt: the status the release left behind is recorded, including when it deliberately retained `status/in-review`. | `api:unclaim`, `stale-recovery` |
+| `attempt_failed` | A worker reported a `failed` or `blocked` outcome. Recorded once per report; an idempotent duplicate replays the original run and adds nothing. | `agent-report` |
+| `status_changed` | The `status/*` label moved. `fromStatus`/`toStatus` carry the values. | `api:move`, `api:status`, `api:groom`, `hosted-groomer`, `reconciler`, `sync`, `webhook` |
+| `completed` | A worker report closed the item as already done (`status/done` + GitHub close). Not evidence that a PR merged. | `agent-report` |
+| `issue_closed` | The GitHub issue was observed closing. Distinct from the card reaching Done. | `reconciler`, `sync` |
+| `issue_reopened` | The issue was observed reopening after a close. | `sync` |
+| `pr_merged` | A PR referencing the item was observed merged. Only ever recorded from an observation of a merge — never from a worker's success report. | `reconciler` |
+
+`kind` and `source` are stored as strings, not enums, so a new writer can be
+added without a migration; `LIFECYCLE_EVENT_KINDS` and `LIFECYCLE_SOURCES` in
+`src/lib/issue-lifecycle.ts` are the authoritative lists.
+
+## Columns that carry provenance
+
+| Column | Meaning |
+|---|---|
+| `issueId` | The work item the event belongs to (FK, cascades on delete). |
+| `repoFullName`, `issueNumber` | Denormalized for reads that only know GitHub coordinates. |
+| `source` | Which writer produced it — `api:*` for routes, `stale-recovery`, `hosted-groomer`, `reconciler`, `sync`, `webhook`, `agent-report`. |
+| `actor` | The identity responsible: an agent name, an operator actor, `hosted-groomer`, `reconciler`, or GitHub's sender login. |
+| `agentName` | Set when the event is about an agent's work (claim, release, failed attempt). |
+| `occurredAt` | When the transition happened. For a Dispatch-authored write this is "now". For an observed event it is the source's own timestamp — the PR's `merged_at`, the issue's `updated_at`, its `closed_at`. |
+| `observedAt` | When Dispatch saw it. Never backdated to `occurredAt`. |
+| `sourceEventId` | The event's identity in its source system when it has one (GitHub delivery id, `pr-<n>`). Provenance only. |
+| `dedupeKey` | Uniqueness identity for an observed event (unique index). See below. |
+| `metadata` | Small JSON bag for the extra shape of that writer (force-claim details, grooming run id, pull-request number, block reason). |
+
+## Which writers record what
+
+| Writer | Where | What it records |
+|---|---|---|
+| `POST /api/issues/claim` | `src/app/api/issues/claim/route.ts` | `claim` |
+| `POST /api/issues/unclaim`, stale-AgentWork sweep | `src/lib/issue-claim.ts` (shared core) | `claim_released` |
+| Board drag-and-drop | `src/app/api/issues/move/route.ts` | `status_changed` |
+| Manual / agent status set | `src/app/api/issues/status/route.ts` | `status_changed` |
+| Operator grooming decision | `src/app/api/issues/groom/route.ts` | `status_changed` |
+| Hosted groomer plan application | `src/lib/groomer/run.ts` | `status_changed` |
+| Reconciler | `src/app/api/issues/reconcile/route.ts` | `status_changed`, `pr_merged`, `issue_closed` |
+| Issue sync | `src/lib/issue-sync.ts` (`makePrismaIssueStore`, `makePrismaReconcileIssueStore`) | `status_changed`, `issue_closed`, `issue_reopened` |
+| GitHub webhook | `src/app/api/issues/webhook/route.ts` | `status_changed` |
+| Worker report | `src/app/api/agents/[agentName]/tasks/report/route.ts`, `src/lib/report-close.ts` | `attempt_failed`, `completed` |
+
+## Idempotency
+
+Two independent rules, because the writers are not equally repeatable.
+
+**Transitions, not writes.** For a write Dispatch authors itself (claim, move,
+status, groom), the event is recorded only when the status label actually
+changed — or, for a claim, when the assigned agent changed. A redelivered claim
+of an already-claimed issue, a drag that lands back in the same column and a
+set-status to the current status therefore record nothing, while a genuine
+release → reclaim pair records both attempts and leaves the first claim intact.
+These events carry no `dedupeKey`; the guard is what makes them single.
+
+**Source identity.** For an externally observed event the source usually has
+its own identity, which becomes a unique `dedupeKey` and the write is an
+upsert with an empty update, so redelivery lands on the row that already
+exists without rewriting its timestamps:
+
+- webhook — `webhook|<repo>|<n>|<delivery id>|<label>`
+- sync — `sync|<repo>|<n>|<kind>|<from>|<to>|<issue updated_at>`
+- reconciler — `reconciler|<repo>|<n>|<kind>|<pr number>|<merged_at>`
+
+A second, genuine transition always carries a different source timestamp (or
+a different PR), so it gets a different key and is appended normally.
+
+Known limitation: Dispatch's own label writes also generate GitHub webhook
+deliveries. A delivery that is processed before the originating request has
+mirrored the change locally sees the older cache, so the same move can appear
+once as `api:*` and once as `webhook`. Both rows carry the same `fromStatus` and
+`toStatus`, so a reader deduplicating consecutive identical transitions sees
+one; the alternative — dropping the webhook event outright — would lose genuine
+human edits that happen to look the same.
+
+## Late and out-of-order observations
+
+Events are never replayed onto `Issue` state, so recording one cannot move the
+present status — a sync that runs an hour late writes a row whose `occurredAt`
+is an hour old and whose `observedAt` is now, and leaves the issue exactly as
+the writer that owns it left it. Readers order by `occurredAt` and can see the
+gap between occurrence and observation rather than having it hidden by a
+backdated row.
+
+## Failure behavior
+
+- **Dispatch-authored writes** share a transaction with the local state they
+  describe (claim, move, status, groom, unclaim release). A failed event write
+  fails the write rather than leaving a claim with no evidence row; the route
+  returns its existing error shape.
+- **Observed writes** (sync, webhook, reconciler, worker report, hosted
+  groomer) are best-effort and log a warning. Those paths are periodic,
+  retried, and their job is the local mirror — an evidence-row problem must not
+  cost a whole sync run or fail a worker's report.
+
+## Migration
+
+`prisma/migrations/20261013120000_add_issue_lifecycle_events` creates the table
+and its indexes. It is additive: no backfill, no change to `Issue`, no change
+to any API response, and no new worker requirement, token or model field. The
+stream starts empty and fills as writers run, so a first claim recorded after
+the migration has no earlier history to contradict — which is exactly why no
+reader may infer a first claim from the absence of events.
\ No newline at end of file
diff --git a/prisma/migrations/20261013120000_add_issue_lifecycle_events/migration.sql b/prisma/migrations/20261013120000_add_issue_lifecycle_events/migration.sql
new file mode 100644
index 00000000..3bac2bd9
--- /dev/null
+++ b/prisma/migrations/20261013120000_add_issue_lifecycle_events/migration.sql
@@ -0,0 +1,56 @@
+-- The durable lifecycle event stream for a work item (#1202): claim, release,
+-- status, completion and merge evidence, one row per transition, owned by the
+-- Issue it describes. Additive and backfill-free — nothing here changes an
+-- existing column, so existing issues simply have no history yet and no reader
+-- may infer a first claim from that absence.
+--
+-- occurredAt is when the transition happened and observedAt is when Dispatch
+-- saw it, so a late or out-of-order observation stays visibly late instead of
+-- being backdated. dedupeKey carries a source-provided identity (GitHub
+-- delivery id, merged-PR identity, a sync's issue updated_at) and is unique so
+-- redelivery upserts instead of duplicating; Dispatch-authored writes leave it
+-- NULL and are guarded by the transition check instead. See
+-- docs/issue-lifecycle-events.md.
+
+-- CreateTable
+CREATE TABLE "IssueLifecycleEvent" (
+    "id" TEXT NOT NULL,
+    "issueId" TEXT NOT NULL,
+    "repoFullName" TEXT NOT NULL,
+    "issueNumber" INTEGER NOT NULL,
+    "kind" TEXT NOT NULL,
+    "source" TEXT NOT NULL,
+    "actor" TEXT NOT NULL,
+    "agentName" TEXT,
+    "fromStatus" TEXT,
+    "toStatus" TEXT,
+    "sourceEventId" TEXT,
+    "dedupeKey" TEXT,
+    "occurredAt" TIMESTAMP(3) NOT NULL,
+    "observedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "metadata" JSONB,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "IssueLifecycleEvent_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "IssueLifecycleEvent_dedupeKey_key" ON "IssueLifecycleEvent"("dedupeKey");
+
+-- CreateIndex
+CREATE INDEX "IssueLifecycleEvent_issueId_occurredAt_idx" ON "IssueLifecycleEvent"("issueId", "occurredAt");
+
+-- CreateIndex
+CREATE INDEX "IssueLifecycleEvent_issueId_kind_idx" ON "IssueLifecycleEvent"("issueId", "kind");
+
+-- CreateIndex
+CREATE INDEX "IssueLifecycleEvent_issueId_kind_occurredAt_idx" ON "IssueLifecycleEvent"("issueId", "kind", "occurredAt");
+
+-- CreateIndex
+CREATE INDEX "IssueLifecycleEvent_repoFullName_issueNumber_idx" ON "IssueLifecycleEvent"("repoFullName", "issueNumber");
+
+-- CreateIndex
+CREATE INDEX "IssueLifecycleEvent_kind_idx" ON "IssueLifecycleEvent"("kind");
+
+-- AddForeignKey
+ALTER TABLE "IssueLifecycleEvent" ADD CONSTRAINT "IssueLifecycleEvent_issueId_fkey" FOREIGN KEY ("issueId") REFERENCES "Issue"("id") ON DELETE CASCADE ON UPDATE CASCADE;
\ No newline at end of file
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 721d9b8d..5034c516 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -44,6 +44,7 @@ model Issue {
   groomingApplications  GroomingApplication[]
   groomingChildClaims   GroomingChildClaim[]
   groomerPendingReplies GroomerPendingReply[]
+  lifecycleEvents       IssueLifecycleEvent[]
 
   // Escalated lane outcome tracking
   decomposed    Boolean  @default(false)
@@ -321,6 +322,69 @@ model AgentReportDedupe {
   @@index([agentName])
 }
 
+// ---------------------------------------------------------------------------
+// IssueLifecycleEvent — the durable, worker-neutral event stream for a work
+// item's lifecycle (#1202). IssueLane already records lane history; this
+// records claim / release / status / completion history so a later
+// claim-to-merge read never has to infer a first claim from issue creation or
+// overwrite an earlier attempt.
+//
+// Every row belongs to the Issue it describes (there is no Courier-specific
+// table or side channel), and every writer — API route, hosted groomer,
+// reconciler, sync, webhook, worker report — goes through
+// src/lib/issue-lifecycle.ts, so the taxonomy and the idempotency rules live in
+// one place.
+//
+// `occurredAt` is when the transition happened; `observedAt` is when Dispatch
+// saw it. A late or out-of-order observation keeps its real occurredAt and is
+// never backdated into observedAt, and events are never replayed back onto
+// Issue state, so the present status can only be changed by the writer that
+// owns it. `dedupeKey` carries a source-provided identity (a GitHub delivery
+// id, a merged-PR identity, a sync's issue-updated_at) so redelivery upserts
+// instead of duplicating; Dispatch-authored writes leave it NULL and rely on
+// the no-op-transition guard instead.
+//
+// See docs/issue-lifecycle-events.md for the taxonomy and migration notes.
+// ---------------------------------------------------------------------------
+
+model IssueLifecycleEvent {
+  id           String @id @default(cuid())
+  issueId      String
+  issue        Issue  @relation(fields: [issueId], references: [id], onDelete: Cascade)
+  repoFullName String
+  issueNumber  Int
+  // Taxonomy: claim | claim_released | attempt_failed | status_changed |
+  // completed | issue_closed | issue_reopened | pr_merged.
+  kind         String
+  // The writer that produced this event (see LIFECYCLE_SOURCES).
+  source       String
+  // The identity responsible: an agent name, an operator actor, or the
+  // automation's own name.
+  actor        String
+  agentName    String?
+  fromStatus   String?
+  toStatus     String?
+  // Identity of the event in its source system, when the source has one
+  // (GitHub delivery id, PR number + merged_at, webhook action). NULL for
+  // writes Dispatch authors itself.
+  sourceEventId String?
+  // Idempotency identity for externally observed events; unique, so a
+  // redelivered webhook or a repeated sync upserts instead of duplicating.
+  // NULL means "no source identity" — those writes are guarded by the
+  // transition check instead.
+  dedupeKey     String?  @unique
+  occurredAt    DateTime
+  observedAt    DateTime @default(now())
+  metadata      Json?
+  createdAt     DateTime @default(now())
+
+  @@index([issueId, occurredAt])
+  @@index([issueId, kind])
+  @@index([issueId, kind, occurredAt])
+  @@index([repoFullName, issueNumber])
+  @@index([kind])
+}
+
 model AuditLog {
   id           String   @id @default(cuid())
   actor        String
diff --git a/src/app/api/agents/[agentName]/tasks/report/route.test.ts b/src/app/api/agents/[agentName]/tasks/report/route.test.ts
index e424e81e..eabfcd6c 100644
--- a/src/app/api/agents/[agentName]/tasks/report/route.test.ts
+++ b/src/app/api/agents/[agentName]/tasks/report/route.test.ts
@@ -39,6 +39,10 @@ const { mocks, mockAgentRun, mockDedupe, prFixResolveMock, closeResolveMock, pri
     issue: {
       findUnique: vi.fn().mockResolvedValue(null),
     },
+    issueLifecycleEvent: {
+      create: vi.fn().mockResolvedValue({ id: "evt-1" }),
+      upsert: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    },
     // `tasks/report` resolves a queued pr-fix item when the agent reports
     // back on PR coordinates. Tests that send `repoFullName` +
     // `pullRequestNumber` should keep the pr-fix queue empty by default;
@@ -2349,3 +2353,90 @@ describe("POST /api/agents/[agentName]/tasks/report — bound worker scope on al
     expect(closeResolveMock).not.toHaveBeenCalled();
   });
 });
+
+describe("POST /api/agents/[agentName]/tasks/report — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    delete process.env.DISPATCH_AUTH_MODE;
+    resetAuthCaches();
+    vi.clearAllMocks();
+    mockAgentRun.create.mockResolvedValue({
+      id: "run-1",
+      agentName: "test-agent",
+      runType: "implement",
+      status: "failed",
+      startedAt: new Date(),
+      finishedAt: new Date(),
+      summary: null,
+      errorMessage: null,
+      touchedIssueUrls: [],
+    });
+    // A cached issue, so the report resolves to an issueId to attach evidence to.
+    mocks.issueFindUnique.mockResolvedValue({ id: "issue-1" });
+  });
+
+  it("records a failed attempt as its own lifecycle fact", async () => {
+    const res = await postRequest({
+      taskType: "implement",
+      outcome: "failed",
+      repoFullName: "org/repo",
+      issueNumber: 42,
+      error: "tests failed",
+    });
+
+    expect(res.status).toBe(200);
+    expect(prismaMock.issueLifecycleEvent.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "attempt_failed",
+        source: "agent-report",
+        actor: "test-agent",
+        agentName: "test-agent",
+        sourceEventId: "agent-run:run-1",
+        metadata: { outcome: "failed", error: "tests failed" },
+      }),
+    });
+  });
+
+  it("records nothing for an ordinary successful report", async () => {
+    const res = await postRequest({
+      taskType: "implement",
+      outcome: "pr_opened",
+      repoFullName: "org/repo",
+      issueNumber: 42,
+    });
+
+    expect(res.status).toBe(200);
+    expect(prismaMock.issueLifecycleEvent.create).not.toHaveBeenCalled();
+  });
+
+  it("records nothing when the report could not resolve a cached issue", async () => {
+    mocks.issueFindUnique.mockResolvedValue(null);
+
+    const res = await postRequest({
+      taskType: "implement",
+      outcome: "blocked",
+      repoFullName: "org/repo",
+      issueNumber: 42,
+    });
+
+    expect(res.status).toBe(200);
+    expect(prismaMock.issueLifecycleEvent.create).not.toHaveBeenCalled();
+  });
+
+  it("keeps the report successful when the evidence write fails", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    prismaMock.issueLifecycleEvent.create.mockRejectedValueOnce(new Error("db down"));
+
+    const res = await postRequest({
+      taskType: "implement",
+      outcome: "failed",
+      repoFullName: "org/repo",
+      issueNumber: 42,
+    });
+
+    expect(res.status).toBe(200);
+    expect(warn).toHaveBeenCalled();
+  });
+});
diff --git a/src/app/api/agents/[agentName]/tasks/report/route.ts b/src/app/api/agents/[agentName]/tasks/report/route.ts
index ee4d8fc2..6cc2d65d 100644
--- a/src/app/api/agents/[agentName]/tasks/report/route.ts
+++ b/src/app/api/agents/[agentName]/tasks/report/route.ts
@@ -15,6 +15,7 @@ import {
 import { asRepoFilePath } from "@/lib/groomer/close-grounding";
 import { PLAN_LIMITS } from "@/lib/groomer/plan";
 import { getLiveIssueLabels } from "@/lib/claim-gate";
+import { recordLifecycleEventQuietly } from "@/lib/issue-lifecycle";
 import { AGENT_PREFIX, getAgentFromLabels } from "@/types";
 
 const VALID_TASK_TYPES = ["implement", "followup-pr"] as const;
@@ -678,6 +679,39 @@ export async function POST(
       }
     }
 
+    // A failed or blocked attempt is a lifecycle event of its own (#1202): it
+    // is the evidence that distinguishes "released because the work finished"
+    // from "released because the worker gave up", which a status label alone
+    // can never show. `blocked` is recorded here too — an attempt that stopped
+    // for input never reached done — and `metadata.outcome` keeps the two
+    // apart. Recorded once per report: a duplicate replays the original run
+    // and adds nothing. Quiet, because a worker retry must not fail over an
+    // evidence row.
+    if (issueId && !duplicate && (report.outcome === "failed" || report.outcome === "blocked")) {
+      await recordLifecycleEventQuietly(
+        prisma,
+        {
+          issueId,
+          repoFullName: report.repoFullName!,
+          issueNumber: report.issueNumber!,
+          kind: "attempt_failed",
+          source: "agent-report",
+          actor: agentName,
+          agentName,
+          fromStatus: null,
+          toStatus: null,
+          sourceEventId: `agent-run:${run.id}`,
+          occurredAt: now,
+          metadata: {
+            outcome: report.outcome,
+            ...(typeof report.error === "string" ? { error: report.error } : {}),
+            ...(typeof report.blockReason === "string" ? { blockReason: report.blockReason } : {}),
+          },
+        },
+        "agent task report",
+      );
+    }
+
     return NextResponse.json({
       ok: true,
       agentName,
diff --git a/src/app/api/issues/claim/route.test.ts b/src/app/api/issues/claim/route.test.ts
index 5321558d..5ce8b278 100644
--- a/src/app/api/issues/claim/route.test.ts
+++ b/src/app/api/issues/claim/route.test.ts
@@ -6,6 +6,8 @@ const { WORKER_TOKEN } = vi.hoisted(() => ({ WORKER_TOKEN: "worker-token" }));
 const { mocks } = vi.hoisted(() => ({
   mocks: {
     findUnique: vi.fn(), updateIssue: vi.fn(), createAuditLog: vi.fn(),
+    createLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    upsertLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
     addIssueLabel: vi.fn(), removeIssueLabel: vi.fn(),
     leaseFindMany: vi.fn(), leaseDeleteMany: vi.fn(),
     leaseFindUnique: vi.fn(), leaseFindUniqueOrThrow: vi.fn(),
@@ -15,7 +17,17 @@ const { mocks } = vi.hoisted(() => ({
     agentWorkUpdate: vi.fn().mockResolvedValue({}),
     transaction: vi.fn((arg: any) => {
       if (typeof arg === "function") {
-        return Promise.resolve(arg({ agentWork: { update: mocks.agentWorkUpdate }, agentWorkHistory: { create: vi.fn().mockResolvedValue({}) } }));
+        return Promise.resolve(
+          arg({
+            issue: { update: mocks.updateIssue },
+            issueLifecycleEvent: {
+              create: mocks.createLifecycleEvent,
+              upsert: mocks.upsertLifecycleEvent,
+            },
+            agentWork: { update: mocks.agentWorkUpdate },
+            agentWorkHistory: { create: vi.fn().mockResolvedValue({}) },
+          }),
+        );
       }
       return Promise.all(arg.map((op: any) => op));
     }),
@@ -32,6 +44,10 @@ vi.mock("@/lib/prisma", () => ({
   prisma: {
     issue: { findUnique: mocks.findUnique, update: mocks.updateIssue },
     auditLog: { create: mocks.createAuditLog },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
     lease: { 
       findMany: mocks.leaseFindMany, 
       deleteMany: mocks.leaseDeleteMany, 
@@ -621,3 +637,85 @@ describe("POST /api/issues/claim — cross-issue identity invariant (#1129 revie
     });
   });
 });
+
+describe("POST /api/issues/claim — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.findUnique.mockResolvedValue({ id: "issue-1", state: "open", number: 42, repository: { fullName: "org/repo" }, labels: [] as string[] });
+    mocks.updateIssue.mockResolvedValue(undefined);
+    mocks.createAuditLog.mockResolvedValue({ id: "log-1" });
+    mocks.addIssueLabel.mockResolvedValue(undefined);
+    mocks.leaseFindMany.mockResolvedValue([]);
+    mocks.leaseDeleteMany.mockResolvedValue({ count: 0 });
+    mocks.removeIssueLabel.mockResolvedValue(undefined);
+    resetRateLimits();
+  });
+
+  it("records the claim with its source, actor and transition", async () => {
+    mocks.getLiveIssueLabels.mockResolvedValue(["status/ready", "type/feature"]);
+
+    const res = await POST(makeRequest());
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "claim",
+        source: "api:claim",
+        actor: "test-agent",
+        agentName: "test-agent",
+        fromStatus: "status/ready",
+        toStatus: "status/in-progress",
+      }),
+    });
+  });
+
+  it("records nothing for a redelivered claim of an already-claimed issue", async () => {
+    // Live GitHub already shows this agent holding the issue as in-progress,
+    // which is exactly what a replayed claim request looks like.
+    mocks.getLiveIssueLabels.mockResolvedValue(["status/in-progress", "agent/test-agent"]);
+
+    const res = await POST(makeRequest());
+    expect(res.status).toBe(200);
+    expect(mocks.updateIssue).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+
+  it("records a force-claim that only changes ownership", async () => {
+    mocks.getLiveIssueLabels.mockResolvedValue(["status/in-progress", "agent/other-agent"]);
+
+    const res = await POST(makeRequest({ force: true }));
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        kind: "claim",
+        actor: "test-agent",
+        fromStatus: "status/in-progress",
+        toStatus: "status/in-progress",
+        metadata: {
+          force: true,
+          claimedFrom: "agent/other-agent",
+          claimedTo: "agent/test-agent",
+          note: "ownership changed without a status transition",
+        },
+      }),
+    });
+  });
+
+  it("fails the claim when the evidence write fails, instead of recording nothing", async () => {
+    // The cache write and the event share a transaction: a claim that landed
+    // without its evidence row would silently drop an attempt.
+    mocks.getLiveIssueLabels.mockResolvedValue(["status/ready"]);
+    mocks.createLifecycleEvent.mockRejectedValueOnce(new Error("lifecycle write failed"));
+
+    const res = await POST(makeRequest());
+
+    expect(res.status).toBe(500);
+    expect(mocks.createAuditLog).toHaveBeenCalledWith({
+      data: expect.objectContaining({ action: "claim_issue", success: false }),
+    });
+  });
+});
diff --git a/src/app/api/issues/claim/route.ts b/src/app/api/issues/claim/route.ts
index e68f1155..29c5325f 100644
--- a/src/app/api/issues/claim/route.ts
+++ b/src/app/api/issues/claim/route.ts
@@ -10,6 +10,7 @@ import { enforceWorkerAgentScope } from "@/lib/worker-identity";
 import { upsertLease, findActiveLeasesForIssue, releaseExpiredLeases } from "@/lib/lease";
 import { findAndReleaseStaleAgentWorkForIssue } from "@/lib/agent-work";
 import { transitionIssueStatus } from "@/lib/issue-status";
+import { recordClaimEvent } from "@/lib/issue-lifecycle";
 import { enforceRateLimit } from "@/lib/rate-limit";
 
 const IN_PROGRESS_STATUS = "status/in-progress";
@@ -210,10 +211,30 @@ export async function POST(request: Request) {
       // Base is the live GitHub label set (authoritative — #1037).
       await transitionIssueStatus(repoFullName, issueNumber, liveLabels, IN_PROGRESS_STATUS);
 
-      // Update local cache
-      await prisma.issue.update({
-        where: { id: issueId as string },
-        data: { labels: updatedLabels, lastSyncedAt: new Date() },
+      // Update local cache and record the lifecycle event in one transaction:
+      // a claim whose event failed to commit would leave the stream missing an
+      // attempt, and an event without the claim would describe work that never
+      // landed (#1202). A redelivered claim of an already-claimed issue is a
+      // no-op for both — the transition guard inside recordClaimEvent sees an
+      // unchanged status and an unchanged agent label.
+      await prisma.$transaction(async (tx) => {
+        await tx.issue.update({
+          where: { id: issueId as string },
+          data: { labels: updatedLabels, lastSyncedAt: new Date() },
+        });
+
+        await recordClaimEvent(tx, {
+          issueId: issueId as string,
+          repoFullName,
+          issueNumber,
+          kind: "claim",
+          source: "api:claim",
+          actor: agentName as string,
+          agentName: agentName as string,
+          before: liveLabels,
+          after: updatedLabels,
+          metadata: force === true ? { force: true } : null,
+        });
       });
 
       // Create or renew a lease for this agent (issue #166)
diff --git a/src/app/api/issues/groom/route.test.ts b/src/app/api/issues/groom/route.test.ts
index 15b5d780..81d913de 100644
--- a/src/app/api/issues/groom/route.test.ts
+++ b/src/app/api/issues/groom/route.test.ts
@@ -9,6 +9,8 @@ const { mocks } = vi.hoisted(() => ({
     findFirstIssue: vi.fn().mockResolvedValue(null),
     updateIssue: vi.fn().mockResolvedValue(undefined),
     createAuditLog: vi.fn().mockResolvedValue({ id: "log-1" }),
+    createLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    upsertLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
     removeIssueLabel: vi.fn().mockResolvedValue(undefined),
     addIssueLabel: vi.fn().mockResolvedValue(undefined),
     fetchIssue: vi.fn().mockResolvedValue(undefined),
@@ -26,6 +28,23 @@ vi.mock("@/lib/prisma", () => ({
     auditLog: {
       create: mocks.createAuditLog,
     },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
+    // The promotion and its lifecycle event commit together (#1202).
+    $transaction: (arg: any) =>
+      Promise.resolve(
+        typeof arg === "function"
+          ? arg({
+              issue: { update: mocks.updateIssue },
+              issueLifecycleEvent: {
+                create: mocks.createLifecycleEvent,
+                upsert: mocks.upsertLifecycleEvent,
+              },
+            })
+          : Promise.all(arg),
+      ),
   },
 }));
 
@@ -921,3 +940,52 @@ describe("POST /api/issues/groom — auth modes", () => {
     expect(auditCall.data.actor).toBe("body-agent");
   });
 });
+
+describe("POST /api/issues/groom — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetRateLimits();
+    mocks.findFirstIssue.mockResolvedValue(null);
+    process.env.DISPATCH_AGENT_TOKEN = "test-token";
+    process.env.DISPATCH_AUTH_MODE = "disabled";
+    mockIssue();
+    mocks.updateIssue.mockResolvedValue({ id: "issue-1", number: 42, labels: ["status/ready"] });
+    mocks.createAuditLog.mockResolvedValue({ id: "log-1" });
+  });
+
+  afterEach(() => {
+    delete process.env.DISPATCH_AGENT_TOKEN;
+    delete process.env.DISPATCH_AUTH_MODE;
+    resetAuthCaches();
+  });
+
+  it("records the promotion with the groomer as its source", async () => {
+    const res = await groomRequest({ issueId: "i1", repoFullName: "r/r", issueNumber: 42, action: "promote_to_ready", actor: "my-agent" });
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "misospace/dispatch",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "api:groom",
+        actor: "my-agent",
+        fromStatus: "status/backlog",
+        toStatus: "status/ready",
+      }),
+    });
+  });
+
+  it("records nothing for a groom action that leaves the status alone", async () => {
+    const res = await groomRequest({
+      issueId: "i1",
+      repoFullName: "r/r",
+      issueNumber: 42,
+      action: "escalate",
+    });
+    expect(res.status).toBe(200);
+    expect(mocks.updateIssue).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/app/api/issues/groom/route.ts b/src/app/api/issues/groom/route.ts
index 57f7cf02..d5fb40a9 100644
--- a/src/app/api/issues/groom/route.ts
+++ b/src/app/api/issues/groom/route.ts
@@ -5,6 +5,7 @@ import { authorizeRequest, authErrorResponse } from "@/lib/auth";
 import { getEscalationLane, getDefaultClaimableLane, isClaimableLane } from "@/lib/lane-config";
 import { resolveActor } from "@/lib/resolve-actor";
 import { transitionIssueStatus } from "@/lib/issue-status";
+import { recordStatusTransition } from "@/lib/issue-lifecycle";
 import { refreshSingleIssue } from "@/lib/issue-sync";
 import { fetchIssue as fetchIssueFromGitHub } from "@/lib/github";
 import { enforceRateLimit } from "@/lib/rate-limit";
@@ -190,9 +191,27 @@ export async function POST(request: Request) {
 
       // Update GitHub labels if status changed; always refresh lastSyncedAt
       if (action === "promote_to_ready") {
-        await prisma.issue.update({
-          where: { id: effectiveIssueId },
-          data: { ...groomingData, labels: afterLabels, lastSyncedAt: new Date() },
+        // The promotion and its lifecycle event commit together, attributed to
+        // whoever groomed it — a groomer status change is a transition like any
+        // other and must not be invisible to the event stream (#1202). A groom
+        // that re-promotes an already-ready issue moves no status label and
+        // records nothing.
+        await prisma.$transaction(async (tx) => {
+          await tx.issue.update({
+            where: { id: effectiveIssueId },
+            data: { ...groomingData, labels: afterLabels, lastSyncedAt: new Date() },
+          });
+
+          await recordStatusTransition(tx, {
+            issueId: effectiveIssueId,
+            repoFullName: effectiveRepo,
+            issueNumber: effectiveNumber,
+            kind: "status_changed",
+            source: "api:groom",
+            actor: auditActor,
+            before: beforeLabels,
+            after: afterLabels,
+          });
         });
 
         // Refresh the cached row from GitHub so the board and the selector's
diff --git a/src/app/api/issues/move/route.test.ts b/src/app/api/issues/move/route.test.ts
index dc1da2f6..966e0927 100644
--- a/src/app/api/issues/move/route.test.ts
+++ b/src/app/api/issues/move/route.test.ts
@@ -7,6 +7,8 @@ const { mocks } = vi.hoisted(() => ({
     findIssue: vi.fn().mockResolvedValue(null),
     updateIssue: vi.fn().mockResolvedValue(undefined),
     createAuditLog: vi.fn().mockResolvedValue({ id: "log-1" }),
+    createLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    upsertLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
     removeIssueLabel: vi.fn().mockResolvedValue(undefined),
     addIssueLabel: vi.fn().mockResolvedValue(undefined),
     auth: vi.fn(),
@@ -22,9 +24,26 @@ vi.mock("@/lib/prisma", () => ({
       findUnique: mocks.findIssue,
       update: mocks.updateIssue,
     },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
     auditLog: {
       create: mocks.createAuditLog,
     },
+    // The move commits the cache write and its lifecycle event together (#1202).
+    $transaction: (arg: any) =>
+      Promise.resolve(
+        typeof arg === "function"
+          ? arg({
+              issue: { update: mocks.updateIssue },
+              issueLifecycleEvent: {
+                create: mocks.createLifecycleEvent,
+                upsert: mocks.upsertLifecycleEvent,
+              },
+            })
+          : Promise.all(arg),
+      ),
   },
 }));
 
@@ -396,3 +415,50 @@ describe("POST /api/issues/move — validation", () => {
     expect(body.error).toBe("Rate limit exceeded");
   });
 });
+
+describe("POST /api/issues/move — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    delete process.env.DISPATCH_AUTH_MODE;
+    delete process.env.DISPATCH_AUTH_USERNAME;
+    delete process.env.DISPATCH_AUTH_PASSWORD;
+    resetAuthCaches();
+    resetRateLimits();
+    vi.clearAllMocks();
+    mocks.auth.mockReset();
+    mocks.findIssue.mockResolvedValue(null);
+    mocks.updateIssue.mockResolvedValue(undefined);
+    mocks.createAuditLog.mockResolvedValue({ id: "log-1" });
+    mocks.removeIssueLabel.mockResolvedValue(undefined);
+    mocks.addIssueLabel.mockResolvedValue(undefined);
+  });
+
+  it("records the column move with the actor that made it", async () => {
+    mocks.findIssue.mockResolvedValue({ id: "issue-1", labels: ["status/backlog"] });
+
+    const res = await postRequest();
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "api:move",
+        fromStatus: "status/backlog",
+        toStatus: "status/in-progress",
+      }),
+    });
+  });
+
+  it("records nothing when the drop does not move the card to another column", async () => {
+    mocks.findIssue.mockResolvedValue({ id: "issue-1", labels: ["status/backlog"] });
+
+    const res = await postRequest(
+      makePayload({ oldLabels: ["status/backlog"], newLabels: ["status/backlog", "priority/p0"] }),
+    );
+    expect(res.status).toBe(200);
+    expect(mocks.updateIssue).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/app/api/issues/move/route.ts b/src/app/api/issues/move/route.ts
index ce2da6c0..fff5fdc1 100644
--- a/src/app/api/issues/move/route.ts
+++ b/src/app/api/issues/move/route.ts
@@ -6,6 +6,7 @@ import { STATUS_LABELS, isStatusLabel } from "@/types";
 import { authorizeRequest, getAuthorizedActor, authErrorResponse } from "@/lib/auth";
 import { enforceRateLimit } from "@/lib/rate-limit";
 import { transitionIssueStatus } from "@/lib/issue-status";
+import { recordStatusTransition } from "@/lib/issue-lifecycle";
 
 // Generous per-actor rate limit — normal kanban drag-and-drop and agent
 // status transitions stay far below this.
@@ -71,9 +72,26 @@ export async function POST(request: Request) {
       }
 
       if (issue) {
-        await prisma.issue.update({
-          where: { id: issueId as string },
-          data: { labels: newLabels as string[], lastSyncedAt: new Date() },
+        // The cached label write and the lifecycle event commit together, so a
+        // board move is never visible without its evidence row (#1202). A drag
+        // that lands on the column the card already sits in moves no status
+        // label and records nothing.
+        await prisma.$transaction(async (tx) => {
+          await tx.issue.update({
+            where: { id: issueId as string },
+            data: { labels: newLabels as string[], lastSyncedAt: new Date() },
+          });
+
+          await recordStatusTransition(tx, {
+            issueId: issueId as string,
+            repoFullName: repoFullName as string,
+            issueNumber: issueNumber as number,
+            kind: "status_changed",
+            source: "api:move",
+            actor: moveActor,
+            before: effectiveCurrentLabels,
+            after: newLabels as string[],
+          });
         });
       }
 
diff --git a/src/app/api/issues/reconcile/route.test.ts b/src/app/api/issues/reconcile/route.test.ts
index 453dbf97..01bce15c 100644
--- a/src/app/api/issues/reconcile/route.test.ts
+++ b/src/app/api/issues/reconcile/route.test.ts
@@ -131,3 +131,140 @@ describe("GET /api/issues/reconcile", () => {
     expect(mocks.auditLogFindMany).not.toHaveBeenCalled();
   });
 });
+
+describe("recordReconciledAction — lifecycle evidence (#1202)", () => {
+  function makeClient() {
+    const rows: Array<Record<string, any>> = [];
+    const client = {
+      issueLifecycleEvent: {
+        create: vi.fn(async ({ data }: any) => {
+          rows.push({ ...data });
+          return data;
+        }),
+        upsert: vi.fn(async ({ where, create }: any) => {
+          const existing = rows.find((row) => row.dedupeKey === where.dedupeKey);
+          if (existing) return existing;
+          rows.push({ ...create });
+          return create;
+        }),
+      },
+    };
+    return { client, rows };
+  }
+
+  const repo = { id: "repo-1", fullName: "org/repo" };
+
+  it("records the merge and the close as separate facts", async () => {
+    const { recordReconciledAction } = await import("./route");
+    const { client, rows } = makeClient();
+
+    await recordReconciledAction({
+      repo,
+      issueNumber: 42,
+      existingIssue: { id: "issue-1" },
+      mergedPr: { number: 7, merged_at: "2026-10-02T08:00:00Z" },
+      executed: {
+        action: { type: "close_issue", issueNumber: 42, repoFullName: "org/repo", reason: "fixed" },
+        success: true,
+        beforeLabels: ["status/in-review"],
+        afterLabels: [],
+      },
+      client,
+    });
+
+    expect(rows.map((row) => row.kind)).toEqual(["pr_merged", "issue_closed"]);
+    // The merge is dated by the PR's own merged_at, not by the reconcile pass.
+    expect(rows[0]).toMatchObject({
+      source: "reconciler",
+      sourceEventId: "pr-7",
+      occurredAt: new Date("2026-10-02T08:00:00Z"),
+      metadata: { pullRequestNumber: 7 },
+    });
+  });
+
+  it("does not record a second merge when a later pass re-derives the same one", async () => {
+    const { recordReconciledAction } = await import("./route");
+    const { client, rows } = makeClient();
+    const input = {
+      repo,
+      issueNumber: 42,
+      existingIssue: { id: "issue-1" },
+      mergedPr: { number: 7, merged_at: "2026-10-02T08:00:00Z" },
+      executed: {
+        action: { type: "close_issue" as const, issueNumber: 42, repoFullName: "org/repo", reason: "fixed" },
+        success: true,
+        beforeLabels: ["status/in-review"],
+        afterLabels: [],
+      },
+      client,
+    };
+
+    await recordReconciledAction(input);
+    await recordReconciledAction(input);
+
+    expect(rows).toHaveLength(2);
+  });
+
+  it("records a PR-driven status move with the PR as its identity", async () => {
+    const { recordReconciledAction } = await import("./route");
+    const { client, rows } = makeClient();
+
+    await recordReconciledAction({
+      repo,
+      issueNumber: 42,
+      existingIssue: { id: "issue-1" },
+      mergedPr: { number: 9, merged_at: null },
+      executed: {
+        action: { type: "set_status", issueNumber: 42, repoFullName: "org/repo", label: "status/in-review", reason: "PR healthy" },
+        success: true,
+        beforeLabels: ["status/backlog"],
+        afterLabels: ["status/in-review"],
+      },
+      client,
+    });
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      kind: "status_changed",
+      source: "reconciler",
+      fromStatus: "status/backlog",
+      toStatus: "status/in-review",
+      dedupeKey: "reconciler|org/repo|42|status_changed|9|unknown",
+    });
+  });
+
+  it("records nothing for a failed action or an uncached issue", async () => {
+    const { recordReconciledAction } = await import("./route");
+    const { client, rows } = makeClient();
+
+    await recordReconciledAction({
+      repo,
+      issueNumber: 42,
+      existingIssue: { id: "issue-1" },
+      mergedPr: null,
+      executed: {
+        action: { type: "set_status", issueNumber: 42, repoFullName: "org/repo", label: "status/ready", reason: "x" },
+        success: false,
+        error: "github 500",
+        beforeLabels: ["status/backlog"],
+        afterLabels: ["status/backlog"],
+      },
+      client,
+    });
+    await recordReconciledAction({
+      repo,
+      issueNumber: 42,
+      existingIssue: undefined,
+      mergedPr: null,
+      executed: {
+        action: { type: "set_status", issueNumber: 42, repoFullName: "org/repo", label: "status/ready", reason: "x" },
+        success: true,
+        beforeLabels: ["status/backlog"],
+        afterLabels: ["status/ready"],
+      },
+      client,
+    });
+
+    expect(rows).toHaveLength(0);
+  });
+});
diff --git a/src/app/api/issues/reconcile/route.ts b/src/app/api/issues/reconcile/route.ts
index 23698b25..966f3ac2 100644
--- a/src/app/api/issues/reconcile/route.ts
+++ b/src/app/api/issues/reconcile/route.ts
@@ -9,7 +9,15 @@ import {
   classifyLaneByHeuristics,
   shouldReclassifyStaleBacklog,
   executeActions,
+  type ReconciliationAction,
 } from "@/lib/issue-reconciliation";
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  recordLifecycleEvent,
+  recordStatusTransition,
+  type LifecycleEventClient,
+} from "@/lib/issue-lifecycle";
 import { isBacklogLane } from "@/lib/lane-config";
 import { computeLinkedPrHealth, toPersistedLinkedPrHealth, type LinkedPrHealth } from "@/lib/linked-pr-health";
 import { authorizeRequest, authErrorResponse } from "@/lib/auth";
@@ -19,15 +27,114 @@ import { acquireLock, releaseLock, type AcquiredLock, type LockConflict } from "
 
 const RATE_LIMIT = { limit: 10, windowMs: 60_000 };
 
+/**
+ * Record the lifecycle evidence for one executed reconciliation action.
+ *
+ * The reconciler reacts to what it observed on GitHub, so its events carry
+ * the observation's own identity rather than Dispatch's clock: a merged PR is
+ * identified by the PR's number and `merged_at`, and a status swap by the PR
+ * that caused it plus the labels it moved between. A later reconcile pass
+ * that re-derives the same conclusion upserts the row that already exists
+ * instead of recording a second merge.
+ *
+ * Failures are logged, never thrown: the reconcile pass has already done its
+ * GitHub work and recorded its audit row by this point, so an evidence-row
+ * problem must not abort the remaining issues.
+ */
+export async function recordReconciledAction(input: {
+  repo: { id: string; fullName: string };
+  issueNumber: number;
+  existingIssue: { id: string } | undefined;
+  /** The PR whose state drove the action, when the action came from one. */
+  mergedPr: { number: number; merged_at?: string | null } | null;
+  executed: {
+    action: ReconciliationAction;
+    success: boolean;
+    error?: string;
+    beforeLabels: string[];
+    afterLabels: string[];
+  };
+  client: LifecycleEventClient;
+}): Promise<void> {
+  const { repo, issueNumber, existingIssue, executed, client } = input;
+  if (!existingIssue || !executed.success) return;
+
+  const identity = lifecycleDedupeKey("reconciler", repo.fullName, issueNumber);
+  const mergedPr = input.mergedPr;
+  const prIdentity = mergedPr
+    ? lifecycleDedupeKey(mergedPr.number, mergedPr.merged_at ?? "unknown")
+    : null;
+
+  try {
+    if (executed.action.type === "close_issue") {
+      // A merge is recorded separately from the close it causes: "the PR
+      // merged" and "someone closed the issue" are different facts, and a
+      // worker reporting success must never be able to assert either.
+      if (mergedPr && prIdentity) {
+        await recordLifecycleEvent(client, {
+          issueId: existingIssue.id,
+          repoFullName: repo.fullName,
+          issueNumber,
+          kind: "pr_merged",
+          source: "reconciler",
+          actor: "reconciler",
+          fromStatus: lifecycleStatusLabel(executed.beforeLabels),
+          toStatus: lifecycleStatusLabel(executed.afterLabels),
+          sourceEventId: `pr-${mergedPr.number}`,
+          dedupeKey: lifecycleDedupeKey(identity, "pr_merged", prIdentity),
+          occurredAt: mergedPr.merged_at ? new Date(mergedPr.merged_at) : undefined,
+          metadata: { pullRequestNumber: mergedPr.number },
+        });
+      }
+
+      await recordLifecycleEvent(client, {
+        issueId: existingIssue.id,
+        repoFullName: repo.fullName,
+        issueNumber,
+        kind: "issue_closed",
+        source: "reconciler",
+        actor: "reconciler",
+        fromStatus: lifecycleStatusLabel(executed.beforeLabels),
+        toStatus: lifecycleStatusLabel(executed.afterLabels),
+        dedupeKey: lifecycleDedupeKey(identity, "issue_closed", prIdentity ?? "reconciler-close"),
+        metadata: prIdentity ? { pullRequestNumber: mergedPr!.number } : null,
+      });
+      return;
+    }
+
+    if (executed.action.type === "set_status") {
+      await recordStatusTransition(client, {
+        issueId: existingIssue.id,
+        repoFullName: repo.fullName,
+        issueNumber,
+        kind: "status_changed",
+        source: "reconciler",
+        actor: "reconciler",
+        before: executed.beforeLabels,
+        after: executed.afterLabels,
+        // Without a PR to key on, the label pair itself is the identity: the
+        // same swap re-derived on a later pass is the same conclusion.
+        dedupeKey: prIdentity
+          ? lifecycleDedupeKey(identity, "status_changed", prIdentity)
+          : lifecycleDedupeKey(identity, "status_changed", executed.beforeLabels.join(","), executed.afterLabels.join(",")),
+        metadata: prIdentity ? { pullRequestNumber: mergedPr!.number } : null,
+      });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`reconciler lifecycle evidence for ${repo.fullName}#${issueNumber} was not recorded: ${message}`);
+  }
+}
+
 /**
  * Reconcile issue state against PR state for all tracked repos.
- * 
+ *
  * This endpoint replaces the grooming logic that previously lived in
  * Saffron's project_groom.py scripts. It:
  * 1. Detects merged PRs that fix issues → closes them on GitHub
  * 2. Detects open PRs and checks their health → applies labels via GitHub API
  * 3. Classifies lanes using heuristics when model calls are unavailable
- * 
+ *
  * Dispatch calls this periodically (e.g., every 5 minutes) to keep issue
  * state current without relying on GitHub ProjectV2 columns.
  */
@@ -176,6 +283,10 @@ export async function POST(request: Request) {
           if (issue.state !== "open") continue;
 
           const currentLabels = issue.labels.map((l) => l.name);
+          // Resolved before the action loop so a reconciled action can be
+          // attributed to the cached issue row, and reused below for lane and
+          // linked-PR bookkeeping.
+          const existingIssue = existingIssueByNumber.get(issue.number);
           const result = reconcileIssue(
             {
               number: issue.number,
@@ -223,12 +334,22 @@ export async function POST(request: Request) {
               if (exec.action.type === "close_issue" && exec.success) {
                 totalIssuesClosed++;
               }
+
+              await recordReconciledAction({
+                repo,
+                issueNumber: exec.action.issueNumber,
+                existingIssue,
+                mergedPr:
+                  mergedFixingIssues.get(exec.action.issueNumber) ??
+                  openPrToIssue.get(exec.action.issueNumber) ??
+                  null,
+                executed: exec,
+                client: prisma,
+              });
             }
           }
 
           // Classify lane using heuristics — first-time set, or stale-backlog reclassification.
-          const existingIssue = existingIssueByNumber.get(issue.number);
-
           if (existingIssue && !existingIssue.currentLane) {
             // First-time classification: lane was never set.
             const classification = classifyLaneByHeuristics(
diff --git a/src/app/api/issues/status/route.test.ts b/src/app/api/issues/status/route.test.ts
index 8d3c6e01..0f7415c2 100644
--- a/src/app/api/issues/status/route.test.ts
+++ b/src/app/api/issues/status/route.test.ts
@@ -6,6 +6,8 @@ const { mocks } = vi.hoisted(() => ({
     findUnique: vi.fn(),
     updateIssue: vi.fn(),
     createAuditLog: vi.fn(),
+    createLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    upsertLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
     removeIssueLabel: vi.fn(),
     addIssueLabel: vi.fn(),
     getLiveIssueLabels: vi.fn().mockResolvedValue([] as string[]),
@@ -19,7 +21,24 @@ process.env.DISPATCH_WORKER_TOKENS = "alpha:status-worker-token";
 vi.mock("@/lib/prisma", () => ({
   prisma: {
     issue: { findUnique: mocks.findUnique, update: mocks.updateIssue },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
     auditLog: { create: mocks.createAuditLog },
+    // The status write and its lifecycle event commit together (#1202).
+    $transaction: (arg: any) =>
+      Promise.resolve(
+        typeof arg === "function"
+          ? arg({
+              issue: { update: mocks.updateIssue },
+              issueLifecycleEvent: {
+                create: mocks.createLifecycleEvent,
+                upsert: mocks.upsertLifecycleEvent,
+              },
+            })
+          : Promise.all(arg),
+      ),
   },
 }));
 
@@ -430,3 +449,50 @@ describe("POST /api/issues/status — bound worker scope (#1129)", () => {
     }
   });
 });
+
+describe("POST /api/issues/status — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetRateLimits();
+    mocks.updateIssue.mockResolvedValue(undefined);
+    mocks.createAuditLog.mockResolvedValue({ id: "log-1" });
+    mocks.addIssueLabel.mockResolvedValue(undefined);
+    mocks.removeIssueLabel.mockResolvedValue(undefined);
+    mocks.findUnique.mockResolvedValue({ id: "issue-1", state: "open", labels: ["status/ready"], number: 42, repository: { fullName: "org/repo" } });
+    mocks.getLiveIssueLabels.mockResolvedValue(["status/ready"]);
+  });
+
+  it("records the manual status change with its source and actor", async () => {
+    const res = await POST(makeRequest({ status: "in-progress", actor: "operator" }));
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "api:status",
+        actor: "operator",
+        fromStatus: "status/ready",
+        toStatus: "status/in-progress",
+      }),
+    });
+  });
+
+  it("records nothing when the issue already carries the requested status", async () => {
+    const res = await POST(makeRequest({ status: "ready" }));
+    expect(res.status).toBe(200);
+    expect(mocks.updateIssue).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+
+  it("writes no evidence when the request never reached the write", async () => {
+    mocks.getLiveIssueLabels.mockRejectedValueOnce(new Error("github 500"));
+
+    const res = await POST(makeRequest());
+
+    expect(res.status).toBe(503);
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/app/api/issues/status/route.ts b/src/app/api/issues/status/route.ts
index b9d7b3ad..8664211a 100644
--- a/src/app/api/issues/status/route.ts
+++ b/src/app/api/issues/status/route.ts
@@ -6,6 +6,7 @@ import { authorizeRequest, getAuthorizedActor, getBoundWorkerAgent, authErrorRes
 import { enforceWorkerAgentScope, enforceWorkerBound } from "@/lib/worker-identity";
 import { transitionIssueStatus } from "@/lib/issue-status";
 import { getLiveIssueLabels } from "@/lib/claim-gate";
+import { recordStatusTransition } from "@/lib/issue-lifecycle";
 import { enforceRateLimit } from "@/lib/rate-limit";
 
 const RATE_LIMIT = { limit: 30, windowMs: 10_000 };
@@ -122,16 +123,33 @@ export async function POST(request: Request) {
       // Base is the live GitHub label set (authoritative — #1037).
       const labelsToSet = await transitionIssueStatus(effectiveRepo, effectiveNumber, liveLabels, targetLabel);
 
-      // Update local cache
-      await prisma.issue.update({
-        where: { id: issueId as string },
-        data: {
-          labels: labelsToSet,
-          lastSyncedAt: new Date(),
-          ...(targetLabel === "status/blocked"
-            ? { blockedReason: (blockedReason as string).trim() }
-            : { blockedReason: null }),
-        },
+      // The cached label write and the lifecycle event commit together, so a manual
+      // or agent-driven status change is never visible without its evidence row
+      // (#1202). Setting the status an issue already carries records nothing.
+      await prisma.$transaction(async (tx) => {
+        await tx.issue.update({
+          where: { id: issueId as string },
+          data: {
+            labels: labelsToSet,
+            lastSyncedAt: new Date(),
+            ...(targetLabel === "status/blocked"
+              ? { blockedReason: (blockedReason as string).trim() }
+              : { blockedReason: null }),
+          },
+        });
+
+        await recordStatusTransition(tx, {
+          issueId: issueId as string,
+          repoFullName: effectiveRepo,
+          issueNumber: effectiveNumber,
+          kind: "status_changed",
+          source: "api:status",
+          actor: actorName,
+          agentName: typeof agentName === "string" ? agentName : null,
+          before: liveLabels,
+          after: labelsToSet,
+          metadata: targetLabel === "status/blocked" ? { blocked: true } : null,
+        });
       });
 
       // Write audit log
diff --git a/src/app/api/issues/unclaim/route.test.ts b/src/app/api/issues/unclaim/route.test.ts
index 000cf3f9..6400228f 100644
--- a/src/app/api/issues/unclaim/route.test.ts
+++ b/src/app/api/issues/unclaim/route.test.ts
@@ -8,6 +8,8 @@ const { mocks } = vi.hoisted(() => ({
     findUnique: vi.fn().mockResolvedValue(null),
     updateIssue: vi.fn().mockResolvedValue(undefined),
     createAuditLog: vi.fn().mockResolvedValue({ id: "log-1" }),
+    createLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
+    upsertLifecycleEvent: vi.fn().mockResolvedValue({ id: "evt-1" }),
     removeIssueLabel: vi.fn().mockResolvedValue(undefined),
     addIssueLabel: vi.fn().mockResolvedValue(undefined),
     updateIssueLabels: vi.fn().mockResolvedValue(undefined),
@@ -33,6 +35,23 @@ vi.mock("@/lib/prisma", () => ({
     auditLog: {
       create: mocks.createAuditLog,
     },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
+    // The release cache write and its lifecycle event commit together (#1202).
+    $transaction: (arg: any) =>
+      Promise.resolve(
+        typeof arg === "function"
+          ? arg({
+              issue: { findUnique: mocks.findUnique, update: mocks.updateIssue },
+              issueLifecycleEvent: {
+                create: mocks.createLifecycleEvent,
+                upsert: mocks.upsertLifecycleEvent,
+              },
+            })
+          : Promise.all(arg),
+      ),
   },
 }));
 
@@ -667,3 +686,66 @@ describe("POST /api/issues/unclaim — cross-issue identity invariant (#1129 rev
     });
   });
 });
+
+describe("POST /api/issues/unclaim — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.findUnique.mockResolvedValue({
+      id: "issue-1",
+      state: "open",
+      number: 42,
+      repository: { fullName: "org/repo" },
+      labels: ["agent/test-agent", "status/in-progress"],
+    } as never);
+    mocks.updateIssue.mockResolvedValue(undefined);
+    mocks.createAuditLog.mockResolvedValue({ id: "log-1" });
+    mocks.removeIssueLabel.mockResolvedValue(undefined);
+    mocks.addIssueLabel.mockResolvedValue(undefined);
+    mocks.releaseLeaseByAgentAndIssue.mockResolvedValue(undefined);
+    mocks.releaseAgentWorkByAgentAndIssue.mockResolvedValue(1);
+  });
+
+  it("records the release, attributed to the releasing agent", async () => {
+    const res = await postRequest();
+    expect(res.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "claim_released",
+        source: "api:unclaim",
+        actor: "test-agent",
+        agentName: "test-agent",
+        fromStatus: "status/in-progress",
+        toStatus: "status/ready",
+      }),
+    });
+  });
+
+  it("attributes an operator release to the operator, not to the released agent", async () => {
+    process.env.DISPATCH_AUTH_MODE = "basic";
+    process.env.DISPATCH_AUTH_USERNAME = "alice";
+    process.env.DISPATCH_AUTH_PASSWORD = "hunter2";
+    const credentials = Buffer.from("alice:hunter2").toString("base64");
+
+    const res = await POST(
+      authedRequest("http://localhost/api/issues/unclaim", {
+        method: "POST",
+        body: makePayload(),
+        includeAuth: false,
+        headers: { Authorization: `Basic ${credentials}` },
+      }),
+    );
+
+    expect(res.status).toBe(200);
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({ kind: "claim_released", actor: "alice", agentName: "test-agent" }),
+    });
+
+    delete process.env.DISPATCH_AUTH_MODE;
+    delete process.env.DISPATCH_AUTH_USERNAME;
+    delete process.env.DISPATCH_AUTH_PASSWORD;
+  });
+});
diff --git a/src/app/api/issues/unclaim/route.ts b/src/app/api/issues/unclaim/route.ts
index a5cf9437..508eec3b 100644
--- a/src/app/api/issues/unclaim/route.ts
+++ b/src/app/api/issues/unclaim/route.ts
@@ -98,13 +98,16 @@ export async function POST(request: Request) {
 
     try {
       // The shared core keeps operator and scheduled claim release behaviour
-      // consistent while allowing stale retries to be idempotent.
+      // consistent while allowing stale retries to be idempotent. It also
+      // records the release's lifecycle event, attributed to the audited actor
+      // rather than to the agent being released (#1202).
       const released = await releaseIssueClaim({
         prisma,
         issue,
         repoFullName,
         issueNumber,
         agentName: agentName as string,
+        options: { actor },
       });
 
       const updatedLabels = released.labels;
diff --git a/src/app/api/issues/webhook/route.test.ts b/src/app/api/issues/webhook/route.test.ts
index cdd7dd06..19b175eb 100644
--- a/src/app/api/issues/webhook/route.test.ts
+++ b/src/app/api/issues/webhook/route.test.ts
@@ -11,6 +11,8 @@ const { mocks } = vi.hoisted(() => ({
     repoFindUnique: vi.fn(),
     issueFindUnique: vi.fn(),
     issueUpdate: vi.fn(),
+    createLifecycleEvent: vi.fn(),
+    upsertLifecycleEvent: vi.fn(),
     invalidateGroomingForComment: vi.fn(),
   },
 }));
@@ -23,6 +25,10 @@ vi.mock("@/lib/prisma", () => ({
   prisma: {
     repository: { findUnique: mocks.repoFindUnique },
     issue: { findUnique: mocks.issueFindUnique, update: mocks.issueUpdate },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
+    },
   },
 }));
 
@@ -58,7 +64,7 @@ function postRequest(body: unknown, headers: Record<string, string> = {}) {
  * Builds a Request whose body bytes are exactly what the HMAC was computed
  * over, plus a valid x-hub-signature-256 header.
  */
-function signedRequest(body: unknown, rawBody?: string) {
+function signedRequest(body: unknown, rawBody?: string, extraHeaders: Record<string, string> = {}) {
   const bodyStr = rawBody ?? JSON.stringify(body);
   const sig =
     "sha256=" + crypto.createHmac("sha256", WEBHOOK_SECRET).update(bodyStr).digest("hex");
@@ -69,6 +75,7 @@ function signedRequest(body: unknown, rawBody?: string) {
       "Content-Type": "application/json",
       "x-github-event": "issues",
       "x-hub-signature-256": sig,
+      ...extraHeaders,
     },
     body: bodyStr,
   });
@@ -92,6 +99,8 @@ describe("POST /api/issues/webhook", () => {
       labels: ["status/backlog"],
     });
     mocks.issueUpdate.mockResolvedValue({ id: "issue-1", labels: ["status/backlog"] });
+    mocks.createLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+    mocks.upsertLifecycleEvent.mockResolvedValue({ id: "evt-1" });
   });
 
   describe("signature verification (fail-closed default)", () => {
@@ -363,3 +372,86 @@ describe("POST /api/issues/webhook", () => {
     });
   });
 });
+
+describe("POST /api/issues/webhook — lifecycle evidence (#1202)", () => {
+  beforeEach(() => {
+    delete process.env.DISPATCH_AUTH_MODE;
+    delete process.env.WEBHOOK_GATEWAY_MODE;
+    process.env.WEBHOOK_SECRET = WEBHOOK_SECRET;
+    resetAuthCaches();
+    resetRateLimits();
+    vi.clearAllMocks();
+    mocks.repoFindUnique.mockResolvedValue({ id: "repo-1", fullName: "org/repo" });
+    mocks.issueFindUnique.mockResolvedValue({
+      id: "issue-1",
+      number: 42,
+      repositoryId: "repo-1",
+      labels: ["status/backlog"],
+    });
+    mocks.issueUpdate.mockResolvedValue({ id: "issue-1" });
+    mocks.createLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+    mocks.upsertLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+  });
+
+  const statusDelivery = makeIssuesEvent({
+    action: "labeled",
+    label: { name: "status/ready" },
+    issue: { number: 42, updated_at: "2026-10-02T08:00:00Z" },
+    sender: { login: "octocat" },
+  });
+
+  it("records a status label move with the delivery as its idempotency identity", async () => {
+    const res = await POST(signedRequest(statusDelivery, undefined, { "x-github-delivery": "delivery-1" }));
+    expect(res.status).toBe(200);
+
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledWith({
+      where: { dedupeKey: "webhook|org/repo|42|delivery-1|status/ready" },
+      create: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "webhook",
+        actor: "octocat",
+        fromStatus: "status/backlog",
+        toStatus: "status/ready",
+        sourceEventId: "delivery-1",
+        // GitHub sends no per-label timestamp, so the issue's own updated_at
+        // is the occurrence time — and the observation stays on the clock.
+        occurredAt: new Date("2026-10-02T08:00:00Z"),
+      }),
+      update: {},
+    });
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
+
+  it("upserts the same identity when GitHub redelivers", async () => {
+    await POST(signedRequest(statusDelivery, undefined, { "x-github-delivery": "delivery-1" }));
+    await POST(signedRequest(statusDelivery, undefined, { "x-github-delivery": "delivery-1" }));
+
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledTimes(2);
+    const keys = mocks.upsertLifecycleEvent.mock.calls.map((call: any[]) => call[0].where.dedupeKey);
+    expect(new Set(keys).size).toBe(1);
+  });
+
+  it("still records a move for a delivery that carries no delivery id", async () => {
+    const res = await POST(signedRequest(statusDelivery));
+    expect(res.status).toBe(200);
+
+    // No source identity to key on, so the write is a plain insert and the
+    // label-set check is what makes a repeat a no-op.
+    expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({ kind: "status_changed", source: "webhook", sourceEventId: null }),
+    });
+  });
+
+  it("records nothing for a non-status label", async () => {
+    const res = await POST(signedRequest(makeIssuesEvent({ action: "labeled", label: { name: "type/bug" } })));
+    expect(res.status).toBe(200);
+
+    expect(mocks.issueUpdate).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+    expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/app/api/issues/webhook/route.ts b/src/app/api/issues/webhook/route.ts
index 18618aeb..45a0ffeb 100644
--- a/src/app/api/issues/webhook/route.ts
+++ b/src/app/api/issues/webhook/route.ts
@@ -5,6 +5,24 @@ import { prisma } from "@/lib/prisma";
 import { getSignatureVerificationMode, verifyWebhookSignature } from "@/lib/webhook-signature";
 import { enforceRateLimit } from "@/lib/rate-limit";
 import { invalidateGroomingForComment } from "@/lib/groomer/freshness-invalidation";
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  recordLifecycleEventQuietly,
+} from "@/lib/issue-lifecycle";
+
+/** Parse a GitHub ISO timestamp, ignoring absent or unparseable values. */
+function parseGithubTimestamp(value: unknown): Date | undefined {
+  if (typeof value !== "string" || !value) return undefined;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+
+/** Who GitHub says caused the change — the sender, not the authenticated caller. */
+function deliveryActor(body: Record<string, any>): string {
+  const sender = body.sender?.login;
+  return typeof sender === "string" && sender ? sender : "github";
+}
 
 /**
  * GitHub Webhook Handler for Issue Label Events
@@ -33,6 +51,11 @@ export async function POST(request: Request) {
       return errorResponse("Missing x-github-event header", 400);
     }
 
+    // GitHub's own identity for this delivery. Present on every real
+    // delivery and absent only from hand-rolled replays, which is exactly the
+    // distinction the lifecycle event's dedupe key needs (#1202).
+    const deliveryId = request.headers.get("x-github-delivery")?.trim() || null;
+
     // Read raw body before authorization so that if authorizeRequest ever
     // consumes the body stream, HMAC verification still operates on the real payload.
     const rawBody = await request.arrayBuffer();
@@ -164,6 +187,51 @@ export async function POST(request: Request) {
       data: { labels: nextLabels, lastSyncedAt: new Date() },
     });
 
+    // A status label moving on GitHub is a transition in the lifecycle stream
+    // with GitHub, not Dispatch, as its source (#1202).
+    //
+    // The from/to values come from the delivery's own label rather than from
+    // diffing the cached label sets: GitHub fires one event per label, so a
+    // status swap reaches the cache as "labeled new" while the old label is
+    // still on it, and a set diff would read that as no transition at all.
+    // The route's own no-op handling (adding a label that is already present,
+    // removing one that is absent leaves `nextLabels` equal to `currentLabels`)
+    // is what makes a repeat delivery a no-op here. The delivery id is GitHub's
+    // identity for the event, so a redelivery upserts the row it already wrote
+    // instead of counting as a second move.
+    //
+    // GitHub sends no per-label timestamp, so the issue's own updated_at
+    // stands in as the occurrence time and is labelled as such in metadata —
+    // the observation time is never backdated to it.
+    if (labelName.startsWith("status/") && nextLabels !== currentLabels) {
+      const statusUpdatedAt = parseGithubTimestamp(body.issue?.updated_at);
+      const added = action === "labeled";
+      await recordLifecycleEventQuietly(
+        prisma,
+        {
+          issueId: cachedIssue.id,
+          repoFullName,
+          issueNumber,
+          kind: "status_changed",
+          source: "webhook",
+          actor: deliveryActor(body),
+          fromStatus: added ? lifecycleStatusLabel(currentLabels) : labelName,
+          toStatus: added ? labelName : lifecycleStatusLabel(nextLabels),
+          sourceEventId: deliveryId,
+          dedupeKey: deliveryId
+            ? lifecycleDedupeKey("webhook", repoFullName, issueNumber, deliveryId, labelName)
+            : null,
+          occurredAt: statusUpdatedAt,
+          metadata: {
+            action,
+            label: labelName,
+            ...(statusUpdatedAt ? { occurredAtSource: "issue.updated_at" } : {}),
+          },
+        },
+        "issues webhook",
+      );
+    }
+
     return NextResponse.json({
       message: `Issue label cache updated: ${repoFullName}#${issueNumber}`,
       action,
diff --git a/src/app/api/sync/scheduled/route.ts b/src/app/api/sync/scheduled/route.ts
index 97c75cd3..f654557a 100644
--- a/src/app/api/sync/scheduled/route.ts
+++ b/src/app/api/sync/scheduled/route.ts
@@ -7,7 +7,7 @@ import {
   syncIssuesForRepos,
   reconcileClosedIssues,
   makePrismaIssueStore,
-  findActiveCachedIssuesForReconcile,
+  makePrismaReconcileIssueStore,
   fetchAllStateIssues,
   SyncResponse,
   ClosedIssueReconcileResponse,
@@ -69,19 +69,7 @@ export async function POST(request: Request) {
 
       // Reconcile closed issues with stale active statuses
       try {
-        closedIssueReconcile = await reconcileClosedIssues(repos, fetchIssue, {
-          findActiveCachedIssues: findActiveCachedIssuesForReconcile,
-          async updateIssue(id, data) {
-            await prisma.issue.update({
-              where: { id },
-              data: {
-                labels: data.labels,
-                state: data.state,
-                closedAt: data.closedAt,
-              },
-            });
-          },
-        });
+        closedIssueReconcile = await reconcileClosedIssues(repos, fetchIssue, makePrismaReconcileIssueStore());
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
         console.error("Closed issue reconciliation failed:", error);
diff --git a/src/lib/groomer/run.test.ts b/src/lib/groomer/run.test.ts
index 592eefe7..c85120c6 100644
--- a/src/lib/groomer/run.test.ts
+++ b/src/lib/groomer/run.test.ts
@@ -52,6 +52,7 @@ const { mocks } = vi.hoisted(() => ({
       groomingChildClaim: { findUnique: vi.fn(), create: vi.fn(), update: vi.fn() },
       groomerPendingReply: { updateMany: vi.fn(), upsert: vi.fn() },
       issue: { update: vi.fn(), findMany: vi.fn() },
+      issueLifecycleEvent: { create: vi.fn(), upsert: vi.fn() },
       issueLane: { create: vi.fn() },
       agentRun: { create: vi.fn() },
       auditLog: { create: vi.fn() },
@@ -936,6 +937,34 @@ describe("runHostedGroomer", () => {
     );
   });
 
+  it("write mode records the status move the grooming plan made (#1202)", async () => {
+    await runHostedGroomer();
+
+    // The groomer writes labels to GitHub; the issue cache only catches up on
+    // the next sync. Recording the move here is what keeps the transition
+    // attributable to the groomer instead of to whatever sync ran next.
+    const event = mocks.prisma.issueLifecycleEvent.create.mock.calls.at(-1)?.[0]?.data;
+    expect(event).toMatchObject({
+      issueId: "issue-42",
+      repoFullName: "org/repo",
+      issueNumber: 42,
+      kind: "status_changed",
+      source: "hosted-groomer",
+      actor: "hosted-groomer",
+    });
+  });
+
+  it("keeps the run successful when the lifecycle write fails", async () => {
+    mocks.prisma.issueLifecycleEvent.create.mockRejectedValue(new Error("db down"));
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const result = await runHostedGroomer();
+
+    expect(result).toBeTruthy();
+    expect(mocks.prisma.auditLog.create).toHaveBeenCalled();
+    expect(warn).toHaveBeenCalled();
+  });
+
   it("passes untrusted commenter trust decisions into the prompt", async () => {
     const { buildIssueContext } = await vi.importActual<typeof import("./context")>("./context");
     let capturedInput: Parameters<typeof buildIssueContext>[0] | undefined;
diff --git a/src/lib/groomer/run.ts b/src/lib/groomer/run.ts
index 2227eb16..8a3419f6 100644
--- a/src/lib/groomer/run.ts
+++ b/src/lib/groomer/run.ts
@@ -28,6 +28,7 @@ import { createGroomingRunRecord, completeGroomingRunRecord, updateGroomingRunRe
 import { explorationCallsForFreshness } from "./freshness";
 import { freshnessBaselineIssueData } from "./freshness-invalidation";
 import { compareCommits, searchRepositoryCode } from "@/lib/github-code-search";
+import { lifecycleStatusLabel, recordLifecycleEventQuietly } from "@/lib/issue-lifecycle";
 import { fetchCommitDate } from "@/lib/github-ci";
 import { validateApplyPreconditions, type LiveComment, type PreconditionReader } from "./mutation-validator";
 import {
@@ -1221,6 +1222,30 @@ async function executeGroomerRun(
       },
     });
 
+    // Record the status move the grooming plan actually made (#1202). The
+    // labels only reach the issue cache on the next sync, so without this the
+    // groomer's own transition would first be observable as a `sync` event and
+    // a claim-to-merge read could not tell who moved the card. Quiet by
+    // design: a grooming run that already landed its mutations must not fail
+    // over an evidence row, and a replayed application records nothing because
+    // this branch is only reached the first time the application key lands.
+    await recordLifecycleEventQuietly(
+      deps.prisma,
+      {
+        issueId: candidate.id,
+        repoFullName: candidate.repoFullName,
+        issueNumber: candidate.number,
+        kind: "status_changed",
+        source: "hosted-groomer",
+        actor: "hosted-groomer",
+        fromStatus: lifecycleStatusLabel(analyzed.labels),
+        toStatus: lifecycleStatusLabel(applied.labels),
+        occurredAt: new Date(),
+        metadata: { groomingRunId: groomingRun.id, applicationKey },
+      },
+      "hosted-groomer",
+    );
+
     // Complete GroomingRun. A partial application is explicit in history
     // and retryable: every landed step is recorded, so a retry of the same
     // application replays them instead of repeating them.
diff --git a/src/lib/heartbeat.ts b/src/lib/heartbeat.ts
index 4fe42927..d404f6e4 100644
--- a/src/lib/heartbeat.ts
+++ b/src/lib/heartbeat.ts
@@ -5,14 +5,13 @@
  * the agent-agnostic heartbeat endpoint and any future orchestrator.
  */
 
-import { prisma } from "@/lib/prisma";
 import { fetchIssue, syncStatusLabels } from "@/lib/github";
 import { getSyncRepos, parseExcludedLabels } from "@/lib/config";
 import {
   syncIssuesForRepos,
   reconcileClosedIssues,
   makePrismaIssueStore,
-  findActiveCachedIssuesForReconcile,
+  makePrismaReconcileIssueStore,
   fetchAllStateIssues,
 } from "@/lib/issue-sync";
 
@@ -104,12 +103,7 @@ export async function runReconcileBestEffort(): Promise<ReconcileStepResult> {
       return { issuesReconciled: 0, issuesChecked: 0, reposProcessed: 0, warnings, errors };
     }
 
-    const result = await reconcileClosedIssues(repos, fetchIssue, {
-      findActiveCachedIssues: findActiveCachedIssuesForReconcile,
-      async updateIssue(id: string, data: { labels: string[]; state: string; closedAt: Date | null }) {
-        await prisma.issue.update({ where: { id }, data });
-      },
-    });
+    const result = await reconcileClosedIssues(repos, fetchIssue, makePrismaReconcileIssueStore());
 
     for (const r of result.results) {
       if (r.error && !r.reconciled) {
diff --git a/src/lib/issue-claim.test.ts b/src/lib/issue-claim.test.ts
index 969425d4..734583d6 100644
--- a/src/lib/issue-claim.test.ts
+++ b/src/lib/issue-claim.test.ts
@@ -407,3 +407,123 @@ describe("releaseIssueClaim — guards", () => {
     expect(update).not.toHaveBeenCalled();
   });
 });
+
+describe("releaseIssueClaim — lifecycle evidence (#1202)", () => {
+  /** A client that records lifecycle events, with a real transaction shape. */
+  function makeLifecyclePrisma(overrides: Partial<{ labels: string[] }> = {}) {
+    const base = makePrisma(overrides);
+    const createEvent = vi.fn().mockResolvedValue({ id: "evt-1" });
+    const upsertEvent = vi.fn().mockResolvedValue({ id: "evt-1" });
+    const client: IssueClaimClient = {
+      issue: base.client.issue,
+      issueLifecycleEvent: { create: createEvent, upsert: upsertEvent },
+      $transaction: (fn: any) => Promise.resolve(fn({
+        issue: base.client.issue,
+        issueLifecycleEvent: { create: createEvent, upsert: upsertEvent },
+      })),
+    };
+    return { client, createEvent, upsertEvent, update: base.update };
+  }
+
+  it("records the release with the status it left behind", async () => {
+    const { client, createEvent } = makeLifecyclePrisma();
+
+    await callRelease(client, ["agent/alpha", "status/in-progress"], {});
+
+    expect(createEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: REPO,
+        issueNumber: ISSUE_NUMBER,
+        kind: "claim_released",
+        source: "api:unclaim",
+        actor: "alpha",
+        agentName: "alpha",
+        fromStatus: "status/in-progress",
+        toStatus: "status/ready",
+      }),
+    });
+  });
+
+  it("records the release even when the status is deliberately retained", async () => {
+    const { client, createEvent } = makeLifecyclePrisma();
+
+    await callRelease(
+      client,
+      ["agent/alpha", "status/in-review"],
+      { releaseOptions: { preserveStatus: true } },
+    );
+
+    // A release that keeps in-review still happened, and the unchanged status
+    // is what makes it distinguishable from a finished attempt.
+    expect(createEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        kind: "claim_released",
+        fromStatus: "status/in-review",
+        toStatus: "status/in-review",
+      }),
+    });
+  });
+
+  it("attributes a stale sweep's release to the sweep, not to the abandoned agent", async () => {
+    const { client, createEvent } = makeLifecyclePrisma();
+
+    await callRelease(
+      client,
+      ["agent/alpha", "status/in-progress"],
+      {
+        releaseOptions: {
+          allowMissingAgent: true,
+          preserveStatus: true,
+          source: "stale-recovery",
+          actor: "system",
+        },
+      },
+    );
+
+    expect(createEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        kind: "claim_released",
+        source: "stale-recovery",
+        actor: "system",
+        agentName: "alpha",
+      }),
+    });
+  });
+
+  it("de-duplicates the already-released repair a repeated sweep performs", async () => {
+    const { client, createEvent, upsertEvent } = makeLifecyclePrisma({ labels: ["status/in-progress"] });
+
+    const options = { allowMissingAgent: true, source: "stale-recovery", actor: "system" } as const;
+    await callRelease(client, ["status/in-progress"], { releaseOptions: options });
+    await callRelease(client, ["status/in-progress"], { releaseOptions: options });
+
+    // A sweep that dies mid-release retries the same repair; it must not
+    // inflate the release count.
+    expect(upsertEvent).toHaveBeenCalledTimes(2);
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(upsertEvent.mock.calls[0][0].create.dedupeKey).toBe(
+      upsertEvent.mock.calls[1][0].create.dedupeKey,
+    );
+  });
+
+  it("records nothing when the claim belongs to another agent", async () => {
+    const { client, createEvent, update } = makeLifecyclePrisma();
+
+    await callRelease(client, ["agent/beta", "status/in-progress"], { agentName: "alpha" });
+
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it("records nothing for a narrow client that cannot record events", async () => {
+    // Callers that pass only an issue surface (test fakes, partial clients)
+    // keep working: the release still lands, it just has no evidence row.
+    const { client, update } = makePrisma();
+
+    const result = await callRelease(client, ["agent/alpha", "status/in-progress"], {});
+
+    expect(result.released).toBe(true);
+    expect(update).toHaveBeenCalled();
+  });
+});
diff --git a/src/lib/issue-claim.ts b/src/lib/issue-claim.ts
index 41d06f82..3069051f 100644
--- a/src/lib/issue-claim.ts
+++ b/src/lib/issue-claim.ts
@@ -2,6 +2,14 @@ import { AGENT_PREFIX, getAgentFromLabels } from "@/types";
 import { removeIssueLabel } from "@/lib/github";
 import { transitionIssueStatus } from "@/lib/issue-status";
 import { fetchPullRequestState } from "@/lib/github-prs";
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  recordLifecycleEvent,
+  type LifecycleEventClient,
+  type LifecycleEventWrite,
+  type LifecycleSource,
+} from "@/lib/issue-lifecycle";
 
 /** The issue fields needed by the shared claim-release policy. */
 export interface IssueClaimRecord {
@@ -17,6 +25,10 @@ export interface ReleaseIssueClaimOptions {
   allowMissingAgent?: boolean;
   /** Release ownership only; preserve the current status label. */
   preserveStatus?: boolean;
+  /** Lifecycle source for the release. Defaults to the operator/agent unclaim route. */
+  source?: LifecycleSource;
+  /** Lifecycle actor for the release. Defaults to the releasing agent. */
+  actor?: string;
 }
 
 export interface ReleaseIssueClaimResult {
@@ -32,6 +44,15 @@ export interface IssueClaimClient {
     update: (args: any) => Promise<unknown>;
     findUnique?: (args: any) => Promise<any>;
   };
+  /** Present on the real client; absent in fakes that do not record events. */
+  issueLifecycleEvent?: LifecycleEventClient["issueLifecycleEvent"];
+  /**
+   * When present, the cache write and the lifecycle event commit together, so
+   * a release is never visible without its evidence row (#1202). The
+   * transaction client's type is left open because the stale-work sweep passes
+   * its own narrower transaction shape.
+   */
+  $transaction?: <T>(fn: (tx: any) => Promise<T>) => Promise<T>;
 }
 
 /**
@@ -40,6 +61,11 @@ export interface IssueClaimClient {
  * The operator unclaim route and stale-work recovery use this same mutation
  * core. Stale recovery uses ownership-only mode so it never rewrites a status
  * label while recovering an abandoned claim.
+ *
+ * Both callers also get the `claim_released` lifecycle event from here, so a
+ * release is recorded wherever it is decided — with the status the release
+ * left behind, which for a deliberate `preserveStatus` recovery is the status
+ * the issue already had, and never a guess that the work finished.
  */
 export async function releaseIssueClaim(params: {
   prisma: IssueClaimClient;
@@ -53,6 +79,49 @@ export async function releaseIssueClaim(params: {
   const options = params.options ?? {};
   const agentLabel = `${AGENT_PREFIX}${agentName}`;
   const currentAgent = getAgentFromLabels(issue.labels);
+  const source = options.source ?? "api:unclaim";
+  const actor = options.actor ?? agentName;
+
+  /**
+   * Commit the local label mirror and its release event together when the
+   * client supports a transaction; otherwise write them in order. Both are
+   * skipped into a no-op when the client cannot record events (test fakes and
+   * callers that pass a narrow client).
+   */
+  const commitRelease = async (labels: string[], event: LifecycleEventWrite) => {
+    const write = async (tx: IssueClaimClient) => {
+      await tx.issue.update({
+        where: { id: issue.id },
+        data: { labels, lastSyncedAt: new Date() },
+      });
+      if (tx.issueLifecycleEvent) {
+        await recordLifecycleEvent({ issueLifecycleEvent: tx.issueLifecycleEvent }, event);
+      }
+    };
+
+    if (typeof prisma.$transaction === "function") {
+      await prisma.$transaction((tx) => write(tx));
+      return;
+    }
+    await write(prisma);
+  };
+
+  const releaseEvent = (
+    from: string[],
+    to: string[],
+    dedupeKey?: string,
+  ): LifecycleEventWrite => ({
+    issueId: issue.id,
+    repoFullName,
+    issueNumber,
+    kind: "claim_released",
+    source,
+    actor,
+    agentName,
+    fromStatus: lifecycleStatusLabel(from),
+    toStatus: lifecycleStatusLabel(to),
+    dedupeKey: dedupeKey ?? null,
+  });
 
   // Never remove a newer agent's claim while an old AgentWork row is being
   // recovered. The stale-work caller can still retire the old local row.
@@ -78,10 +147,17 @@ export async function releaseIssueClaim(params: {
       ? await prisma.issue.findUnique({ where: { id: issue.id }, select: { labels: true } })
       : null;
     const cacheLabels = latestIssue?.labels ?? issue.labels;
-    await prisma.issue.update({
-      where: { id: issue.id },
-      data: { labels: cacheLabels, lastSyncedAt: new Date() },
-    });
+    // A sweep that dies between the GitHub release and the final AgentWork
+    // update repeats this repair, so the release event carries an identity:
+    // the same already-released repair cannot be recorded twice.
+    await commitRelease(
+      cacheLabels,
+      releaseEvent(
+        issue.labels,
+        cacheLabels,
+        lifecycleDedupeKey("claim-released", issue.id, agentLabel, "already-released"),
+      ),
+    );
     return {
       released: true,
       labels: cacheLabels,
@@ -101,10 +177,7 @@ export async function releaseIssueClaim(params: {
       ? await prisma.issue.findUnique({ where: { id: issue.id }, select: { labels: true } })
       : null;
     const cacheLabels = latestIssue?.labels?.filter((label: string) => label !== agentLabel) ?? updatedLabels;
-    await prisma.issue.update({
-      where: { id: issue.id },
-      data: { labels: cacheLabels, lastSyncedAt: new Date() },
-    });
+    await commitRelease(cacheLabels, releaseEvent(issue.labels, cacheLabels));
     return {
       released: true,
       labels: cacheLabels,
@@ -158,10 +231,7 @@ export async function releaseIssueClaim(params: {
   // silently revert every label change made on GitHub since the last sync.
   await removeIssueLabel(repoFullName, issueNumber, agentLabel);
 
-  await prisma.issue.update({
-    where: { id: issue.id },
-    data: { labels: updatedLabels, lastSyncedAt: new Date() },
-  });
+  await commitRelease(updatedLabels, releaseEvent(issue.labels, updatedLabels));
 
   return {
     released: true,
diff --git a/src/lib/issue-lifecycle.test.ts b/src/lib/issue-lifecycle.test.ts
new file mode 100644
index 00000000..3515ebf1
--- /dev/null
+++ b/src/lib/issue-lifecycle.test.ts
@@ -0,0 +1,357 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  lifecycleStatusTransition,
+  recordClaimEvent,
+  recordLifecycleEvent,
+  recordLifecycleEventQuietly,
+  recordStatusTransition,
+  recordSyncedIssueEvents,
+  type LifecycleEventClient,
+} from "./issue-lifecycle";
+
+/**
+ * A `prisma.issueLifecycleEvent` stand-in. The recorder only ever writes
+ * through these two methods, and the fake keeps rows keyed by `dedupeKey` the
+ * way the real unique index does, so an upsert's idempotency is observable
+ * here rather than asserted by hand.
+ */
+function makeClient() {
+  const rows: Array<Record<string, any>> = [];
+  const client: LifecycleEventClient = {
+    issueLifecycleEvent: {
+      create: vi.fn(async ({ data }) => {
+        rows.push({ ...data });
+        return data;
+      }),
+      upsert: vi.fn(async ({ where, create }) => {
+        const existing = rows.find((row) => row.dedupeKey === where.dedupeKey);
+        if (existing) return existing;
+        rows.push({ ...create });
+        return create;
+      }),
+    },
+  };
+  return { client, rows };
+}
+
+const base = {
+  issueId: "issue-1",
+  repoFullName: "octocat/hello-world",
+  issueNumber: 42,
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("lifecycleStatusLabel / lifecycleStatusTransition", () => {
+  it("reads the status label an issue carries", () => {
+    expect(lifecycleStatusLabel(["type/bug", "status/in-review"])).toBe("status/in-review");
+    expect(lifecycleStatusLabel(["type/bug"])).toBeNull();
+  });
+
+  it("reports no transition when the status label is unchanged", () => {
+    // A redelivered write, or a sync over unchanged GitHub state, must not
+    // look like a new transition.
+    expect(
+      lifecycleStatusTransition(["status/ready", "agent/alpha"], ["agent/alpha", "type/bug", "status/ready"]),
+    ).toBeNull();
+    expect(lifecycleStatusTransition(["type/bug"], ["type/bug", "priority/p0"])).toBeNull();
+  });
+
+  it("reports the transition when the status label moves", () => {
+    expect(lifecycleStatusTransition(["status/ready"], ["status/in-progress"])).toEqual({
+      from: "status/ready",
+      to: "status/in-progress",
+    });
+    expect(lifecycleStatusTransition(["status/in-review"], ["type/bug"])).toEqual({
+      from: "status/in-review",
+      to: null,
+    });
+    expect(lifecycleStatusTransition(["type/bug"], ["type/bug", "status/done"])).toEqual({
+      from: null,
+      to: "status/done",
+    });
+  });
+});
+
+describe("recordLifecycleEvent", () => {
+  it("records occurrence and observation together for a Dispatch-authored write", async () => {
+    const { client, rows } = makeClient();
+    const before = new Date("2026-10-01T00:00:00.000Z");
+
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(before);
+      await recordLifecycleEvent(client, {
+        ...base,
+        kind: "claim",
+        source: "api:claim",
+        actor: "alpha",
+        agentName: "alpha",
+        fromStatus: "status/ready",
+        toStatus: "status/in-progress",
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      issueId: "issue-1",
+      repoFullName: "octocat/hello-world",
+      issueNumber: 42,
+      kind: "claim",
+      source: "api:claim",
+      actor: "alpha",
+      agentName: "alpha",
+      fromStatus: "status/ready",
+      toStatus: "status/in-progress",
+      occurredAt: before,
+      observedAt: before,
+    });
+    expect(client.issueLifecycleEvent.create).toHaveBeenCalledTimes(1);
+  });
+
+  it("upserts on the dedupe key so a redelivery cannot duplicate the event", async () => {
+    const { client, rows } = makeClient();
+    const write = {
+      ...base,
+      kind: "status_changed" as const,
+      source: "webhook" as const,
+      actor: "github",
+      dedupeKey: lifecycleDedupeKey("webhook", "octocat/hello-world", 42, "delivery-1", "status/done"),
+    };
+
+    await recordLifecycleEvent(client, write);
+    await recordLifecycleEvent(client, { ...write, actor: "someone-else", occurredAt: new Date(0) });
+
+    expect(rows).toHaveLength(1);
+    // The second delivery must not rewrite the first one's provenance either.
+    expect(rows[0].actor).toBe("github");
+    expect(client.issueLifecycleEvent.upsert).toHaveBeenCalledTimes(2);
+  });
+
+  it("keeps occurrence and observation apart for an observed event", async () => {
+    const { client, rows } = makeClient();
+    const occurredAt = new Date("2026-10-01T12:00:00.000Z");
+    const observedAt = new Date("2026-10-01T13:30:00.000Z");
+
+    await recordLifecycleEvent(client, {
+      ...base,
+      kind: "issue_closed",
+      source: "sync",
+      actor: "github",
+      occurredAt,
+      observedAt,
+    });
+
+    expect(rows[0].occurredAt).toEqual(occurredAt);
+    expect(rows[0].observedAt).toEqual(observedAt);
+  });
+});
+
+describe("recordStatusTransition", () => {
+  it("records nothing when the status label did not move", async () => {
+    const { client, rows } = makeClient();
+
+    const recorded = await recordStatusTransition(client, {
+      ...base,
+      kind: "status_changed",
+      source: "api:status",
+      actor: "alpha",
+      before: ["status/ready"],
+      after: ["status/ready", "agent/alpha"],
+    });
+
+    expect(recorded).toBe(false);
+    expect(rows).toHaveLength(0);
+  });
+
+  it("records the from/to pair when the status label moved", async () => {
+    const { client, rows } = makeClient();
+
+    const recorded = await recordStatusTransition(client, {
+      ...base,
+      kind: "status_changed",
+      source: "api:move",
+      actor: "operator",
+      before: ["status/ready"],
+      after: ["status/in-review"],
+    });
+
+    expect(recorded).toBe(true);
+    expect(rows[0]).toMatchObject({
+      kind: "status_changed",
+      source: "api:move",
+      fromStatus: "status/ready",
+      toStatus: "status/in-review",
+    });
+  });
+});
+
+describe("recordClaimEvent", () => {
+  it("records the claim that also moves the status label", async () => {
+    const { client, rows } = makeClient();
+
+    await recordClaimEvent(client, {
+      ...base,
+      kind: "claim",
+      source: "api:claim",
+      actor: "alpha",
+      agentName: "alpha",
+      before: ["status/ready"],
+      after: ["status/in-progress", "agent/alpha"],
+    });
+
+    expect(rows[0]).toMatchObject({ kind: "claim", fromStatus: "status/ready", toStatus: "status/in-progress" });
+  });
+
+  it("records a force-claim that only changes ownership", async () => {
+    const { client, rows } = makeClient();
+
+    await recordClaimEvent(client, {
+      ...base,
+      kind: "claim",
+      source: "api:claim",
+      actor: "bravo",
+      agentName: "bravo",
+      before: ["status/in-progress", "agent/alpha"],
+      after: ["status/in-progress", "agent/bravo"],
+    });
+
+    expect(rows[0]).toMatchObject({ kind: "claim", fromStatus: "status/in-progress", toStatus: "status/in-progress" });
+    expect(rows[0].metadata).toMatchObject({ claimedFrom: "agent/alpha", claimedTo: "agent/bravo" });
+  });
+
+  it("records nothing for a redelivered claim of an already-claimed issue", async () => {
+    const { client, rows } = makeClient();
+    const labels = ["status/in-progress", "agent/alpha"];
+
+    // Claim → release → reclaim keeps both attempts and the first claim; the
+    // repeated delivery in the middle is not a new attempt.
+    await recordClaimEvent(client, {
+      ...base, kind: "claim", source: "api:claim", actor: "alpha", agentName: "alpha",
+      before: ["status/ready"], after: labels,
+    });
+    await recordClaimEvent(client, {
+      ...base, kind: "claim", source: "api:claim", actor: "alpha", agentName: "alpha",
+      before: labels, after: labels,
+    });
+
+    expect(rows).toHaveLength(1);
+  });
+});
+
+describe("recordSyncedIssueEvents", () => {
+  const syncedAt = new Date("2026-10-02T08:00:00.000Z");
+
+  it("records a status move with the source's occurrence time, not the observation time", async () => {
+    const { client, rows } = makeClient();
+
+    await recordSyncedIssueEvents(client, {
+      ...base,
+      before: { labels: ["status/ready"], state: "open" },
+      after: { labels: ["status/in-review"], state: "open", updatedAt: syncedAt },
+    });
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ kind: "status_changed", source: "sync", fromStatus: "status/ready", toStatus: "status/in-review" });
+    expect(rows[0].occurredAt).toEqual(syncedAt);
+    expect(rows[0].observedAt.getTime()).toBeGreaterThanOrEqual(syncedAt.getTime());
+  });
+
+  it("collapses a repeated sync over unchanged GitHub state onto one row", async () => {
+    const { client, rows } = makeClient();
+    const input = {
+      ...base,
+      before: { labels: ["status/ready"], state: "open" },
+      after: { labels: ["status/done"], state: "closed", updatedAt: syncedAt, closedAt: syncedAt },
+    };
+
+    await recordSyncedIssueEvents(client, input);
+    await recordSyncedIssueEvents(client, input);
+    await recordSyncedIssueEvents(client, input);
+
+    // One status move plus one close, regardless of how many sync passes ran.
+    expect(rows.map((row) => row.kind).sort()).toEqual(["issue_closed", "status_changed"]);
+    expect(rows.every((row) => row.dedupeKey)).toBe(true);
+  });
+
+  it("records a close and a reopen as distinct facts", async () => {
+    const { client, rows } = makeClient();
+    const reopenedAt = new Date("2026-10-04T09:00:00.000Z");
+
+    await recordSyncedIssueEvents(client, {
+      ...base,
+      before: { labels: ["status/done"], state: "open" },
+      after: { labels: ["status/ready"], state: "closed", updatedAt: syncedAt, closedAt: syncedAt },
+    });
+    await recordSyncedIssueEvents(client, {
+      ...base,
+      before: { labels: ["status/ready"], state: "closed" },
+      after: { labels: ["status/ready"], state: "open", updatedAt: reopenedAt },
+    });
+
+    // The reopen moved no status label; only the state changed, and it is
+    // recorded under its own identity rather than as a second transition.
+    expect(rows.map((row) => row.kind)).toEqual(["status_changed", "issue_closed", "issue_reopened"]);
+  });
+
+  it("never writes back to the issue, so a late observation cannot move the present status", async () => {
+    const { client } = makeClient();
+
+    // The client only exposes the event table: recording is evidence, so the
+    // caller has no way to mutate issue state from here at all.
+    await recordSyncedIssueEvents(client, {
+      ...base,
+      before: { labels: ["status/in-progress"], state: "open" },
+      after: { labels: ["status/ready"], state: "open", updatedAt: syncedAt },
+    });
+
+    expect(Object.keys(client)).toEqual(["issueLifecycleEvent"]);
+  });
+
+  it("keeps a failed sync write from failing the sync", async () => {
+    const { client } = makeClient();
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.mocked(client.issueLifecycleEvent.create).mockRejectedValue(new Error("db down"));
+
+    await expect(
+      recordSyncedIssueEvents(client, {
+        ...base,
+        before: { labels: ["status/ready"], state: "open" },
+        after: { labels: ["status/done"], state: "open", updatedAt: syncedAt },
+      }),
+    ).resolves.toBeUndefined();
+  });
+});
+
+describe("recordLifecycleEventQuietly", () => {
+  it("swallows the failure and says which event was lost", async () => {
+    const { client } = makeClient();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.mocked(client.issueLifecycleEvent.create).mockRejectedValue(new Error("db down"));
+
+    await recordLifecycleEventQuietly(
+      client,
+      { ...base, kind: "completed", source: "agent-report", actor: "alpha" },
+      "agent task report",
+    );
+
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("octocat/hello-world#42"));
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("agent task report"));
+  });
+});
+
+describe("lifecycleDedupeKey", () => {
+  it("is stable across calls and tolerant of absent parts", () => {
+    expect(lifecycleDedupeKey("sync", "org/repo", 7, null, undefined, "status/ready")).toBe(
+      lifecycleDedupeKey("sync", "org/repo", 7, null, undefined, "status/ready"),
+    );
+    expect(lifecycleDedupeKey("a", undefined, "b")).toBe("a||b");
+  });
+});
\ No newline at end of file
diff --git a/src/lib/issue-lifecycle.ts b/src/lib/issue-lifecycle.ts
new file mode 100644
index 00000000..cb4dd5ba
--- /dev/null
+++ b/src/lib/issue-lifecycle.ts
@@ -0,0 +1,424 @@
+import { getAgentFromLabels } from "@/types";
+
+/**
+ * Durable lifecycle event stream for a work item (#1202).
+ *
+ * `Issue` holds current state and `AuditLog` holds best-effort per-call
+ * history, but neither preserves the claim → release → reclaim sequence a
+ * later claim-to-merge read needs: audit rows are per-request, are not
+ * deduplicated, and a first claim cannot be told apart from later attempts.
+ * `IssueLifecycleEvent` is that record — append-only, ordered by when the
+ * transition happened, attributed to the writer that produced it.
+ *
+ * Three rules the whole codebase depends on:
+ *
+ * 1. **One contract.** Every status writer (claim, unclaim/stale recovery,
+ *    board move, manual status, hosted groomer, reconciler, sync, webhook,
+ *    worker report) goes through `recordStatusTransition` /
+ *    `recordLifecycleEvent` instead of hand-rolling an event insert, so the
+ *    taxonomy, the idempotency rules and the timestamps cannot drift per route.
+ * 2. **Events record transitions, not writes.** `recordStatusTransition` is a
+ *    no-op when the status label did not change, so a redelivered claim or a
+ *    repeated set-status cannot inflate the stream, while a genuine
+ *    release → reclaim pair still records both attempts and leaves the first
+ *    claim intact.
+ * 3. **Observation is never backdated.** A write Dispatch authors records
+ *    `occurredAt` = `observedAt` = now. An externally observed event keeps the
+ *    source's own occurrence time in `occurredAt` and the wall clock in
+ *    `observedAt`. Events are never replayed onto `Issue` state, so a late or
+ *    out-of-order delivery cannot move the present status.
+ */
+
+export const LIFECYCLE_EVENT_KINDS = [
+  /** An agent took ownership of the work item (claim/unclaim pairs bracket it). */
+  "claim",
+  /** Ownership was given up: unclaim, operator release, or stale recovery. */
+  "claim_released",
+  /** A worker reported a failed or blocked attempt on this item. */
+  "attempt_failed",
+  /** The `status/*` label moved. from/to carry the label values. */
+  "status_changed",
+  /** A worker report closed the item as already done (status/done + close). */
+  "completed",
+  /** The GitHub issue was observed closing. */
+  "issue_closed",
+  /** The GitHub issue was observed reopening after a close. */
+  "issue_reopened",
+  /** A PR that references this item was observed merged. */
+  "pr_merged",
+] as const;
+
+export type LifecycleEventKind = (typeof LIFECYCLE_EVENT_KINDS)[number];
+
+export const LIFECYCLE_SOURCES = [
+  /** POST /api/issues/claim */
+  "api:claim",
+  /** POST /api/issues/unclaim (agent self-release and operator release) */
+  "api:unclaim",
+  /** POST /api/issues/move (board drag-and-drop) */
+  "api:move",
+  /** POST /api/issues/status (agent/operator status set) */
+  "api:status",
+  /** POST /api/issues/groom (operator grooming decision) */
+  "api:groom",
+  /** Scheduled stale-AgentWork sweep releasing an abandoned claim. */
+  "stale-recovery",
+  /** The hosted groomer applying a grooming plan. */
+  "hosted-groomer",
+  /** POST /api/issues/reconcile reacting to PR state. */
+  "reconciler",
+  /** Issue sync ingesting GitHub state. */
+  "sync",
+  /** POST /api/issues/webhook ingesting a GitHub delivery. */
+  "webhook",
+  /** POST /api/agents/{agent}/tasks/report. */
+  "agent-report",
+] as const;
+
+export type LifecycleSource = (typeof LIFECYCLE_SOURCES)[number];
+
+/** The single `status/*` label on an issue, or null when it carries none. */
+export function lifecycleStatusLabel(labels: readonly string[]): string | null {
+  return labels.find((label) => label.startsWith("status/")) ?? null;
+}
+
+export interface LifecycleTransition {
+  from: string | null;
+  to: string | null;
+}
+
+/**
+ * The status transition between two label sets, or null when the status label
+ * is unchanged. Data-quality inputs can carry more than one `status/*` label;
+ * the first is treated as the status so an issue with two never reads as a
+ * transition on every sync.
+ */
+export function lifecycleStatusTransition(
+  before: readonly string[],
+  after: readonly string[],
+): LifecycleTransition | null {
+  const from = lifecycleStatusLabel(before);
+  const to = lifecycleStatusLabel(after);
+  if (from === to) return null;
+  return { from, to };
+}
+
+export interface LifecycleEventWrite {
+  issueId: string;
+  repoFullName: string;
+  issueNumber: number;
+  kind: LifecycleEventKind;
+  source: LifecycleSource;
+  /** The identity responsible: an agent name, an operator actor, or the writer's own name. */
+  actor: string;
+  agentName?: string | null;
+  fromStatus?: string | null;
+  toStatus?: string | null;
+  /**
+   * Identity of the event in the source system (GitHub delivery id, merged-PR
+   * identity). Provenance only — never used to deduplicate.
+   */
+  sourceEventId?: string | null;
+  /**
+   * Uniqueness identity for an externally observed event. Present, the write
+   * is an upsert: redelivery lands on the existing row instead of duplicating
+   * it. Absent, the caller has established the write is a real transition.
+   */
+  dedupeKey?: string | null;
+  /** When the transition happened. Defaults to now for Dispatch-authored writes. */
+  occurredAt?: Date;
+  /** When Dispatch saw it. Defaults to now. */
+  observedAt?: Date;
+  metadata?: Record<string, unknown> | null;
+}
+
+/**
+ * The write surface a lifecycle record needs. Both `prisma` and a
+ * `Prisma.TransactionClient` satisfy it, so a writer can persist the event in
+ * the same transaction as the local state it describes. The argument types are
+ * deliberately loose (`any`), the same way the other hand-rolled client
+ * interfaces in this codebase accept Prisma's generic method signatures.
+ */
+export interface LifecycleEventClient {
+  issueLifecycleEvent: {
+    create(args: any): Promise<unknown>;
+    upsert(args: any): Promise<unknown>;
+  };
+}
+
+/**
+ * Build the idempotency identity for an observed event out of stable parts.
+ * Every part must come from the source system, never from when Dispatch
+ * happened to look, or a repeated observation would not collapse.
+ */
+export function lifecycleDedupeKey(...parts: Array<string | number | null | undefined>): string {
+  return parts.map((part) => (part === null || part === undefined ? "" : String(part))).join("|");
+}
+
+/**
+ * Persist one lifecycle event. A write carrying a `dedupeKey` is an upsert, so
+ * a redelivered webhook or a repeated sync lands on the row that already holds
+ * that identity instead of appending a second one — and, because the update is
+ * empty, the first observation's timestamps survive redelivery untouched.
+ */
+export async function recordLifecycleEvent(
+  client: LifecycleEventClient,
+  write: LifecycleEventWrite,
+): Promise<void> {
+  const now = new Date();
+  const occurredAt = write.occurredAt ?? now;
+  const observedAt = write.observedAt ?? now;
+  const data: Record<string, unknown> = {
+    issueId: write.issueId,
+    repoFullName: write.repoFullName,
+    issueNumber: write.issueNumber,
+    kind: write.kind,
+    source: write.source,
+    actor: write.actor,
+    agentName: write.agentName ?? null,
+    fromStatus: write.fromStatus ?? null,
+    toStatus: write.toStatus ?? null,
+    sourceEventId: write.sourceEventId ?? null,
+    occurredAt,
+    observedAt,
+    metadata: write.metadata ?? undefined,
+  };
+
+  if (write.dedupeKey) {
+    await client.issueLifecycleEvent.upsert({
+      where: { dedupeKey: write.dedupeKey },
+      create: { ...data, dedupeKey: write.dedupeKey },
+      update: {},
+    });
+    return;
+  }
+
+  await client.issueLifecycleEvent.create({ data });
+}
+
+export interface LifecycleStatusTransitionInput {
+  issueId: string;
+  repoFullName: string;
+  issueNumber: number;
+  kind: LifecycleEventKind;
+  source: LifecycleSource;
+  actor: string;
+  agentName?: string | null;
+  /** Label set before the write. */
+  before: readonly string[];
+  /** Label set after the write — the same set the writer mirrored locally. */
+  after: readonly string[];
+  sourceEventId?: string | null;
+  dedupeKey?: string | null;
+  occurredAt?: Date;
+  observedAt?: Date;
+  metadata?: Record<string, unknown> | null;
+}
+
+/**
+ * Persist the status transition implied by a label-set change, or nothing when
+ * the status label did not move. Callers pass the exact before/after label
+ * sets they wrote, so the guard reflects the write that actually happened
+ * rather than a re-read that may have moved underneath them.
+ */
+export async function recordStatusTransition(
+  client: LifecycleEventClient,
+  input: LifecycleStatusTransitionInput,
+): Promise<boolean> {
+  const transition = lifecycleStatusTransition(input.before, input.after);
+  if (!transition) return false;
+
+  await recordLifecycleEvent(client, {
+    issueId: input.issueId,
+    repoFullName: input.repoFullName,
+    issueNumber: input.issueNumber,
+    kind: input.kind,
+    source: input.source,
+    actor: input.actor,
+    agentName: input.agentName ?? null,
+    fromStatus: transition.from,
+    toStatus: transition.to,
+    sourceEventId: input.sourceEventId ?? null,
+    dedupeKey: input.dedupeKey ?? null,
+    occurredAt: input.occurredAt,
+    observedAt: input.observedAt,
+    metadata: input.metadata ?? null,
+  });
+  return true;
+}
+
+/**
+ * Record a claim.
+ *
+ * A claim is a status transition *or* an ownership change, and the second case
+ * is real: a force-claim that takes an in-progress issue from one agent to
+ * another never moves the status label, yet it is a new attempt. Recording
+ * only status moves would drop those, and recording on every call would
+ * duplicate a redelivered claim of an already-claimed issue — so this fires
+ * exactly when the status label moved or the assigned `agent/*` label changed.
+ */
+export async function recordClaimEvent(
+  client: LifecycleEventClient,
+  input: LifecycleStatusTransitionInput,
+): Promise<boolean> {
+  const transition = lifecycleStatusTransition(input.before, input.after);
+  const claimedFrom = getAgentFromLabels([...input.before]);
+  const claimedTo = getAgentFromLabels([...input.after]);
+  if (!transition && claimedFrom === claimedTo) return false;
+
+  await recordLifecycleEvent(client, {
+    issueId: input.issueId,
+    repoFullName: input.repoFullName,
+    issueNumber: input.issueNumber,
+    kind: "claim",
+    source: input.source,
+    actor: input.actor,
+    agentName: input.agentName ?? null,
+    fromStatus: lifecycleStatusLabel(input.before),
+    toStatus: lifecycleStatusLabel(input.after),
+    sourceEventId: input.sourceEventId ?? null,
+    dedupeKey: input.dedupeKey ?? null,
+    occurredAt: input.occurredAt,
+    observedAt: input.observedAt,
+    metadata: {
+      ...input.metadata,
+      ...(transition
+        ? null
+        : { claimedFrom, claimedTo, note: "ownership changed without a status transition" }),
+    },
+  });
+  return true;
+}
+
+/**
+ * Record every lifecycle event one sync-visible change implies.
+ *
+ * Sync mirrors GitHub's state, so it is the last writer to learn about a move
+ * made anywhere: on GitHub by a human, by a webhook, or by an agent whose
+ * request already left its own event behind. All three are folded into the
+ * same shape here:
+ *
+ * - `occurredAt` is the source's own timestamp (the issue's `updated_at`, or
+ *   `closed_at` for a close) — never `now`. The observation time stays in
+ *   `observedAt`, so a sync that runs an hour late is visibly late instead of
+ *   rewriting when the work happened.
+ * - `dedupeKey` is built from that same source timestamp plus the transition
+ *   itself, so re-running the sync over unchanged GitHub state upserts the
+ *   rows that already exist instead of adding a second copy. A genuine second
+ *   move has a different `updated_at` and therefore a different key.
+ * - Nothing here writes back to `Issue`. The events are evidence, so a late or
+ *   out-of-order sync can be recorded without ever moving the present status.
+ */
+export async function recordSyncedIssueEvents(
+  client: LifecycleEventClient,
+  input: {
+    issueId: string;
+    repoFullName: string;
+    issueNumber: number;
+    before: { labels: readonly string[]; state: string | null };
+    after: { labels: readonly string[]; state: string; updatedAt?: Date | null; closedAt?: Date | null };
+    actor?: string;
+  },
+): Promise<void> {
+  const actor = input.actor ?? "github";
+  const identity = lifecycleDedupeKey(input.repoFullName, input.issueNumber);
+  const observedAt = new Date();
+  const transition = lifecycleStatusTransition(input.before.labels, input.after.labels);
+  const occurredAt = input.after.updatedAt ?? undefined;
+
+  const writes: LifecycleEventWrite[] = [];
+
+  if (transition) {
+    writes.push({
+      issueId: input.issueId,
+      repoFullName: input.repoFullName,
+      issueNumber: input.issueNumber,
+      kind: "status_changed",
+      source: "sync",
+      actor,
+      fromStatus: transition.from,
+      toStatus: transition.to,
+      dedupeKey: lifecycleDedupeKey(
+        "sync",
+        identity,
+        "status_changed",
+        transition.from,
+        transition.to,
+        occurredAt?.toISOString(),
+      ),
+      occurredAt,
+      observedAt,
+      metadata: { observedVia: "issue sync", occurredAtSource: occurredAt ? "issue.updated_at" : null },
+    });
+  }
+
+  // A close and a reopen are distinct from the status label moving to
+  // status/done: the label says where the card sits, the state says whether
+  // GitHub considers the work finished. Both are recorded so a reader can
+  // tell an abandoned card from a finished one.
+  if (input.before.state !== "closed" && input.after.state === "closed") {
+    writes.push({
+      issueId: input.issueId,
+      repoFullName: input.repoFullName,
+      issueNumber: input.issueNumber,
+      kind: "issue_closed",
+      source: "sync",
+      actor,
+      toStatus: lifecycleStatusLabel(input.after.labels),
+      dedupeKey: lifecycleDedupeKey(
+        "sync",
+        identity,
+        "issue_closed",
+        input.after.closedAt?.toISOString() ?? occurredAt?.toISOString(),
+      ),
+      occurredAt: input.after.closedAt ?? occurredAt,
+      observedAt,
+      metadata: { observedVia: "issue sync" },
+    });
+  }
+
+  if (input.before.state === "closed" && input.after.state !== "closed") {
+    writes.push({
+      issueId: input.issueId,
+      repoFullName: input.repoFullName,
+      issueNumber: input.issueNumber,
+      kind: "issue_reopened",
+      source: "sync",
+      actor,
+      fromStatus: lifecycleStatusLabel(input.before.labels),
+      toStatus: lifecycleStatusLabel(input.after.labels),
+      dedupeKey: lifecycleDedupeKey("sync", identity, "issue_reopened", occurredAt?.toISOString()),
+      occurredAt,
+      observedAt,
+      metadata: { observedVia: "issue sync" },
+    });
+  }
+
+  for (const write of writes) {
+    await recordLifecycleEventQuietly(client, write, "issue sync");
+  }
+}
+
+/**
+ * Record an event without letting a lifecycle failure abort the writer.
+ *
+ * For the observed sources — sync, webhook, reconcile — the job is the local
+ * mirror, not the event: those paths are periodic and retried, so a failed
+ * event must cost a log line rather than the whole run. Dispatch-authored
+ * writes share a transaction with the state they describe and deliberately
+ * fail together instead (see the route callers).
+ */
+export async function recordLifecycleEventQuietly(
+  client: LifecycleEventClient,
+  write: LifecycleEventWrite,
+  context: string,
+): Promise<void> {
+  try {
+    await recordLifecycleEvent(client, write);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `lifecycle event ${write.kind} for ${write.repoFullName}#${write.issueNumber} was not recorded (${context}): ${message}`,
+    );
+  }
+}
\ No newline at end of file
diff --git a/src/lib/issue-sync.test.ts b/src/lib/issue-sync.test.ts
index e0da5166..25f6bba9 100644
--- a/src/lib/issue-sync.test.ts
+++ b/src/lib/issue-sync.test.ts
@@ -5,6 +5,11 @@ const { mocks } = vi.hoisted(() => ({
   mocks: {
     fetchIssues: vi.fn(),
     issueAggregate: vi.fn(),
+    issueFindUnique: vi.fn(),
+    issueUpdate: vi.fn(),
+    issueCreate: vi.fn(),
+    createLifecycleEvent: vi.fn(),
+    upsertLifecycleEvent: vi.fn(),
   },
 }));
 
@@ -16,17 +21,26 @@ vi.mock("@/lib/prisma", () => ({
   prisma: {
     issue: {
       aggregate: mocks.issueAggregate,
+      findUnique: mocks.issueFindUnique,
+      update: mocks.issueUpdate,
+      create: mocks.issueCreate,
+    },
+    issueLifecycleEvent: {
+      create: mocks.createLifecycleEvent,
+      upsert: mocks.upsertLifecycleEvent,
     },
   },
 }));
 
 import {
   IssueStore,
+  type SyncedIssueData,
   syncIssuesForRepos,
   mergeLabels,
   reconcileClosedIssues,
   closedIssueStatusFix,
   fetchAllStateIssues,
+  makePrismaIssueStore,
   defaultCurrentLane,
   currentLaneForLabels,
   SYNC_OVERLAP_BUFFER_MS,
@@ -204,7 +218,13 @@ describe("syncIssuesForRepos", () => {
     );
 
     expect(findMock).toHaveBeenCalledTimes(2);
-    expect(updateMock).toHaveBeenCalledWith("existing-1", expect.objectContaining({ number: 1 }));
+    expect(updateMock).toHaveBeenCalledWith(
+      "existing-1",
+      expect.objectContaining({ number: 1 }),
+      // The cached state is handed to the store alongside the write so it can
+      // record what the sync changed (#1202).
+      expect.objectContaining({ labels: [] }),
+    );
     expect(createMock).toHaveBeenCalledWith("repo-1", expect.objectContaining({ number: 2 }));
   });
 
@@ -225,6 +245,9 @@ describe("syncIssuesForRepos", () => {
     expect(store.updateIssue).toHaveBeenCalledWith(
       "existing-1",
       expect.objectContaining({ labels: ["type/bug", "agent/saffron"] }),
+      expect.objectContaining({
+        labels: ["agent/saffron", "status/in-progress"],
+      }),
     );
   });
 
@@ -600,3 +623,109 @@ describe("currentLaneForLabels (dispatch#988)", () => {
     expect(currentLaneForLabels(["needs-escalation"])).toBe("work");
   });
 });
+
+describe("makePrismaIssueStore — lifecycle evidence (#1202)", () => {
+  const updatedAt = new Date("2026-10-02T08:00:00.000Z");
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.issueUpdate.mockResolvedValue({ id: "issue-1" });
+    mocks.issueCreate.mockResolvedValue({ id: "issue-1" });
+    mocks.issueFindUnique.mockResolvedValue({
+      id: "issue-1",
+      labels: ["status/ready"],
+      state: "open",
+      repository: { fullName: "org/repo" },
+    });
+    mocks.createLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+    mocks.upsertLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+  });
+
+  function syncData(overrides: Partial<SyncedIssueData> = {}): SyncedIssueData {
+    return {
+      number: 42,
+      title: "Issue 42",
+      body: null,
+      url: "https://github.com/org/repo/issues/42",
+      labels: ["status/in-review"],
+      assignees: [],
+      commentsCount: 0,
+      createdAt: new Date("2026-01-01T00:00:00.000Z"),
+      updatedAt,
+      closedAt: null,
+      lastSyncedAt: updatedAt,
+      state: "open",
+      ...overrides,
+    };
+  }
+
+  it("records the status move the sync mirrored, with GitHub's timestamp as the occurrence time", async () => {
+    const store = makePrismaIssueStore();
+    await store.findIssue("repo-1", 42);
+    await store.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" });
+
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledWith({
+      where: { dedupeKey: "sync|org/repo|42|status_changed|status/ready|status/in-review|2026-10-02T08:00:00.000Z" },
+      create: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "sync",
+        fromStatus: "status/ready",
+        toStatus: "status/in-review",
+        occurredAt: updatedAt,
+      }),
+      update: {},
+    });
+  });
+
+  it("records a close GitHub reported, separately from the status label moving to done", async () => {
+    const store = makePrismaIssueStore();
+    await store.findIssue("repo-1", 42);
+    await store.updateIssue(
+      "issue-1",
+      syncData({ labels: ["status/done"], state: "closed", closedAt: updatedAt }),
+      { labels: ["status/in-progress"], state: "open" },
+    );
+
+    const kinds = mocks.upsertLifecycleEvent.mock.calls.map((call: any[]) => call[0].create.kind);
+    expect(kinds).toEqual(["status_changed", "issue_closed"]);
+  });
+
+  it("records nothing when the synced issue did not change", async () => {
+    const store = makePrismaIssueStore();
+    await store.findIssue("repo-1", 42);
+    await store.updateIssue("issue-1", syncData({ labels: ["status/ready"] }), { labels: ["status/ready"], state: "open" });
+
+    expect(mocks.issueUpdate).toHaveBeenCalled();
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+    expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
+  });
+
+  it("collapses a repeated sync over the same GitHub state onto one row", async () => {
+    const store = makePrismaIssueStore();
+    await store.findIssue("repo-1", 42);
+    await store.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" });
+    await store.findIssue("repo-1", 42);
+    await store.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" });
+
+    const keys = mocks.upsertLifecycleEvent.mock.calls.map((call: any[]) => call[0].where.dedupeKey);
+    expect(keys).toHaveLength(2);
+    expect(new Set(keys).size).toBe(1);
+  });
+
+  it("keeps a failed event write from failing the sync it observed", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mocks.upsertLifecycleEvent.mockRejectedValue(new Error("db down"));
+    const store = makePrismaIssueStore();
+
+    await store.findIssue("repo-1", 42);
+    await expect(
+      store.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" }),
+    ).resolves.toBeUndefined();
+
+    expect(mocks.issueUpdate).toHaveBeenCalled();
+    expect(warn).toHaveBeenCalled();
+  });
+});
diff --git a/src/lib/issue-sync.ts b/src/lib/issue-sync.ts
index 25ceb015..44e298f9 100644
--- a/src/lib/issue-sync.ts
+++ b/src/lib/issue-sync.ts
@@ -4,6 +4,7 @@ import { isEscalationLabel } from "@/lib/issue-lane";
 import { prisma } from "@/lib/prisma";
 import { fetchIssues } from "@/lib/github";
 import { getDefaultClaimableLane, getEscalationLane } from "@/lib/lane-config";
+import { recordSyncedIssueEvents } from "@/lib/issue-lifecycle";
 
 export interface SyncRepo {
   id: string;
@@ -58,9 +59,22 @@ export interface SyncedIssueData {
   nativeBlockedBy?: string[];
 }
 
+/**
+ * The cached state a sync write is replacing. Passed alongside the write so a
+ * store can record what the sync changed without re-reading the row it just
+ * overwrote.
+ */
+export interface IssueSyncSnapshot {
+  labels: string[];
+  state?: string | null;
+}
+
 export interface IssueStore {
-  findIssue(repositoryId: string, number: number): Promise<{ id: string; labels: string[] } | null>;
-  updateIssue(id: string, data: SyncedIssueData): Promise<void>;
+  findIssue(
+    repositoryId: string,
+    number: number,
+  ): Promise<{ id: string; labels: string[]; state?: string } | null>;
+  updateIssue(id: string, data: SyncedIssueData, previous?: IssueSyncSnapshot | null): Promise<void>;
   createIssue(repositoryId: string, data: SyncedIssueData): Promise<void>;
 }
 
@@ -193,7 +207,10 @@ export async function syncIssuesForRepos(
           if (existingIssue.labels.length > 0) {
             issueData.labels = mergeLabels(issueData.labels, existingIssue.labels);
           }
-          await store.updateIssue(existingIssue.id, issueData);
+          await store.updateIssue(existingIssue.id, issueData, {
+            labels: existingIssue.labels,
+            state: existingIssue.state ?? null,
+          });
         } else {
           await store.createIssue(repo.id, issueData);
         }
@@ -241,7 +258,11 @@ export async function reconcileClosedIssues(
   fetchIssueFn: (repoFullName: string, issueNumber: number) => Promise<GitHubIssue>,
   store: {
     findActiveCachedIssues(repositoryId: string): Promise<Array<{ id: string; number: number; labels: string[]; state: string }>>;
-    updateIssue(id: string, data: { labels: string[]; state: string; closedAt: Date | null }): Promise<void>;
+    updateIssue(
+      id: string,
+      data: { labels: string[]; state: string; closedAt: Date | null },
+      previous?: IssueSyncSnapshot | null,
+    ): Promise<void>;
   },
 ): Promise<ClosedIssueReconcileResponse> {
   const results: ReconcileClosedIssueResult[] = [];
@@ -267,11 +288,15 @@ export async function reconcileClosedIssues(
           if (ghIssue.state === "closed") {
             // Case 1: Issue has status/done but stale open state — just fix the state
             if (hasDoneLabelButOpenState) {
-              await store.updateIssue(cached.id, {
-                labels: cached.labels,
-                state: "closed",
-                closedAt: ghIssue.closed_at ? new Date(ghIssue.closed_at) : new Date(),
-              });
+              await store.updateIssue(
+                cached.id,
+                {
+                  labels: cached.labels,
+                  state: "closed",
+                  closedAt: ghIssue.closed_at ? new Date(ghIssue.closed_at) : new Date(),
+                },
+                { labels: cached.labels, state: cached.state },
+              );
 
               repoReconciled++;
               results.push({
@@ -287,11 +312,15 @@ export async function reconcileClosedIssues(
                 .filter((l) => !RECONCILABLE_STATUS_LABELS.includes(l as typeof RECONCILABLE_STATUS_LABELS[number]))
                 .concat(["status/done"]);
 
-              await store.updateIssue(cached.id, {
-                labels: newLabels,
-                state: "closed",
-                closedAt: ghIssue.closed_at ? new Date(ghIssue.closed_at) : new Date(),
-              });
+              await store.updateIssue(
+                cached.id,
+                {
+                  labels: newLabels,
+                  state: "closed",
+                  closedAt: ghIssue.closed_at ? new Date(ghIssue.closed_at) : new Date(),
+                },
+                { labels: cached.labels, state: cached.state },
+              );
 
               repoReconciled++;
               results.push({
@@ -428,18 +457,47 @@ export const fetchAllStateIssues = async (repo: SyncRepo): Promise<GitHubIssue[]
 /**
  * Prisma-backed IssueStore for syncIssuesForRepos. findIssue returns the
  * cached labels so the sync core can merge agent/* labels without a second
- * lookup per issue.
+ * lookup per issue, and the cached state so the store can record what the sync
+ * changed once it lands (#1202).
  */
 export function makePrismaIssueStore(): IssueStore {
+  // The repo full name an issue belongs to, taken from the same findIssue the
+  // core always calls immediately before updateIssue. Holding it here costs
+  // no extra query per synced issue; the entry is consumed (and dropped) by the
+  // update, so the map never holds more than the issue being synced.
+  const repoByIssueId = new Map<string, string>();
+
   return {
     findIssue(repositoryId: string, number: number) {
       return prisma.issue.findUnique({
         where: { repositoryId_number: { repositoryId, number } },
-        select: { id: true, labels: true },
+        select: { id: true, labels: true, state: true, repository: { select: { fullName: true } } },
+      }).then((issue) => {
+        if (issue) repoByIssueId.set(issue.id, issue.repository.fullName);
+        return issue;
       });
     },
-    async updateIssue(id: string, data: SyncedIssueData) {
+    async updateIssue(id: string, data: SyncedIssueData, previous?: IssueSyncSnapshot | null) {
       await prisma.issue.update({ where: { id }, data });
+
+      const repoFullName = repoByIssueId.get(id);
+      repoByIssueId.delete(id);
+      // The write landed even if the lookup above never ran, so a missing repo
+      // name costs the event, not the sync.
+      if (!repoFullName || !previous) return;
+
+      await recordSyncedIssueEvents(prisma, {
+        issueId: id,
+        repoFullName,
+        issueNumber: data.number,
+        before: { labels: previous.labels, state: previous.state ?? null },
+        after: {
+          labels: data.labels,
+          state: data.state,
+          updatedAt: data.updatedAt,
+          closedAt: data.closedAt,
+        },
+      });
     },
     async createIssue(repositoryId: string, data: SyncedIssueData) {
       // Stamp the configured default claimable lane so a freshly-ingested,
@@ -490,6 +548,42 @@ export function findActiveCachedIssuesForReconcile(
   });
 }
 
+/**
+ * Prisma-backed store for reconcileClosedIssues (closed-issue reconciliation),
+ * shared by the scheduled sync route and the heartbeat orchestrator so both
+ * record the same lifecycle evidence for the same writes.
+ */
+export function makePrismaReconcileIssueStore(): {
+  findActiveCachedIssues: typeof findActiveCachedIssuesForReconcile;
+  updateIssue(
+    id: string,
+    data: { labels: string[]; state: string; closedAt: Date | null },
+    previous?: IssueSyncSnapshot | null,
+  ): Promise<void>;
+} {
+  return {
+    findActiveCachedIssues: findActiveCachedIssuesForReconcile,
+    async updateIssue(id, data, previous) {
+      await prisma.issue.update({ where: { id }, data });
+      if (!previous) return;
+
+      const repo = await prisma.issue.findUnique({
+        where: { id },
+        select: { number: true, repository: { select: { fullName: true } } },
+      });
+      if (!repo) return;
+
+      await recordSyncedIssueEvents(prisma, {
+        issueId: id,
+        repoFullName: repo.repository.fullName,
+        issueNumber: repo.number,
+        before: { labels: previous.labels, state: previous.state ?? null },
+        after: { labels: data.labels, state: data.state, closedAt: data.closedAt },
+      });
+    },
+  };
+}
+
 export async function refreshSingleIssue(
   repoFullName: string,
   issueNumber: number,
diff --git a/src/lib/report-close.test.ts b/src/lib/report-close.test.ts
index a4a8ebcc..f897e00e 100644
--- a/src/lib/report-close.test.ts
+++ b/src/lib/report-close.test.ts
@@ -901,3 +901,79 @@ describe("already_done never touches the PR-fix queue (#1143)", () => {
     });
   });
 });
+
+describe("applyReportClose — lifecycle evidence (#1202)", () => {
+  function lifecycleClient() {
+    const createEvent = vi.fn(async () => ({}));
+    const upsertEvent = vi.fn(async () => ({}));
+    return {
+      createEvent,
+      upsertEvent,
+      client: { ...client(), issueLifecycleEvent: { create: createEvent, upsert: upsertEvent } },
+    };
+  }
+
+  /** Swaps every status label like the real transitionIssueStatus does. */
+  function swapToDone() {
+    return deps({
+      transitionStatus: vi.fn(async (_repo: string, _number: number, labels: string[]) => [
+        ...labels.filter((label) => !label.startsWith("status/")),
+        "status/done",
+      ]),
+    });
+  }
+
+  it("records the completion with the status the close left behind", async () => {
+    const d = swapToDone();
+    const { client: c, createEvent } = lifecycleClient();
+    const evaluation = await evaluateReportClose(
+      { repoFullName: "org/repo", issueNumber: 42, criteria: [criterion()] },
+      d,
+    );
+
+    await applyReportClose({ evaluation, actor: "alpha", issueId: "issue-42", client: c, deps: d });
+
+    expect(createEvent).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        issueId: "issue-42",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        // A completion is its own fact, not the status label moving to done.
+        kind: "completed",
+        source: "agent-report",
+        actor: "alpha",
+        fromStatus: "status/backlog",
+        toStatus: "status/done",
+        metadata: { evidenceDigest: evaluation.evidenceDigest, headSha: HEAD },
+      }),
+    });
+  });
+
+  it("records nothing when the close could not resolve to a cached issue", async () => {
+    const d = deps();
+    const { client: c, createEvent } = lifecycleClient();
+    const evaluation = await evaluateReportClose(
+      { repoFullName: "org/repo", issueNumber: 42, criteria: [criterion()] },
+      d,
+    );
+
+    await applyReportClose({ evaluation, actor: "alpha", issueId: null, client: c, deps: d });
+
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("reports a failed evidence write as a warning without undoing the close", async () => {
+    const d = deps();
+    const { client: c, createEvent } = lifecycleClient();
+    createEvent.mockRejectedValueOnce(new Error("db down"));
+    const evaluation = await evaluateReportClose(
+      { repoFullName: "org/repo", issueNumber: 42, criteria: [criterion()] },
+      d,
+    );
+
+    const applied = await applyReportClose({ evaluation, actor: "alpha", issueId: "issue-42", client: c, deps: d });
+
+    expect(applied.closed).toBe(true);
+    expect(applied.warning).toContain("lifecycle event write failed");
+  });
+});
diff --git a/src/lib/report-close.ts b/src/lib/report-close.ts
index f1beb309..6a43643d 100644
--- a/src/lib/report-close.ts
+++ b/src/lib/report-close.ts
@@ -31,6 +31,11 @@ import {
   fetchRepositoryMetadata,
 } from "@/lib/github-code-search";
 import { transitionIssueStatus } from "@/lib/issue-status";
+import {
+  lifecycleStatusLabel,
+  recordLifecycleEvent,
+  type LifecycleEventClient,
+} from "@/lib/issue-lifecycle";
 import { buildEvidenceCatalog, repositoryEvidenceId } from "@/lib/groomer/plan-evidence";
 import {
   collectPinnedReadContent,
@@ -508,6 +513,8 @@ export interface ReportCloseClient {
   auditLog: {
     create(args: { data: Record<string, unknown> }): Promise<unknown>;
   };
+  /** Optional: when present, the close also records its lifecycle evidence (#1202). */
+  issueLifecycleEvent?: LifecycleEventClient["issueLifecycleEvent"];
 }
 
 export interface ApplyReportCloseInput {
@@ -601,6 +608,33 @@ export async function applyReportClose(input: ApplyReportCloseInput): Promise<Ap
     addWarning(`the audit log write failed: ${errorMessage(err)}`);
   }
 
+  // The completion itself, as a lifecycle event (#1202). Deliberately its own
+  // kind and separate from the status/done move above: "a worker reported this
+  // done and Dispatch closed it" is a different fact from "the card says done",
+  // and neither is evidence that a PR merged — only a merge observation is.
+  if (input.issueId && input.client.issueLifecycleEvent) {
+    try {
+      await recordLifecycleEvent(
+        { issueLifecycleEvent: input.client.issueLifecycleEvent },
+        {
+          issueId: input.issueId,
+          repoFullName: evaluation.repoFullName,
+          issueNumber: evaluation.issueNumber,
+          kind: "completed",
+          source: "agent-report",
+          actor: input.actor,
+          fromStatus: lifecycleStatusLabel(evaluation.liveLabels),
+          toStatus: lifecycleStatusLabel(labelsAfter),
+          occurredAt: now(),
+          observedAt: now(),
+          metadata: { evidenceDigest: evaluation.evidenceDigest, headSha: evaluation.headSha },
+        },
+      );
+    } catch (err) {
+      addWarning(`the lifecycle event write failed: ${errorMessage(err)}`);
+    }
+  }
+
   return { closed: true, labelsAfter, ...(warning ? { warning } : {}) };
 }
 
diff --git a/src/lib/stale-work.ts b/src/lib/stale-work.ts
index 80655f6f..c1838377 100644
--- a/src/lib/stale-work.ts
+++ b/src/lib/stale-work.ts
@@ -143,13 +143,22 @@ export async function sweepStaleWork(
       }
 
       if (work.issue) {
+        // The release is attributed to the sweep, not to the abandoned agent:
+        // nobody chose to let this claim go, and a claim-to-merge read must be
+        // able to tell a recovered stall apart from a worker's own unclaim
+        // (#1202).
         await releaseIssueClaim({
           prisma: client,
           issue: work.issue,
           repoFullName: work.issue.repository.fullName,
           issueNumber: work.issue.number,
           agentName: work.agentName,
-          options: { allowMissingAgent: true, preserveStatus: true },
+          options: {
+            allowMissingAgent: true,
+            preserveStatus: true,
+            source: "stale-recovery",
+            actor: "system",
+          },
         });
       }
 

From c20a4303b1f64e4a15f5d0e2e906c0caa55afc42 Mon Sep 17 00:00:00 2001
From: Courier <courier@localhost>
Date: Wed, 14 Oct 2026 06:05:44 +0000
Subject: [PATCH 2/2] fix(lifecycle): close the six evidence gaps found in
 review (#1202)

Review found four writer families that could record a non-transition or lose
an event, and the two-request durability hole each of them shares.

Sync recorded its evidence after committing the cache mirror, inside a quiet
wrapper: a failed insert left the cache already updated, so the next sync
derived no transition and the row could never be reconstructed. Both sync
stores now record first, and recordSyncedIssueEvents propagates instead of
swallowing - a failure defers that issue's mirror to the next run, which
re-derives the same transition from the unchanged row and upserts onto the
same source-derived dedupe key.

Claim and set-status mutate GitHub before opening the transaction that
mirrors the cache and records the event, so a failed insert rolled back only
the local side and the retry read the already-applied live labels as
"nothing changed", dropping the attempt for good. Both routes now pass their
cached label set as mirroredBefore: the recorder prefers the observed set
whenever it shows the change and falls back to the mirror when it does not,
marking the row recoveredFromMirroredState. A redelivered claim of an
already-committed issue still records nothing, and the decision logic stays
on the live labels.

The hosted groomer wrote status_changed unconditionally, so a noop or partial
plan that moved no status/* label persisted a row with identical from/to; it
now goes through the shared transition guard, via a quiet wrapper that keeps
the guarantee that a landed run never fails over its evidence row. The same
groomer close is a separate fact the next sync can never observe, because the
close is mirrored in the same run - so a confirmed groomer close now records
its own idempotent issue_closed under the application key.

The webhook's unlabeled branch called filter(), which always returns a new
array, so its reference check passed even for an absent label and recorded a
phantom status change that could repeat without a delivery id. The label-set
update now returns the same reference when membership does not change, which
makes the existing gate exact.

Stale recovery released the real claim with an unkeyed event, so a crash
between that commit and the AgentWork finalization made the retry take the
already-released repair branch and write a second, differently-keyed
claim_released. The sweep now supplies the AgentWork row - one claim epoch,
stable across a retry of the same sweep - as a releaseKey shared by both
paths, so the release and its repair are one row while a reclaim-and-release
gets a new epoch and a new row.

Co-authored-by: Courier <courier@localhost>
---
 docs/issue-lifecycle-events.md           |  62 ++++++--
 src/app/api/issues/claim/route.test.ts   |  39 ++++-
 src/app/api/issues/claim/route.ts        |   7 +
 src/app/api/issues/status/route.test.ts  |  29 ++++
 src/app/api/issues/status/route.ts       |   9 +-
 src/app/api/issues/webhook/route.test.ts |  57 +++++++
 src/app/api/issues/webhook/route.ts      |   8 +-
 src/lib/groomer/run.test.ts              | 109 ++++++++++++-
 src/lib/groomer/run.ts                   |  57 +++++--
 src/lib/issue-claim.test.ts              |  87 +++++++++++
 src/lib/issue-claim.ts                   |  21 ++-
 src/lib/issue-lifecycle.test.ts          | 153 ++++++++++++++++++-
 src/lib/issue-lifecycle.ts               | 114 +++++++++++---
 src/lib/issue-sync.test.ts               | 115 ++++++++++++--
 src/lib/issue-sync.ts                    |  80 ++++++----
 src/lib/stale-work.test.ts               | 186 +++++++++++++++++++++++
 src/lib/stale-work.ts                    |   8 +
 17 files changed, 1049 insertions(+), 92 deletions(-)
 create mode 100644 src/lib/stale-work.test.ts

diff --git a/docs/issue-lifecycle-events.md b/docs/issue-lifecycle-events.md
index e36edbf2..75e8a00a 100644
--- a/docs/issue-lifecycle-events.md
+++ b/docs/issue-lifecycle-events.md
@@ -28,7 +28,7 @@ attempt telemetry/cohorts.
 | `attempt_failed` | A worker reported a `failed` or `blocked` outcome. Recorded once per report; an idempotent duplicate replays the original run and adds nothing. | `agent-report` |
 | `status_changed` | The `status/*` label moved. `fromStatus`/`toStatus` carry the values. | `api:move`, `api:status`, `api:groom`, `hosted-groomer`, `reconciler`, `sync`, `webhook` |
 | `completed` | A worker report closed the item as already done (`status/done` + GitHub close). Not evidence that a PR merged. | `agent-report` |
-| `issue_closed` | The GitHub issue was observed closing. Distinct from the card reaching Done. | `reconciler`, `sync` |
+| `issue_closed` | The GitHub issue was observed closing — or closed by the hosted groomer. Distinct from the card reaching Done. | `reconciler`, `sync`, `hosted-groomer` |
 | `issue_reopened` | The issue was observed reopening after a close. | `sync` |
 | `pr_merged` | A PR referencing the item was observed merged. Only ever recorded from an observation of a merge — never from a worker's success report. | `reconciler` |
 
@@ -60,7 +60,7 @@ added without a migration; `LIFECYCLE_EVENT_KINDS` and `LIFECYCLE_SOURCES` in
 | Board drag-and-drop | `src/app/api/issues/move/route.ts` | `status_changed` |
 | Manual / agent status set | `src/app/api/issues/status/route.ts` | `status_changed` |
 | Operator grooming decision | `src/app/api/issues/groom/route.ts` | `status_changed` |
-| Hosted groomer plan application | `src/lib/groomer/run.ts` | `status_changed` |
+| Hosted groomer plan application | `src/lib/groomer/run.ts` | `status_changed` (only the moves the plan actually made), `issue_closed` (when the plan closed the issue) |
 | Reconciler | `src/app/api/issues/reconcile/route.ts` | `status_changed`, `pr_merged`, `issue_closed` |
 | Issue sync | `src/lib/issue-sync.ts` (`makePrismaIssueStore`, `makePrismaReconcileIssueStore`) | `status_changed`, `issue_closed`, `issue_reopened` |
 | GitHub webhook | `src/app/api/issues/webhook/route.ts` | `status_changed` |
@@ -76,7 +76,12 @@ changed — or, for a claim, when the assigned agent changed. A redelivered clai
 of an already-claimed issue, a drag that lands back in the same column and a
 set-status to the current status therefore record nothing, while a genuine
 release → reclaim pair records both attempts and leaves the first claim intact.
-These events carry no `dedupeKey`; the guard is what makes them single.
+These events carry no `dedupeKey`; the guard is what makes them single. The one
+keyed case is the stale sweep's ownership-only release: the sweep knows the
+AgentWork row it is releasing, which is one claim epoch, so it supplies that as
+the release's identity and a retry of the same sweep — which finds the agent
+label already gone and repairs the cache — lands on the same `claim_released`
+row instead of recording the release twice.
 
 **Source identity.** For an externally observed event the source usually has
 its own identity, which becomes a unique `dedupeKey` and the write is an
@@ -88,7 +93,34 @@ exists without rewriting its timestamps:
 - reconciler — `reconciler|<repo>|<n>|<kind>|<pr number>|<merged_at>`
 
 A second, genuine transition always carries a different source timestamp (or
-a different PR), so it gets a different key and is appended normally.
+a different PR), so it gets a different key and is appended normally. A
+hosted-groomer close is keyed by its application
+(`hosted-groomer|<repo>|<n>|issue_closed|<application key>`) for the same
+reason: a retry of the same plan collapses onto one row.
+
+**Recovering a Dispatch-authored write whose GitHub mutation already landed.**
+Claim and set-status write GitHub labels first and mirror them into the cache
+inside the transaction that also records the event. If that transaction fails,
+GitHub already carries the claim while the cache still holds the pre-write set,
+so a retry observes labels that show no change — and the guard would record
+nothing, losing the first attempt's evidence for good. Both routes therefore
+pass their cached label set as `mirroredBefore`: the recorder prefers the
+observed set whenever it shows the change and falls back to the mirror when it
+does not, marking such a row `recoveredFromMirroredState`. The fallback is
+consulted only when the observed set shows nothing, so a redelivered claim of an
+already-claimed-and-committed issue still records nothing. The claim decision
+itself always reads the live GitHub labels.
+
+Known limitation of that fallback: the mirrored row is a witness of the
+pre-write state only when the cache was in step with GitHub. If sync lag left it
+behind, a retry can recover a row whose `fromStatus` describes the last mirrored
+state rather than the state this claim actually displaced — the two are
+indistinguishable at retry time, and telling them apart would need an intent
+record written durably *before* the GitHub mutation. Every such row carries
+`recoveredFromMirroredState`, so a reader can separate a recovered row from an
+observed move; no status change is lost either way, because sync independently
+records the real GitHub-side move — only its attribution to this writer is
+approximate.
 
 Known limitation: Dispatch's own label writes also generate GitHub webhook
 deliveries. A delivery that is processed before the originating request has
@@ -113,10 +145,22 @@ backdated row.
   describe (claim, move, status, groom, unclaim release). A failed event write
   fails the write rather than leaving a claim with no evidence row; the route
   returns its existing error shape.
-- **Observed writes** (sync, webhook, reconciler, worker report, hosted
-  groomer) are best-effort and log a warning. Those paths are periodic,
-  retried, and their job is the local mirror — an evidence-row problem must not
-  cost a whole sync run or fail a worker's report.
+- **Sync** records before it mirrors: the events are written first, so a failed
+  event write aborts that issue's cache write instead of leaving a cache that
+  shows a move the stream has no record of. Both sync cores already catch a
+  failing write — at repo level for the issue sync, per issue for closed-issue
+  reconciliation — and report it in their existing result shape; because the
+  cache row never moved, the next run re-derives the same transition from the
+  same before-state onto the same `dedupeKey`, so the deferred mirror costs one
+  row rather than a duplicate.
+- **Webhook, reconciler, worker report, hosted groomer** stay best-effort and
+  log a warning: those writers are periodic or retried, and their job is the
+  local mirror — an evidence-row problem must not cost a whole run or fail a
+  worker's report. The groomer therefore records its status move and its close
+  through the same transition guard as everyone else (a `noop` or a `partial`
+  that moved no `status/*` label records no `status_changed`) and both stay
+  quiet, because a run that already landed its mutations must not fail over an
+  evidence row.
 
 ## Migration
 
@@ -125,4 +169,4 @@ and its indexes. It is additive: no backfill, no change to `Issue`, no change
 to any API response, and no new worker requirement, token or model field. The
 stream starts empty and fills as writers run, so a first claim recorded after
 the migration has no earlier history to contradict — which is exactly why no
-reader may infer a first claim from the absence of events.
\ No newline at end of file
+reader may infer a first claim from the absence of events.
diff --git a/src/app/api/issues/claim/route.test.ts b/src/app/api/issues/claim/route.test.ts
index 5ce8b278..e51c2231 100644
--- a/src/app/api/issues/claim/route.test.ts
+++ b/src/app/api/issues/claim/route.test.ts
@@ -674,8 +674,13 @@ describe("POST /api/issues/claim — lifecycle evidence (#1202)", () => {
 
   it("records nothing for a redelivered claim of an already-claimed issue", async () => {
     // Live GitHub already shows this agent holding the issue as in-progress,
-    // which is exactly what a replayed claim request looks like.
+    // which is exactly what a replayed claim request looks like — and so does
+    // the cache, because the first attempt's mirror committed.
     mocks.getLiveIssueLabels.mockResolvedValue(["status/in-progress", "agent/test-agent"]);
+    mocks.findUnique.mockResolvedValue({
+      id: "issue-1", state: "open", number: 42, repository: { fullName: "org/repo" },
+      labels: ["status/in-progress", "agent/test-agent"],
+    });
 
     const res = await POST(makeRequest());
     expect(res.status).toBe(200);
@@ -683,6 +688,38 @@ describe("POST /api/issues/claim — lifecycle evidence (#1202)", () => {
     expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
   });
 
+  it("recovers the claim on a retry whose GitHub writes already landed", async () => {
+    // First attempt: GitHub takes the labels, the event insert fails, and the
+    // transaction rolls the mirror back. The retry then reads an
+    // already-claimed issue — only the cache row still shows the pre-claim
+    // state, and it is what makes the first attempt's evidence recoverable.
+    mocks.getLiveIssueLabels
+      .mockResolvedValueOnce(["status/ready", "type/feature"])
+      .mockResolvedValue(["type/feature", "agent/test-agent", "status/in-progress"]);
+    mocks.findUnique.mockResolvedValue({
+      id: "issue-1", state: "open", number: 42, repository: { fullName: "org/repo" },
+      labels: ["status/ready", "type/feature"],
+    });
+    mocks.createLifecycleEvent.mockRejectedValueOnce(new Error("lifecycle write failed"));
+
+    const first = await POST(makeRequest());
+    expect(first.status).toBe(500);
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledTimes(1);
+
+    const retry = await POST(makeRequest());
+    expect(retry.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledTimes(2);
+    expect(mocks.createLifecycleEvent).toHaveBeenLastCalledWith({
+      data: expect.objectContaining({
+        kind: "claim",
+        fromStatus: "status/ready",
+        toStatus: "status/in-progress",
+        metadata: { recoveredFromMirroredState: true },
+      }),
+    });
+  });
+
   it("records a force-claim that only changes ownership", async () => {
     mocks.getLiveIssueLabels.mockResolvedValue(["status/in-progress", "agent/other-agent"]);
 
diff --git a/src/app/api/issues/claim/route.ts b/src/app/api/issues/claim/route.ts
index 29c5325f..7ab78391 100644
--- a/src/app/api/issues/claim/route.ts
+++ b/src/app/api/issues/claim/route.ts
@@ -233,6 +233,13 @@ export async function POST(request: Request) {
           agentName: agentName as string,
           before: liveLabels,
           after: updatedLabels,
+          // The GitHub writes above are already outside this transaction, so a
+          // failure here rolls the mirror back while GitHub keeps the claim —
+          // and the retry reads those live labels as "already claimed". The
+          // cache row is written inside the transaction, so on the retry it
+          // still holds the pre-claim set and can supply the before-state this
+          // attempt is missing. Decision logic stays on liveLabels above.
+          mirroredBefore: issue.labels,
           metadata: force === true ? { force: true } : null,
         });
       });
diff --git a/src/app/api/issues/status/route.test.ts b/src/app/api/issues/status/route.test.ts
index 0f7415c2..a670692a 100644
--- a/src/app/api/issues/status/route.test.ts
+++ b/src/app/api/issues/status/route.test.ts
@@ -495,4 +495,33 @@ describe("POST /api/issues/status — lifecycle evidence (#1202)", () => {
     expect(res.status).toBe(503);
     expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
   });
+
+  it("recovers the transition on a retry whose GitHub write already landed", async () => {
+    // First attempt: GitHub takes status/in-progress, the event insert fails,
+    // and the transaction rolls the mirror back. The retry reads an issue that
+    // already carries the requested status — only the cache row still shows
+    // the pre-write state, and it is what makes the evidence recoverable.
+    mocks.getLiveIssueLabels
+      .mockResolvedValueOnce(["status/ready"])
+      .mockResolvedValue(["status/in-progress"]);
+    mocks.createLifecycleEvent.mockRejectedValueOnce(new Error("lifecycle write failed"));
+
+    const first = await POST(makeRequest());
+    expect(first.status).toBe(500);
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledTimes(1);
+
+    const retry = await POST(makeRequest());
+    expect(retry.status).toBe(200);
+
+    expect(mocks.createLifecycleEvent).toHaveBeenCalledTimes(2);
+    expect(mocks.createLifecycleEvent).toHaveBeenLastCalledWith({
+      data: expect.objectContaining({
+        kind: "status_changed",
+        source: "api:status",
+        fromStatus: "status/ready",
+        toStatus: "status/in-progress",
+        metadata: { recoveredFromMirroredState: true },
+      }),
+    });
+  });
 });
diff --git a/src/app/api/issues/status/route.ts b/src/app/api/issues/status/route.ts
index 8664211a..21fe4bf7 100644
--- a/src/app/api/issues/status/route.ts
+++ b/src/app/api/issues/status/route.ts
@@ -148,6 +148,13 @@ export async function POST(request: Request) {
           agentName: typeof agentName === "string" ? agentName : null,
           before: liveLabels,
           after: labelsToSet,
+          // The GitHub status swap above is already outside this transaction,
+          // so a failure here rolls the mirror back while GitHub keeps the new
+          // label — and the retry reads those live labels as "already at the
+          // requested status". The cache row is written inside the transaction,
+          // so on the retry it still holds the pre-write set and can supply the
+          // before-state this attempt is missing. Decisions stay on liveLabels.
+          mirroredBefore: issue.labels,
           metadata: targetLabel === "status/blocked" ? { blocked: true } : null,
         });
       });
@@ -190,4 +197,4 @@ export async function POST(request: Request) {
     console.error("Set issue status failed:", error);
     return errorResponse("Failed to set issue", 500);
   }
-}
\ No newline at end of file
+}
diff --git a/src/app/api/issues/webhook/route.test.ts b/src/app/api/issues/webhook/route.test.ts
index 19b175eb..d1b2d505 100644
--- a/src/app/api/issues/webhook/route.test.ts
+++ b/src/app/api/issues/webhook/route.test.ts
@@ -454,4 +454,61 @@ describe("POST /api/issues/webhook — lifecycle evidence (#1202)", () => {
     expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
     expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
   });
+
+  // `.filter()` returns a new array even when nothing was removed, so an
+  // absent-label removal used to read as a phantom move on every redelivery —
+  // unbounded, because such a hand-rolled delivery has no id to key on.
+  it.each([
+    ["with", { "x-github-delivery": "delivery-absent-label" }],
+    ["without", {}],
+  ])("records nothing when unlabeling a status label the cache does not carry (%s delivery id)", async (_label, headers) => {
+    mocks.issueFindUnique.mockResolvedValue({
+      id: "issue-1",
+      number: 42,
+      repositoryId: "repo-1",
+      labels: ["status/ready", "type/bug"],
+    });
+
+    const res = await POST(
+      signedRequest(
+        makeIssuesEvent({ action: "unlabeled", label: { name: "status/in-review" } }),
+        undefined,
+        headers,
+      ),
+    );
+    expect(res.status).toBe(200);
+
+    // The cached label set is left exactly as it was.
+    expect((await res.json()).labels).toEqual(["status/ready", "type/bug"]);
+    expect(mocks.issueUpdate).toHaveBeenCalledWith({
+      where: { repositoryId_number: { repositoryId: "repo-1", number: 42 } },
+      data: expect.objectContaining({ labels: ["status/ready", "type/bug"] }),
+    });
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+    expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
+  });
+
+  it("records exactly one event for a real status removal", async () => {
+    const res = await POST(
+      signedRequest(
+        makeIssuesEvent({ action: "unlabeled", label: { name: "status/backlog" } }),
+        undefined,
+        { "x-github-delivery": "delivery-removal" },
+      ),
+    );
+    expect(res.status).toBe(200);
+
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledTimes(1);
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledWith({
+      where: { dedupeKey: "webhook|org/repo|42|delivery-removal|status/backlog" },
+      create: expect.objectContaining({
+        kind: "status_changed",
+        source: "webhook",
+        fromStatus: "status/backlog",
+        toStatus: null,
+      }),
+      update: {},
+    });
+    expect(mocks.createLifecycleEvent).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/app/api/issues/webhook/route.ts b/src/app/api/issues/webhook/route.ts
index 45a0ffeb..ac86214a 100644
--- a/src/app/api/issues/webhook/route.ts
+++ b/src/app/api/issues/webhook/route.ts
@@ -173,14 +173,18 @@ export async function POST(request: Request) {
     }
 
     // Idempotent: adding a label that is already present (or removing one
-    // that is absent) leaves the label set unchanged.
+    // that is absent) leaves the label set unchanged — returned as the same
+    // array reference, which is what makes the identity check below exact
+    // rather than a "new array means a change" test.
     const currentLabels = cachedIssue.labels;
     const nextLabels =
       action === "labeled"
         ? currentLabels.includes(labelName)
           ? currentLabels
           : [...currentLabels, labelName]
-        : currentLabels.filter((label) => label !== labelName);
+        : currentLabels.includes(labelName)
+          ? currentLabels.filter((label) => label !== labelName)
+          : currentLabels;
 
     await prisma.issue.update({
       where: { repositoryId_number: { repositoryId: repo.id, number: issueNumber } },
diff --git a/src/lib/groomer/run.test.ts b/src/lib/groomer/run.test.ts
index c85120c6..a3bb551b 100644
--- a/src/lib/groomer/run.test.ts
+++ b/src/lib/groomer/run.test.ts
@@ -943,15 +943,114 @@ describe("runHostedGroomer", () => {
     // The groomer writes labels to GitHub; the issue cache only catches up on
     // the next sync. Recording the move here is what keeps the transition
     // attributable to the groomer instead of to whatever sync ran next.
-    const event = mocks.prisma.issueLifecycleEvent.create.mock.calls.at(-1)?.[0]?.data;
-    expect(event).toMatchObject({
+    const events = mocks.prisma.issueLifecycleEvent.create.mock.calls.map((call: any[]) => call[0].data);
+    expect(events.filter((data: any) => data.kind === "status_changed")).toEqual([
+      expect.objectContaining({
+        issueId: "issue-42",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "status_changed",
+        source: "hosted-groomer",
+        actor: "hosted-groomer",
+        fromStatus: null,
+        toStatus: "status/ready",
+      }),
+    ]);
+  });
+
+  it("records no status_changed for a plan that changed no status label", async () => {
+    // Already at the status the plan derives, so the application lands nothing
+    // at all: the shared guard must keep a `noop` out of the stream instead of
+    // persisting a row whose from/to are identical.
+    mocks.selectGroomingCandidate.mockResolvedValue({ ...mockCandidate, labels: ["status/ready", "priority/p0"] });
+
+    const result = await runHostedGroomer();
+
+    expect(result!.appliedMutations).toMatchObject({ outcome: "noop" });
+    expect(mocks.prisma.issueLifecycleEvent.create).not.toHaveBeenCalled();
+    expect(mocks.prisma.issueLifecycleEvent.upsert).not.toHaveBeenCalled();
+  });
+
+  it("records no status_changed for a partial plan that landed no status label", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    mocks.closeIssue.mockRejectedValue(new Error("GitHub API error: 502"));
+    mocks.callGroomerLLM.mockResolvedValue(
+      notReadyDraft("already_done", {
+        mutations: {
+          githubComment: "Verified on the default branch: the step is gone, so closing as already resolved.",
+          close: {
+            reason: "already_done",
+            rationale: "login.ts no longer has the step",
+            evidenceRefs: ["repo:src/auth/login.ts"],
+            criteria: GROUNDED_CRITERIA,
+          },
+        },
+      }),
+    );
+
+    const result = await runHostedGroomer();
+
+    // The explaining comment landed, the close did not, and no `status/*`
+    // label moved either way — so there is no transition to record.
+    expect(result!.appliedMutations).toMatchObject({ outcome: "partial" });
+    expect(mocks.prisma.issueLifecycleEvent.create).not.toHaveBeenCalled();
+    expect(mocks.prisma.issueLifecycleEvent.upsert).not.toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
+  it("records the close it authored, which the next sync can no longer observe", async () => {
+    mocks.selectGroomingCandidate.mockResolvedValue({ ...mockCandidate, labels: ["status/done", "priority/p0"] });
+    mocks.callGroomerLLM.mockResolvedValue(
+      notReadyDraft("already_done", {
+        mutations: {
+          githubComment: "Verified on the default branch: the step is gone, so closing as already resolved.",
+          close: {
+            reason: "already_done",
+            rationale: "login.ts no longer has the step",
+            evidenceRefs: ["repo:src/auth/login.ts"],
+            criteria: GROUNDED_CRITERIA,
+          },
+        },
+      }),
+    );
+
+    const result = await runHostedGroomer();
+    const key = result!.mutationPlan!.applicationKey as string;
+
+    // The close landed with no status-label move alongside it: one close, and
+    // no transition to stand in for it.
+    expect(mocks.closeIssue).toHaveBeenCalledWith("org/repo", 42);
+    expect(mocks.prisma.issueLifecycleEvent.create).not.toHaveBeenCalled();
+    expect(mocks.prisma.issueLifecycleEvent.upsert).toHaveBeenCalledTimes(1);
+    expect(mocks.prisma.issueLifecycleEvent.upsert).toHaveBeenCalledWith({
+      where: { dedupeKey: `hosted-groomer|org/repo|42|issue_closed|${key}` },
+      create: expect.objectContaining({
+        issueId: "issue-42",
+        kind: "issue_closed",
+        source: "hosted-groomer",
+        actor: "hosted-groomer",
+        toStatus: "status/done",
+      }),
+      update: {},
+    });
+
+    // The close is mirrored into the cache in the same run, so the next sync
+    // observes an issue that was already closed and adds nothing to it.
+    const { recordSyncedIssueEvents } = await import("@/lib/issue-lifecycle");
+    const syncClient = { issueLifecycleEvent: { create: vi.fn(), upsert: vi.fn() } };
+    await recordSyncedIssueEvents(syncClient, {
       issueId: "issue-42",
       repoFullName: "org/repo",
       issueNumber: 42,
-      kind: "status_changed",
-      source: "hosted-groomer",
-      actor: "hosted-groomer",
+      before: { labels: ["status/done", "priority/p0"], state: "closed" },
+      after: {
+        labels: ["status/done", "priority/p0"],
+        state: "closed",
+        updatedAt: new Date("2026-10-02T08:00:00.000Z"),
+        closedAt: new Date("2026-10-02T08:00:00.000Z"),
+      },
     });
+    expect(syncClient.issueLifecycleEvent.upsert).not.toHaveBeenCalled();
   });
 
   it("keeps the run successful when the lifecycle write fails", async () => {
diff --git a/src/lib/groomer/run.ts b/src/lib/groomer/run.ts
index 8a3419f6..4a46f2ea 100644
--- a/src/lib/groomer/run.ts
+++ b/src/lib/groomer/run.ts
@@ -28,7 +28,12 @@ import { createGroomingRunRecord, completeGroomingRunRecord, updateGroomingRunRe
 import { explorationCallsForFreshness } from "./freshness";
 import { freshnessBaselineIssueData } from "./freshness-invalidation";
 import { compareCommits, searchRepositoryCode } from "@/lib/github-code-search";
-import { lifecycleStatusLabel, recordLifecycleEventQuietly } from "@/lib/issue-lifecycle";
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  recordLifecycleEventQuietly,
+  recordStatusTransitionQuietly,
+} from "@/lib/issue-lifecycle";
 import { fetchCommitDate } from "@/lib/github-ci";
 import { validateApplyPreconditions, type LiveComment, type PreconditionReader } from "./mutation-validator";
 import {
@@ -1225,11 +1230,15 @@ async function executeGroomerRun(
     // Record the status move the grooming plan actually made (#1202). The
     // labels only reach the issue cache on the next sync, so without this the
     // groomer's own transition would first be observable as a `sync` event and
-    // a claim-to-merge read could not tell who moved the card. Quiet by
-    // design: a grooming run that already landed its mutations must not fail
-    // over an evidence row, and a replayed application records nothing because
-    // this branch is only reached the first time the application key lands.
-    await recordLifecycleEventQuietly(
+    // a claim-to-merge read could not tell who moved the card. The shared
+    // guard decides what counts: a plan whose application changed no
+    // `status/*` label (a `noop`, or a `partial` that landed something else
+    // first) records nothing rather than a row with identical from/to. Quiet
+    // by design: a grooming run that already landed its mutations must not
+    // fail over an evidence row, and a replayed application records nothing
+    // because this branch is only reached the first time the application key
+    // lands.
+    await recordStatusTransitionQuietly(
       deps.prisma,
       {
         issueId: candidate.id,
@@ -1238,14 +1247,44 @@ async function executeGroomerRun(
         kind: "status_changed",
         source: "hosted-groomer",
         actor: "hosted-groomer",
-        fromStatus: lifecycleStatusLabel(analyzed.labels),
-        toStatus: lifecycleStatusLabel(applied.labels),
-        occurredAt: new Date(),
+        before: analyzed.labels,
+        after: applied.labels,
         metadata: { groomingRunId: groomingRun.id, applicationKey },
       },
       "hosted-groomer",
     );
 
+    // A close is a separate fact from the status label that goes with it, and
+    // the next sync can never observe this one: the close above is mirrored
+    // into the cache in the same run, so by the time sync looks the issue is
+    // already closed there. Recorded under the application key so a retry of
+    // the same plan collapses onto one row. Independent of the transition
+    // above — a plan that closes without moving the status label still
+    // records the close, and records no `status_changed`.
+    if (applied.closed) {
+      await recordLifecycleEventQuietly(
+        deps.prisma,
+        {
+          issueId: candidate.id,
+          repoFullName: candidate.repoFullName,
+          issueNumber: candidate.number,
+          kind: "issue_closed",
+          source: "hosted-groomer",
+          actor: "hosted-groomer",
+          toStatus: lifecycleStatusLabel(applied.labels),
+          dedupeKey: lifecycleDedupeKey(
+            "hosted-groomer",
+            candidate.repoFullName,
+            candidate.number,
+            "issue_closed",
+            applicationKey,
+          ),
+          metadata: { groomingRunId: groomingRun.id, applicationKey },
+        },
+        "hosted-groomer",
+      );
+    }
+
     // Complete GroomingRun. A partial application is explicit in history
     // and retryable: every landed step is recorded, so a retry of the same
     // application replays them instead of repeating them.
diff --git a/src/lib/issue-claim.test.ts b/src/lib/issue-claim.test.ts
index 734583d6..35ac3609 100644
--- a/src/lib/issue-claim.test.ts
+++ b/src/lib/issue-claim.test.ts
@@ -527,3 +527,90 @@ describe("releaseIssueClaim — lifecycle evidence (#1202)", () => {
     expect(update).toHaveBeenCalled();
   });
 });
+
+describe("releaseIssueClaim — one identity per release attempt (#1202 review)", () => {
+  /** A client whose event rows are keyed by dedupeKey, like the unique index. */
+  function makeRowKeepingPrisma(labels: string[]) {
+    const base = makePrisma({ labels });
+    const rows: Array<Record<string, any>> = [];
+    const issueLifecycleEvent = {
+      create: vi.fn(async ({ data }: { data: Record<string, any> }) => {
+        rows.push({ ...data });
+        return data;
+      }),
+      upsert: vi.fn(async ({ where, create }: { where: { dedupeKey: string }; create: Record<string, any> }) => {
+        const existing = rows.find((row) => row.dedupeKey === where.dedupeKey);
+        if (existing) return existing;
+        rows.push({ ...create });
+        return create;
+      }),
+    };
+    const client: IssueClaimClient = {
+      issue: base.client.issue,
+      issueLifecycleEvent,
+      $transaction: (fn: any) => Promise.resolve(fn({ issue: base.client.issue, issueLifecycleEvent })),
+    };
+    return { client, rows, upsertEvent: issueLifecycleEvent.upsert, createEvent: issueLifecycleEvent.create };
+  }
+
+  const staleOptions = (releaseKey?: string) => ({
+    allowMissingAgent: true,
+    preserveStatus: true,
+    source: "stale-recovery",
+    actor: "system",
+    ...(releaseKey ? { releaseKey } : {}),
+  }) as const;
+
+  it("collapses a retried release and its repair onto one row", async () => {
+    // The sweep releases the claim, dies before finalizing the AgentWork row,
+    // and the retry finds the agent label already gone. Both attempts are the
+    // same release of the same claim epoch, so the stream holds one row.
+    const { client, rows } = makeRowKeepingPrisma(["status/in-progress"]);
+
+    await callRelease(client, ["agent/alpha", "status/in-progress"], {
+      releaseOptions: staleOptions("agent-work|work-1"),
+    });
+    await callRelease(client, ["status/in-progress"], {
+      releaseOptions: staleOptions("agent-work|work-1"),
+    });
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ kind: "claim_released", source: "stale-recovery" });
+  });
+
+  it("records a reclaim as its own release, because it is a new claim epoch", async () => {
+    // Same issue, same agent, but the work was claimed again in between, so
+    // the caller holds a new AgentWork row and supplies a new key.
+    const { client, rows } = makeRowKeepingPrisma(["status/in-progress"]);
+
+    await callRelease(client, ["agent/alpha", "status/in-progress"], {
+      releaseOptions: staleOptions("agent-work|work-1"),
+    });
+    await callRelease(client, ["agent/alpha", "status/in-progress"], {
+      releaseOptions: staleOptions("agent-work|work-2"),
+    });
+
+    expect(rows).toHaveLength(2);
+    expect(new Set(rows.map((row) => row.dedupeKey)).size).toBe(2);
+  });
+
+  it("leaves the unclaim route's path unchanged when no release key is supplied", async () => {
+    // The operator/agent unclaim route knows no claim epoch: its release stays
+    // a plain insert, and the already-released repair keeps its own key.
+    const unclaimed = makeRowKeepingPrisma(["status/in-progress"]);
+    await callRelease(unclaimed.client, ["agent/alpha", "status/in-progress"], {});
+
+    expect(unclaimed.createEvent).toHaveBeenCalledTimes(1);
+    expect(unclaimed.createEvent.mock.calls[0][0].data.dedupeKey).toBeUndefined();
+
+    const repaired = makeRowKeepingPrisma(["status/in-progress"]);
+    await callRelease(repaired.client, ["status/in-progress"], {
+      releaseOptions: { allowMissingAgent: true, source: "stale-recovery", actor: "system" },
+    });
+
+    expect(repaired.createEvent).not.toHaveBeenCalled();
+    expect(repaired.upsertEvent.mock.calls[0][0].create.dedupeKey).toBe(
+      "claim-released|issue-1|agent/alpha|already-released",
+    );
+  });
+});
diff --git a/src/lib/issue-claim.ts b/src/lib/issue-claim.ts
index 3069051f..20167a4c 100644
--- a/src/lib/issue-claim.ts
+++ b/src/lib/issue-claim.ts
@@ -29,6 +29,14 @@ export interface ReleaseIssueClaimOptions {
   source?: LifecycleSource;
   /** Lifecycle actor for the release. Defaults to the releasing agent. */
   actor?: string;
+  /**
+   * A stable identity for THIS release attempt — one claim epoch — supplied by
+   * the caller so the ownership-only release and the already-released repair a
+   * retry of that same attempt takes collapse onto one `claim_released` row
+   * instead of recording the release twice. Absent, behavior is unchanged: the
+   * repair keeps its own key and the real release stays unkeyed.
+   */
+  releaseKey?: string;
 }
 
 export interface ReleaseIssueClaimResult {
@@ -123,6 +131,14 @@ export async function releaseIssueClaim(params: {
     dedupeKey: dedupeKey ?? null,
   });
 
+  // One identity for this release attempt, shared by the ownership-only
+  // release and the repair a retry of the same attempt takes. Without it the
+  // two writes carry different identities — and a sweep that dies between them
+  // records one release twice, once for each path it took.
+  const releaseDedupeKey = options.releaseKey
+    ? lifecycleDedupeKey("claim-released", issue.id, agentLabel, options.releaseKey)
+    : null;
+
   // Never remove a newer agent's claim while an old AgentWork row is being
   // recovered. The stale-work caller can still retire the old local row.
   if (currentAgent && currentAgent !== agentLabel) {
@@ -155,7 +171,8 @@ export async function releaseIssueClaim(params: {
       releaseEvent(
         issue.labels,
         cacheLabels,
-        lifecycleDedupeKey("claim-released", issue.id, agentLabel, "already-released"),
+        releaseDedupeKey ??
+          lifecycleDedupeKey("claim-released", issue.id, agentLabel, "already-released"),
       ),
     );
     return {
@@ -177,7 +194,7 @@ export async function releaseIssueClaim(params: {
       ? await prisma.issue.findUnique({ where: { id: issue.id }, select: { labels: true } })
       : null;
     const cacheLabels = latestIssue?.labels?.filter((label: string) => label !== agentLabel) ?? updatedLabels;
-    await commitRelease(cacheLabels, releaseEvent(issue.labels, cacheLabels));
+    await commitRelease(cacheLabels, releaseEvent(issue.labels, cacheLabels, releaseDedupeKey ?? undefined));
     return {
       released: true,
       labels: cacheLabels,
diff --git a/src/lib/issue-lifecycle.test.ts b/src/lib/issue-lifecycle.test.ts
index 3515ebf1..9f3f79d2 100644
--- a/src/lib/issue-lifecycle.test.ts
+++ b/src/lib/issue-lifecycle.test.ts
@@ -8,6 +8,7 @@ import {
   recordLifecycleEvent,
   recordLifecycleEventQuietly,
   recordStatusTransition,
+  recordStatusTransitionQuietly,
   recordSyncedIssueEvents,
   type LifecycleEventClient,
 } from "./issue-lifecycle";
@@ -191,6 +192,48 @@ describe("recordStatusTransition", () => {
       toStatus: "status/in-review",
     });
   });
+
+  it("recovers the before-state from the mirrored cache when the observed labels already show the write", async () => {
+    const { client, rows } = makeClient();
+
+    // The GitHub write landed and the local transaction that mirrors it rolled
+    // back, so the retry observes labels that already carry the new status and
+    // the cache still holds the state from before the write. Without the
+    // fallback the first attempt's transition would be lost for good.
+    const recorded = await recordStatusTransition(client, {
+      ...base,
+      kind: "status_changed",
+      source: "api:status",
+      actor: "operator",
+      before: ["status/in-review"],
+      after: ["status/in-review"],
+      mirroredBefore: ["status/ready"],
+    });
+
+    expect(recorded).toBe(true);
+    expect(rows[0]).toMatchObject({
+      fromStatus: "status/ready",
+      toStatus: "status/in-review",
+      metadata: { recoveredFromMirroredState: true },
+    });
+  });
+
+  it("records nothing when neither the observed nor the mirrored labels show a change", async () => {
+    const { client, rows } = makeClient();
+
+    const recorded = await recordStatusTransition(client, {
+      ...base,
+      kind: "status_changed",
+      source: "api:status",
+      actor: "operator",
+      before: ["status/in-review"],
+      after: ["status/in-review"],
+      mirroredBefore: ["status/in-review"],
+    });
+
+    expect(recorded).toBe(false);
+    expect(rows).toHaveLength(0);
+  });
 });
 
 describe("recordClaimEvent", () => {
@@ -244,6 +287,78 @@ describe("recordClaimEvent", () => {
 
     expect(rows).toHaveLength(1);
   });
+
+  it("recovers a retried claim from the mirrored cache, and only marks it when it had to", async () => {
+    const { client, rows } = makeClient();
+    const after = ["status/in-progress", "agent/alpha"];
+
+    // The claim's GitHub writes landed and its transaction rolled back: the
+    // retry sees an already-claimed issue, and only the cache row — written
+    // inside that transaction — still holds the pre-claim labels.
+    const recovered = await recordClaimEvent(client, {
+      ...base, kind: "claim", source: "api:claim", actor: "alpha", agentName: "alpha",
+      before: after, after, mirroredBefore: ["status/ready"],
+    });
+
+    expect(recovered).toBe(true);
+    expect(rows[0]).toMatchObject({
+      kind: "claim",
+      fromStatus: "status/ready",
+      toStatus: "status/in-progress",
+      metadata: { recoveredFromMirroredState: true },
+    });
+
+    // A claim the observed labels already show as a genuine transition is not
+    // labelled as recovered.
+    await recordClaimEvent(client, {
+      ...base, kind: "claim", source: "api:claim", actor: "bravo", agentName: "bravo",
+      before: ["status/ready"], after: ["status/in-progress", "agent/bravo"],
+      mirroredBefore: ["status/backlog"],
+    });
+    expect(rows[1].metadata).not.toHaveProperty("recoveredFromMirroredState");
+  });
+
+  it("records nothing for a redelivered claim whose mirror already carries the claim", async () => {
+    const { client, rows } = makeClient();
+    const labels = ["status/in-progress", "agent/alpha"];
+
+    const recorded = await recordClaimEvent(client, {
+      ...base, kind: "claim", source: "api:claim", actor: "alpha", agentName: "alpha",
+      before: labels, after: labels, mirroredBefore: labels,
+    });
+
+    expect(recorded).toBe(false);
+    expect(rows).toHaveLength(0);
+  });
+
+  it("marks a recovery that a stale cache cannot distinguish from a real prior state", async () => {
+    const { client, rows } = makeClient();
+
+    // Known limitation (dispatch#1202 review, second pass): the mirrored row
+    // is only a witness of the pre-write state when the cache was in step with
+    // GitHub. When sync lag has left it behind, a retry that finds the observed
+    // labels already at the target still recovers from it — so the recovered
+    // `fromStatus` can describe the last mirrored state rather than the state
+    // this claim actually displaced. There is no way to tell the two apart at
+    // retry time without a durable intent recorded before the GitHub write, so
+    // the row is marked instead: a reader that filters on
+    // `recoveredFromMirroredState` never mistakes it for an observed move.
+    // Sync independently records the real GitHub-side move, so a status change
+    // is never lost — only its attribution to this writer is approximate.
+    const recorded = await recordStatusTransition(client, {
+      ...base, kind: "status_changed", source: "api:status", actor: "alpha",
+      before: ["status/in-progress", "agent/alpha"],
+      after: ["status/in-progress", "agent/beta"],
+      mirroredBefore: ["status/backlog"],
+    });
+
+    expect(recorded).toBe(true);
+    expect(rows[0]).toMatchObject({
+      fromStatus: "status/backlog",
+      toStatus: "status/in-progress",
+      metadata: { recoveredFromMirroredState: true },
+    });
+  });
 });
 
 describe("recordSyncedIssueEvents", () => {
@@ -315,18 +430,48 @@ describe("recordSyncedIssueEvents", () => {
     expect(Object.keys(client)).toEqual(["issueLifecycleEvent"]);
   });
 
-  it("keeps a failed sync write from failing the sync", async () => {
+  it("propagates a failed event write so the caller can defer its mirror", async () => {
     const { client } = makeClient();
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-    vi.mocked(client.issueLifecycleEvent.create).mockRejectedValue(new Error("db down"));
+    vi.mocked(client.issueLifecycleEvent.upsert).mockRejectedValue(new Error("db down"));
 
+    // The stores record before mirroring, so swallowing this would leave a
+    // cache that shows a move the stream has no record of — and the next sync
+    // derives no transition from it, so the row can never be reconstructed.
     await expect(
       recordSyncedIssueEvents(client, {
         ...base,
         before: { labels: ["status/ready"], state: "open" },
         after: { labels: ["status/done"], state: "open", updatedAt: syncedAt },
       }),
-    ).resolves.toBeUndefined();
+    ).rejects.toThrow("db down");
+  });
+});
+
+describe("recordStatusTransitionQuietly", () => {
+  it("reports whether the transition was recorded and never throws", async () => {
+    const { client, rows } = makeClient();
+
+    await expect(
+      recordStatusTransitionQuietly(
+        client,
+        { ...base, kind: "status_changed", source: "hosted-groomer", actor: "hosted-groomer",
+          before: ["status/backlog"], after: ["status/ready"] },
+        "hosted-groomer",
+      ),
+    ).resolves.toBe(true);
+    expect(rows).toHaveLength(1);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.mocked(client.issueLifecycleEvent.create).mockRejectedValue(new Error("db down"));
+    await expect(
+      recordStatusTransitionQuietly(
+        client,
+        { ...base, kind: "status_changed", source: "hosted-groomer", actor: "hosted-groomer",
+          before: ["status/backlog"], after: ["status/ready"] },
+        "hosted-groomer",
+      ),
+    ).resolves.toBe(false);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("hosted-groomer"));
   });
 });
 
diff --git a/src/lib/issue-lifecycle.ts b/src/lib/issue-lifecycle.ts
index cb4dd5ba..fca2d984 100644
--- a/src/lib/issue-lifecycle.ts
+++ b/src/lib/issue-lifecycle.ts
@@ -208,6 +208,16 @@ export interface LifecycleStatusTransitionInput {
   before: readonly string[];
   /** Label set after the write — the same set the writer mirrored locally. */
   after: readonly string[];
+  /**
+   * The label set Dispatch last mirrored into the cache. A fallback only: it
+   * becomes the before-state when `before` no longer shows the change, which
+   * is what happens when the GitHub write of a Dispatch-authored change landed
+   * but the local transaction that mirrors it and records the evidence rolled
+   * back — the live labels already carry the change while the cache still
+   * holds the state from before it. Absent, `before` is used exactly as it is
+   * today.
+   */
+  mirroredBefore?: readonly string[] | null;
   sourceEventId?: string | null;
   dedupeKey?: string | null;
   occurredAt?: Date;
@@ -215,6 +225,40 @@ export interface LifecycleStatusTransitionInput {
   metadata?: Record<string, unknown> | null;
 }
 
+/**
+ * Decide which label set to read a Dispatch-authored change's "before" state
+ * from, and describe the change it shows.
+ *
+ * `observed` is what the writer passed as `before`; `resolve` returns the
+ * change it describes, or null when there is none. A mirrored fallback (the
+ * cache row the writer last wrote) is consulted only when `observed` no longer
+ * shows the change — the shape of a retry after a rolled-back local write,
+ * where the GitHub mutation already landed and the live labels therefore read
+ * as "already in the after state". Recovering the evidence of the first attempt
+ * matters more than the extra write: without it the attempt is lost forever,
+ * because nothing downstream can reconstruct a transition the cache no longer
+ * shows. A row written this way is marked `recoveredFromMirroredState`.
+ */
+function resolveBeforeState<T>(
+  input: LifecycleStatusTransitionInput,
+  resolve: (before: readonly string[], after: readonly string[]) => T | null,
+): { before: readonly string[]; recoveredFromMirroredState: boolean; change: T } | null {
+  const observed = resolve(input.before, input.after);
+  if (observed) {
+    return { before: input.before, recoveredFromMirroredState: false, change: observed };
+  }
+
+  const mirrored = input.mirroredBefore;
+  if (mirrored) {
+    const fromMirror = resolve(mirrored, input.after);
+    if (fromMirror) {
+      return { before: mirrored, recoveredFromMirroredState: true, change: fromMirror };
+    }
+  }
+
+  return null;
+}
+
 /**
  * Persist the status transition implied by a label-set change, or nothing when
  * the status label did not move. Callers pass the exact before/after label
@@ -225,8 +269,8 @@ export async function recordStatusTransition(
   client: LifecycleEventClient,
   input: LifecycleStatusTransitionInput,
 ): Promise<boolean> {
-  const transition = lifecycleStatusTransition(input.before, input.after);
-  if (!transition) return false;
+  const resolved = resolveBeforeState(input, lifecycleStatusTransition);
+  if (!resolved) return false;
 
   await recordLifecycleEvent(client, {
     issueId: input.issueId,
@@ -236,13 +280,15 @@ export async function recordStatusTransition(
     source: input.source,
     actor: input.actor,
     agentName: input.agentName ?? null,
-    fromStatus: transition.from,
-    toStatus: transition.to,
+    fromStatus: resolved.change.from,
+    toStatus: resolved.change.to,
     sourceEventId: input.sourceEventId ?? null,
     dedupeKey: input.dedupeKey ?? null,
     occurredAt: input.occurredAt,
     observedAt: input.observedAt,
-    metadata: input.metadata ?? null,
+    metadata: resolved.recoveredFromMirroredState
+      ? { ...input.metadata, recoveredFromMirroredState: true }
+      : input.metadata ?? null,
   });
   return true;
 }
@@ -261,10 +307,15 @@ export async function recordClaimEvent(
   client: LifecycleEventClient,
   input: LifecycleStatusTransitionInput,
 ): Promise<boolean> {
-  const transition = lifecycleStatusTransition(input.before, input.after);
-  const claimedFrom = getAgentFromLabels([...input.before]);
-  const claimedTo = getAgentFromLabels([...input.after]);
-  if (!transition && claimedFrom === claimedTo) return false;
+  const resolved = resolveBeforeState(input, (before, after) => {
+    const transition = lifecycleStatusTransition(before, after);
+    const claimedFrom = getAgentFromLabels([...before]);
+    const claimedTo = getAgentFromLabels([...after]);
+    if (!transition && claimedFrom === claimedTo) return null;
+    return { transition, claimedFrom, claimedTo };
+  });
+  if (!resolved) return false;
+  const { transition, claimedFrom, claimedTo } = resolved.change;
 
   await recordLifecycleEvent(client, {
     issueId: input.issueId,
@@ -274,7 +325,7 @@ export async function recordClaimEvent(
     source: input.source,
     actor: input.actor,
     agentName: input.agentName ?? null,
-    fromStatus: lifecycleStatusLabel(input.before),
+    fromStatus: lifecycleStatusLabel(resolved.before),
     toStatus: lifecycleStatusLabel(input.after),
     sourceEventId: input.sourceEventId ?? null,
     dedupeKey: input.dedupeKey ?? null,
@@ -285,6 +336,7 @@ export async function recordClaimEvent(
       ...(transition
         ? null
         : { claimedFrom, claimedTo, note: "ownership changed without a status transition" }),
+      ...(resolved.recoveredFromMirroredState ? { recoveredFromMirroredState: true } : null),
     },
   });
   return true;
@@ -308,6 +360,12 @@ export async function recordClaimEvent(
  *   move has a different `updated_at` and therefore a different key.
  * - Nothing here writes back to `Issue`. The events are evidence, so a late or
  *   out-of-order sync can be recorded without ever moving the present status.
+ *
+ * A failed event write propagates. Callers record before mirroring the change
+ * into the cache, so a throw defers that issue's mirror to the next run —
+ * where the same transition is re-derived from the same before-state and lands
+ * on the same dedupe key — instead of leaving a cache that shows a change the
+ * stream has no record of.
  */
 export async function recordSyncedIssueEvents(
   client: LifecycleEventClient,
@@ -395,18 +453,18 @@ export async function recordSyncedIssueEvents(
   }
 
   for (const write of writes) {
-    await recordLifecycleEventQuietly(client, write, "issue sync");
+    await recordLifecycleEvent(client, write);
   }
 }
 
 /**
  * Record an event without letting a lifecycle failure abort the writer.
  *
- * For the observed sources — sync, webhook, reconcile — the job is the local
- * mirror, not the event: those paths are periodic and retried, so a failed
- * event must cost a log line rather than the whole run. Dispatch-authored
- * writes share a transaction with the state they describe and deliberately
- * fail together instead (see the route callers).
+ * For the sources whose job is the local mirror rather than the event
+ * (webhook, reconciler, worker report, hosted groomer) those paths are periodic
+ * and retried, so a failed event must cost a log line rather than the whole
+ * run. Dispatch-authored writes share a transaction with the state they
+ * describe and deliberately fail together instead (see the route callers).
  */
 export async function recordLifecycleEventQuietly(
   client: LifecycleEventClient,
@@ -421,4 +479,26 @@ export async function recordLifecycleEventQuietly(
       `lifecycle event ${write.kind} for ${write.repoFullName}#${write.issueNumber} was not recorded (${context}): ${message}`,
     );
   }
-}
\ No newline at end of file
+}
+
+/**
+ * `recordStatusTransition` with the same guarantee as above, for a writer that
+ * goes through the transition guard but still must not fail over its evidence
+ * row (the hosted groomer, whose mutations have already landed by then).
+ * Returns whether the transition was recorded.
+ */
+export async function recordStatusTransitionQuietly(
+  client: LifecycleEventClient,
+  input: LifecycleStatusTransitionInput,
+  context: string,
+): Promise<boolean> {
+  try {
+    return await recordStatusTransition(client, input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `lifecycle event ${input.kind} for ${input.repoFullName}#${input.issueNumber} was not recorded (${context}): ${message}`,
+    );
+    return false;
+  }
+}
diff --git a/src/lib/issue-sync.test.ts b/src/lib/issue-sync.test.ts
index 25f6bba9..4bf9683e 100644
--- a/src/lib/issue-sync.test.ts
+++ b/src/lib/issue-sync.test.ts
@@ -41,6 +41,7 @@ import {
   closedIssueStatusFix,
   fetchAllStateIssues,
   makePrismaIssueStore,
+  makePrismaReconcileIssueStore,
   defaultCurrentLane,
   currentLaneForLabels,
   SYNC_OVERLAP_BUFFER_MS,
@@ -715,17 +716,113 @@ describe("makePrismaIssueStore — lifecycle evidence (#1202)", () => {
     expect(new Set(keys).size).toBe(1);
   });
 
-  it("keeps a failed event write from failing the sync it observed", async () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    mocks.upsertLifecycleEvent.mockRejectedValue(new Error("db down"));
-    const store = makePrismaIssueStore();
+  it("defers the mirror when the event write fails, then records exactly one event on the next sync", async () => {
+    // The evidence is written before the mirror, so a failed event write must
+    // leave the cache row untouched: an already-mirrored change would leave the
+    // next sync with no transition to derive, and the missing row could never
+    // be reconstructed.
+    const failedRun = makePrismaIssueStore();
+    await failedRun.findIssue("repo-1", 42);
+    mocks.upsertLifecycleEvent.mockRejectedValueOnce(new Error("db down"));
 
-    await store.findIssue("repo-1", 42);
     await expect(
-      store.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" }),
-    ).resolves.toBeUndefined();
+      failedRun.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" }),
+    ).rejects.toThrow("db down");
+    expect(mocks.issueUpdate).not.toHaveBeenCalled();
+
+    // The next sync sees the same before-state, re-derives the same transition
+    // and upserts onto the same source-derived key.
+    const retriedRun = makePrismaIssueStore();
+    await retriedRun.findIssue("repo-1", 42);
+    await retriedRun.updateIssue("issue-1", syncData(), { labels: ["status/ready"], state: "open" });
+
+    expect(mocks.issueUpdate).toHaveBeenCalledTimes(1);
+    // Both attempts carried the same identity, so the retry upserts the row the
+    // failed run could not write instead of appending a second one.
+    const keys = mocks.upsertLifecycleEvent.mock.calls.map((call: any[]) => call[0].where.dedupeKey);
+    expect(keys).toHaveLength(2);
+    expect(new Set(keys).size).toBe(1);
+  });
+});
 
-    expect(mocks.issueUpdate).toHaveBeenCalled();
-    expect(warn).toHaveBeenCalled();
+describe("makePrismaReconcileIssueStore — lifecycle evidence (#1202)", () => {
+  const closedAt = new Date("2026-10-02T09:00:00.000Z");
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.issueUpdate.mockResolvedValue({ id: "issue-1" });
+    mocks.issueFindUnique.mockResolvedValue({
+      number: 42,
+      repository: { fullName: "org/repo" },
+    });
+    mocks.createLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+    mocks.upsertLifecycleEvent.mockResolvedValue({ id: "evt-1" });
+  });
+
+  const closedData = { labels: ["status/done"], state: "closed", closedAt };
+
+  it("records the closure before mirroring it", async () => {
+    const store = makePrismaReconcileIssueStore();
+    await store.updateIssue("issue-1", closedData, { labels: ["status/ready"], state: "open" });
+
+    // Reconciling a close moves the status label and closes the issue, so both
+    // facts are recorded: a label that reads status/done on an open issue is
+    // not the same evidence as GitHub having closed it.
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledWith({
+      where: { dedupeKey: "sync|org/repo|42|issue_closed|2026-10-02T09:00:00.000Z" },
+      create: expect.objectContaining({
+        issueId: "issue-1",
+        repoFullName: "org/repo",
+        issueNumber: 42,
+        kind: "issue_closed",
+        source: "sync",
+      }),
+      update: {},
+    });
+    expect(mocks.upsertLifecycleEvent).toHaveBeenCalledWith({
+      where: { dedupeKey: "sync|org/repo|42|status_changed|status/ready|status/done|" },
+      create: expect.objectContaining({
+        issueId: "issue-1",
+        kind: "status_changed",
+        fromStatus: "status/ready",
+        toStatus: "status/done",
+      }),
+      update: {},
+    });
+    expect(mocks.issueUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it("defers the mirror when the event write fails, then records one closure on the next pass", async () => {
+    // Same ordering guarantee as the sync store: this store resolves the repo
+    // name itself, so it is the only place where an event failure could leave
+    // an already-closed cache row that no later reconcile could observe.
+    const failedRun = makePrismaReconcileIssueStore();
+    mocks.upsertLifecycleEvent.mockRejectedValueOnce(new Error("db down"));
+
+    await expect(
+      failedRun.updateIssue("issue-1", closedData, { labels: ["status/ready"], state: "open" }),
+    ).rejects.toThrow("db down");
+    expect(mocks.issueUpdate).not.toHaveBeenCalled();
+
+    const retriedRun = makePrismaReconcileIssueStore();
+    await retriedRun.updateIssue("issue-1", closedData, { labels: ["status/ready"], state: "open" });
+
+    expect(mocks.issueUpdate).toHaveBeenCalledTimes(1);
+    // The failed pass got as far as the first of the two identities before the
+    // write was rejected, and the retry derives both of them again from the
+    // unchanged cache row: three attempts, two identities, so the row the
+    // failed pass could not write is upserted rather than duplicated.
+    const keys = mocks.upsertLifecycleEvent.mock.calls.map((call: any[]) => call[0].where.dedupeKey);
+    expect(keys).toHaveLength(3);
+    expect(new Set(keys).size).toBe(2);
+    expect(keys[0]).toBe(keys[1]);
+  });
+
+  it("mirrors without an event when there is no before-state to measure against", async () => {
+    const store = makePrismaReconcileIssueStore();
+    await store.updateIssue("issue-1", closedData);
+
+    expect(mocks.upsertLifecycleEvent).not.toHaveBeenCalled();
+    expect(mocks.issueUpdate).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/src/lib/issue-sync.ts b/src/lib/issue-sync.ts
index 44e298f9..d27de447 100644
--- a/src/lib/issue-sync.ts
+++ b/src/lib/issue-sync.ts
@@ -478,26 +478,35 @@ export function makePrismaIssueStore(): IssueStore {
       });
     },
     async updateIssue(id: string, data: SyncedIssueData, previous?: IssueSyncSnapshot | null) {
-      await prisma.issue.update({ where: { id }, data });
-
       const repoFullName = repoByIssueId.get(id);
       repoByIssueId.delete(id);
-      // The write landed even if the lookup above never ran, so a missing repo
-      // name costs the event, not the sync.
-      if (!repoFullName || !previous) return;
-
-      await recordSyncedIssueEvents(prisma, {
-        issueId: id,
-        repoFullName,
-        issueNumber: data.number,
-        before: { labels: previous.labels, state: previous.state ?? null },
-        after: {
-          labels: data.labels,
-          state: data.state,
-          updatedAt: data.updatedAt,
-          closedAt: data.closedAt,
-        },
-      });
+
+      // Evidence before the mirror (#1202). Committing the cache write first
+      // and the event second would make a failed event write unrecoverable: the
+      // next sync would read an already-updated cache, derive no transition and
+      // never reconstruct the missing row. Recording first lets the failure
+      // abort this issue's mirror instead — the sync core catches a throwing
+      // updateIssue at repo level and reports that repo as errored, exactly as
+      // it already does for a failed mirror write — and because the cache row
+      // never moved, the next run re-derives the same transition from the same
+      // before-state and upserts onto the same source-derived dedupe key: one
+      // row, not a duplicate.
+      if (repoFullName && previous) {
+        await recordSyncedIssueEvents(prisma, {
+          issueId: id,
+          repoFullName,
+          issueNumber: data.number,
+          before: { labels: previous.labels, state: previous.state ?? null },
+          after: {
+            labels: data.labels,
+            state: data.state,
+            updatedAt: data.updatedAt,
+            closedAt: data.closedAt,
+          },
+        });
+      }
+
+      await prisma.issue.update({ where: { id }, data });
     },
     async createIssue(repositoryId: string, data: SyncedIssueData) {
       // Stamp the configured default claimable lane so a freshly-ingested,
@@ -564,22 +573,27 @@ export function makePrismaReconcileIssueStore(): {
   return {
     findActiveCachedIssues: findActiveCachedIssuesForReconcile,
     async updateIssue(id, data, previous) {
-      await prisma.issue.update({ where: { id }, data });
-      if (!previous) return;
+      // Evidence before the mirror, for the same reason as the sync store
+      // above: a failed event write must leave the cache untouched so the next
+      // run can re-derive the transition. The repo lookup is this store's only
+      // extra read; it moves ahead of the update rather than being added for it.
+      if (previous) {
+        const repo = await prisma.issue.findUnique({
+          where: { id },
+          select: { number: true, repository: { select: { fullName: true } } },
+        });
+        if (repo) {
+          await recordSyncedIssueEvents(prisma, {
+            issueId: id,
+            repoFullName: repo.repository.fullName,
+            issueNumber: repo.number,
+            before: { labels: previous.labels, state: previous.state ?? null },
+            after: { labels: data.labels, state: data.state, closedAt: data.closedAt },
+          });
+        }
+      }
 
-      const repo = await prisma.issue.findUnique({
-        where: { id },
-        select: { number: true, repository: { select: { fullName: true } } },
-      });
-      if (!repo) return;
-
-      await recordSyncedIssueEvents(prisma, {
-        issueId: id,
-        repoFullName: repo.repository.fullName,
-        issueNumber: repo.number,
-        before: { labels: previous.labels, state: previous.state ?? null },
-        after: { labels: data.labels, state: data.state, closedAt: data.closedAt },
-      });
+      await prisma.issue.update({ where: { id }, data });
     },
   };
 }
diff --git a/src/lib/stale-work.test.ts b/src/lib/stale-work.test.ts
new file mode 100644
index 00000000..0a790595
--- /dev/null
+++ b/src/lib/stale-work.test.ts
@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/github", () => ({
+  addIssueLabel: vi.fn(),
+  removeIssueLabel: vi.fn(),
+}));
+
+vi.mock("@/lib/github-prs", () => ({
+  fetchPullRequestState: vi.fn(),
+}));
+
+// The default client is never used: every test passes its own fake.
+vi.mock("@/lib/prisma", () => ({ prisma: {} }));
+
+import { removeIssueLabel } from "@/lib/github";
+import { sweepStaleWork, type StaleWorkClient } from "./stale-work";
+
+const removeIssueLabelMock = removeIssueLabel as ReturnType<typeof vi.fn>;
+
+const REPO = "octocat/hello-world";
+
+interface WorkRow {
+  id: string;
+  agentName: string;
+  issueId: string;
+  state: string;
+  staleClaimReleasePending: boolean;
+  lastHeartbeatAt: Date;
+  leaseExpiresAt: Date;
+  issue: {
+    id: string;
+    number: number;
+    state: string;
+    labels: string[];
+    blockedReason: null;
+    linkedPrNumber: null;
+    repository: { fullName: string };
+  };
+}
+
+/**
+ * A stale AgentWork row plus the narrow surfaces `sweepStaleWork` reads. The
+ * issue row is mutable so a release is visible to the retry, and the lifecycle
+ * event table keeps rows keyed by `dedupeKey` the way the unique index does —
+ * so "how many releases are in the stream" is counted, not inferred.
+ */
+function makeSweepClient(options: { work: WorkRow; dieBeforeFinalize?: boolean }) {
+  const eventRows: Array<Record<string, any>> = [];
+  const work = options.work;
+  let crashed = false;
+
+  const issueLifecycleEvent = {
+    create: vi.fn(async ({ data }: { data: Record<string, any> }) => {
+      eventRows.push({ ...data });
+      return data;
+    }),
+    upsert: vi.fn(async ({ where, create }: { where: { dedupeKey: string }; create: Record<string, any> }) => {
+      const existing = eventRows.find((row) => row.dedupeKey === where.dedupeKey);
+      if (existing) return existing;
+      eventRows.push({ ...create });
+      return create;
+    }),
+  };
+
+  const issue = {
+    update: vi.fn(async ({ data }: { data: { labels?: string[] } }) => {
+      if (data.labels) issueRow.labels = [...data.labels];
+      return issueRow;
+    }),
+    findUnique: vi.fn(async () => ({ labels: [...issueRow.labels] })),
+  };
+  const issueRow = work.issue;
+
+  const agentWorkUpdateMany = vi.fn(async ({ data }: { data: Record<string, any> }) => {
+    // The finalization step is what a crash lands after: the release has
+    // committed, but the row is never cleared of its retry marker.
+    if (options.dieBeforeFinalize && data.staleClaimReleasePending === false && !crashed) {
+      crashed = true;
+      throw new Error("sweep died before finalizing");
+    }
+    if (data.state) work.state = data.state;
+    if (data.staleClaimReleasePending !== undefined) work.staleClaimReleasePending = data.staleClaimReleasePending;
+    return { count: 1 };
+  });
+
+  const tx = {
+    agentWork: { updateMany: agentWorkUpdateMany },
+    lease: { deleteMany: vi.fn().mockResolvedValue({ count: 1 }) },
+    agentWorkHistory: { create: vi.fn().mockResolvedValue({ id: "h-1" }) },
+    issue,
+    issueLifecycleEvent,
+  };
+
+  const client = {
+    agentWork: { findMany: vi.fn(async () => [work]) },
+    issue,
+    issueLifecycleEvent,
+    lease: tx.lease,
+    agentWorkHistory: tx.agentWorkHistory,
+    auditLog: { create: vi.fn().mockResolvedValue({ id: "a-1" }) },
+    $transaction: vi.fn(async (fn: (t: typeof tx) => Promise<unknown>) => fn(tx)),
+  } as unknown as StaleWorkClient;
+
+  return { client, eventRows, work };
+}
+
+function makeWork(overrides: Partial<WorkRow> = {}): WorkRow {
+  return {
+    id: "work-1",
+    agentName: "alpha",
+    issueId: "issue-1",
+    state: "CLAIMED",
+    staleClaimReleasePending: false,
+    lastHeartbeatAt: new Date("2026-10-01T00:00:00.000Z"),
+    leaseExpiresAt: new Date("2026-10-01T00:00:00.000Z"),
+    issue: {
+      id: "issue-1",
+      number: 42,
+      state: "open",
+      labels: ["agent/alpha", "status/in-progress"],
+      blockedReason: null,
+      linkedPrNumber: null,
+      repository: { fullName: REPO },
+    },
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  removeIssueLabelMock.mockResolvedValue(undefined);
+});
+
+describe("sweepStaleWork — one claim_released per claim epoch (#1202 review)", () => {
+  it("records one release for a sweep that dies before finalizing, then retries", async () => {
+    // The AgentWork row is the claim epoch and is stable across the retry, so
+    // the release and the already-released repair the retry has to take are the
+    // same release — one row, not two.
+    const { client, eventRows, work } = makeSweepClient({ work: makeWork(), dieBeforeFinalize: true });
+
+    const first = await sweepStaleWork(client);
+    expect(first.released).toBe(0);
+    expect(first.errors).toHaveLength(1);
+    expect(eventRows).toHaveLength(1);
+    expect(eventRows[0]).toMatchObject({ kind: "claim_released", source: "stale-recovery" });
+    // The row is still marked for retry, exactly as a crash leaves it.
+    expect(work.staleClaimReleasePending).toBe(true);
+
+    const second = await sweepStaleWork(client);
+    expect(second.released).toBe(1);
+    expect(second.errors).toHaveLength(0);
+
+    expect(eventRows).toHaveLength(1);
+    // The retry found the agent label already gone and repaired the cache.
+    expect(removeIssueLabelMock).toHaveBeenCalledTimes(2);
+    expect(removeIssueLabelMock).toHaveBeenLastCalledWith(REPO, 42, "agent/alpha");
+    expect(work.issue.labels).toEqual(["status/in-progress"]);
+  });
+
+  it("records a reclaim as a second release, because the AgentWork row is new", async () => {
+    // The issue was claimed again after the first sweep, so the second row is a
+    // different claim epoch and its release is a different fact.
+    const first = makeSweepClient({ work: makeWork() });
+    await sweepStaleWork(first.client);
+    expect(first.eventRows).toHaveLength(1);
+
+    const reclaimed = makeWork({ id: "work-2", issue: makeWork().issue });
+    const second = makeSweepClient({ work: reclaimed });
+    await sweepStaleWork(second.client);
+
+    expect(second.eventRows).toHaveLength(1);
+    // Different identities: the two releases do not collapse onto one row.
+    expect(second.eventRows[0].dedupeKey).not.toBe(first.eventRows[0].dedupeKey);
+  });
+
+  it("skips a row another sweep already took over", async () => {
+    const { client, eventRows } = makeSweepClient({ work: makeWork() });
+    // The conditional mark misses — a concurrent sweep owns this row now.
+    (client as unknown as { $transaction: any }).$transaction.mockImplementation(async () => false);
+
+    const report = await sweepStaleWork(client);
+
+    expect(report).toMatchObject({ examined: 1, released: 0, skipped: 1 });
+    expect(eventRows).toHaveLength(0);
+  });
+});
\ No newline at end of file
diff --git a/src/lib/stale-work.ts b/src/lib/stale-work.ts
index c1838377..3af4402b 100644
--- a/src/lib/stale-work.ts
+++ b/src/lib/stale-work.ts
@@ -1,5 +1,6 @@
 import { prisma } from "@/lib/prisma";
 import { releaseIssueClaim, type IssueClaimClient } from "@/lib/issue-claim";
+import { lifecycleDedupeKey } from "@/lib/issue-lifecycle";
 
 export const DEFAULT_STALE_WORK_MAX_AGE_MS = 5 * 60 * 1000;
 export const DEFAULT_STALE_WORK_BATCH_SIZE = 50;
@@ -158,6 +159,13 @@ export async function sweepStaleWork(
             preserveStatus: true,
             source: "stale-recovery",
             actor: "system",
+            // This AgentWork row is this claim epoch, and it is stable across a
+            // retry of the same sweep (the retry re-marks the same STALE row).
+            // Keying the release on it means the release and the
+            // already-released repair a retry has to take are one
+            // `claim_released`, not two. A reclaimed issue gets a new row and
+            // therefore a new key, so a genuine second release still counts.
+            releaseKey: lifecycleDedupeKey("agent-work", work.id),
           },
         });
       }