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..75e8a00a
--- /dev/null
+++ b/docs/issue-lifecycle-events.md
@@ -0,0 +1,172 @@
+# 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 — 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` |
+
+`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` (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` |
+| 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. 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
+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. 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
+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.
+- **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
+
+`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.
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..e51c2231 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,122 @@ 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 — 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);
+    expect(mocks.updateIssue).toHaveBeenCalled();
+    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"]);
+
+    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..7ab78391 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,37 @@ 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,
+          // 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,
+        });
       });
 
       // 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..a670692a 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,79 @@ 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();
+  });
+
+  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 b9d7b3ad..21fe4bf7 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,40 @@ 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,
+          // 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,
+        });
       });
 
       // Write audit log
@@ -172,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/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..d1b2d505 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,143 @@ 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();
+  });
+
+  // `.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 18618aeb..ac86214a 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();
@@ -150,20 +173,69 @@ 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 } },
       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..a3bb551b 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,133 @@ 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 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,
+      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 () => {
+    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..4a46f2ea 100644
--- a/src/lib/groomer/run.ts
+++ b/src/lib/groomer/run.ts
@@ -28,6 +28,12 @@ import { createGroomingRunRecord, completeGroomingRunRecord, updateGroomingRunRe
 import { explorationCallsForFreshness } from "./freshness";
 import { freshnessBaselineIssueData } from "./freshness-invalidation";
 import { compareCommits, searchRepositoryCode } from "@/lib/github-code-search";
+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 {
@@ -1221,6 +1227,64 @@ 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. 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,
+        repoFullName: candidate.repoFullName,
+        issueNumber: candidate.number,
+        kind: "status_changed",
+        source: "hosted-groomer",
+        actor: "hosted-groomer",
+        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/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..35ac3609 100644
--- a/src/lib/issue-claim.test.ts
+++ b/src/lib/issue-claim.test.ts
@@ -407,3 +407,210 @@ 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();
+  });
+});
+
+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 41d06f82..20167a4c 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,18 @@ 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;
+  /**
+   * 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 {
@@ -32,6 +52,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 +69,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 +87,57 @@ 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,
+  });
+
+  // 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.
@@ -78,10 +163,18 @@ 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,
+        releaseDedupeKey ??
+          lifecycleDedupeKey("claim-released", issue.id, agentLabel, "already-released"),
+      ),
+    );
     return {
       released: true,
       labels: cacheLabels,
@@ -101,10 +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 prisma.issue.update({
-      where: { id: issue.id },
-      data: { labels: cacheLabels, lastSyncedAt: new Date() },
-    });
+    await commitRelease(cacheLabels, releaseEvent(issue.labels, cacheLabels, releaseDedupeKey ?? undefined));
     return {
       released: true,
       labels: cacheLabels,
@@ -158,10 +248,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..9f3f79d2
--- /dev/null
+++ b/src/lib/issue-lifecycle.test.ts
@@ -0,0 +1,502 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  lifecycleDedupeKey,
+  lifecycleStatusLabel,
+  lifecycleStatusTransition,
+  recordClaimEvent,
+  recordLifecycleEvent,
+  recordLifecycleEventQuietly,
+  recordStatusTransition,
+  recordStatusTransitionQuietly,
+  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",
+    });
+  });
+
+  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", () => {
+  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);
+  });
+
+  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", () => {
+  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("propagates a failed event write so the caller can defer its mirror", async () => {
+    const { client } = makeClient();
+    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 },
+      }),
+    ).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"));
+  });
+});
+
+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..fca2d984
--- /dev/null
+++ b/src/lib/issue-lifecycle.ts
@@ -0,0 +1,504 @@
+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[];
+  /**
+   * 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;
+  observedAt?: Date;
+  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
+ * 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 resolved = resolveBeforeState(input, lifecycleStatusTransition);
+  if (!resolved) 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: resolved.change.from,
+    toStatus: resolved.change.to,
+    sourceEventId: input.sourceEventId ?? null,
+    dedupeKey: input.dedupeKey ?? null,
+    occurredAt: input.occurredAt,
+    observedAt: input.observedAt,
+    metadata: resolved.recoveredFromMirroredState
+      ? { ...input.metadata, recoveredFromMirroredState: true }
+      : 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 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,
+    repoFullName: input.repoFullName,
+    issueNumber: input.issueNumber,
+    kind: "claim",
+    source: input.source,
+    actor: input.actor,
+    agentName: input.agentName ?? null,
+    fromStatus: lifecycleStatusLabel(resolved.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" }),
+      ...(resolved.recoveredFromMirroredState ? { recoveredFromMirroredState: true } : null),
+    },
+  });
+  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.
+ *
+ * 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,
+  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 recordLifecycleEvent(client, write);
+  }
+}
+
+/**
+ * Record an event without letting a lifecycle failure abort the writer.
+ *
+ * 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,
+  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}`,
+    );
+  }
+}
+
+/**
+ * `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 e0da5166..4bf9683e 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,27 @@ 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,
+  makePrismaReconcileIssueStore,
   defaultCurrentLane,
   currentLaneForLabels,
   SYNC_OVERLAP_BUFFER_MS,
@@ -204,7 +219,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 +246,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 +624,205 @@ 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("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 expect(
+      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);
+  });
+});
+
+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 25ceb015..d27de447 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,17 +457,55 @@ 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) {
+      const repoFullName = repoByIssueId.get(id);
+      repoByIssueId.delete(id);
+
+      // 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) {
@@ -490,6 +557,47 @@ 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) {
+      // 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 },
+          });
+        }
+      }
+
+      await prisma.issue.update({ where: { id }, data });
+    },
+  };
+}
+
 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.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 80655f6f..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;
@@ -143,13 +144,29 @@ 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",
+            // 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),
+          },
         });
       }