@hasna/todos 0.15.29 → 0.15.32

package/dist/task-manifest.js

@@ -4873,7 +4873,9 @@ init_types();
 
 // src/task-manifest/types.ts
 var TODOS_TASK_MANIFEST_ROUTE = "todos.task-manifest.v1";
+var TODOS_TASK_MANIFEST_CALLER_ROUTE = "accounts.task-manifest.v1";
 var TODOS_TASK_MANIFEST_SCHEMA_VERSION = 1;
+var TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE = "deterministic-v1";
 function supportsIdempotentOutboxDelivery(capability) {
   return capability !== null && typeof capability === "object" && capability["idempotent_outbox_delivery"] === true;
 }
@@ -4903,6 +4905,8 @@ var TODOS_TASK_MANIFEST_BOUNDS = {
 };
 var key = exports_external.string().min(1).max(96).regex(/^[a-z][a-z0-9_-]*$/);
 var identifier = exports_external.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+var digest = exports_external.string().length(64).regex(/^[0-9a-f]{64}$/);
+var idempotencyKey = exports_external.string().length(52).regex(/^tmk_[0-9a-f]{48}$/);
 var uuid = exports_external.string().uuid();
 var scalar = exports_external.union([exports_external.string().max(4096), exports_external.number().finite(), exports_external.boolean(), exports_external.null()]);
 var boundedScalarRecord = (limit, field) => exports_external.record(exports_external.string().max(200), scalar).superRefine((value, context) => {
@@ -4945,7 +4949,9 @@ var effect = exports_external.object({
 var schema = exports_external.object({
   version: exports_external.literal(1),
   operation_id: identifier,
-  idempotency_key: identifier,
+  step_id: identifier,
+  idempotency_key: idempotencyKey,
+  precondition_digest: digest,
   project_id: uuid,
   task_list_id: uuid.optional(),
   if_binding_version: exports_external.number().int().min(0).optional(),
@@ -4961,7 +4967,10 @@ var schema = exports_external.object({
 }).strict();
 var compensationSchema = exports_external.object({
   receipt_id: uuid,
-  idempotency_key: identifier,
+  operation_id: identifier,
+  step_id: identifier,
+  idempotency_key: idempotencyKey,
+  precondition_digest: digest,
   if_binding_version: exports_external.number().int().min(1).max(Number.MAX_SAFE_INTEGER)
 }).strict();
 var bindingLookupSchema = exports_external.object({
@@ -5046,10 +5055,31 @@ function parseTodosTaskManifestBindingLookup(input) {
 }
 
 // src/task-manifest/plan-slug.ts
+var TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE = "deterministic-v1";
 function taskManifestPlanSlug(manifest, planId) {
   const base = normalizeSlug(manifest.plan.key) || normalizeSlug(manifest.plan.name) || "plan";
   return `${base}-${planId}`;
 }
+function sqliteLegacyTaskManifestPlanSlug(rows, planId, targetBase) {
+  const target = rows.find((row) => row.id === planId);
+  if (!target)
+    return null;
+  const used = new Set;
+  const ordered = [...rows].filter((row) => row.project_id === target.project_id).sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id));
+  for (const row of ordered) {
+    const base = row.id === planId ? normalizeSlug(targetBase ?? row.name) || "plan" : normalizeSlug(row.slug || row.name) || "plan";
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+      candidate = `${base}-${suffix}`;
+      suffix += 1;
+    }
+    if (row.id === planId)
+      return candidate;
+    used.add(candidate);
+  }
+  return null;
+}
 
 // src/task-manifest/backend.ts
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -5063,11 +5093,13 @@ function validateTaskManifestBindingLookupRows(rows, tenantId, planId) {
   const row = rows[0];
   const bindingVersion = Number(row.binding_version);
   const state = row.state;
-  if (row.binding_tenant_id !== tenantId || row.receipt_tenant_id !== tenantId || row.binding_plan_id !== planId || row.receipt_plan_id !== planId || row.receipt_authority !== "todos" || row.receipt_route !== "todos.task-manifest.v1" || Number(row.receipt_schema_version) !== 1 || row.receipt_kind !== "apply" || row.binding_operation_id !== row.receipt_operation_id || typeof row.apply_receipt_id !== "string" || !UUID_PATTERN.test(row.apply_receipt_id) || !Number.isSafeInteger(bindingVersion) || bindingVersion < 1 || state !== "applied" && state !== "compensated") {
+  if (row.binding_tenant_id !== tenantId || row.receipt_tenant_id !== tenantId || row.binding_plan_id !== planId || row.receipt_plan_id !== planId || row.receipt_authority !== "todos" || row.receipt_route !== "todos.task-manifest.v1" || Number(row.receipt_schema_version) !== 1 || row.receipt_kind !== "apply" || row.binding_operation_id !== row.receipt_operation_id || row.binding_step_id !== row.receipt_step_id || typeof row.binding_operation_id !== "string" || typeof row.binding_step_id !== "string" || typeof row.apply_receipt_id !== "string" || !UUID_PATTERN.test(row.apply_receipt_id) || !Number.isSafeInteger(bindingVersion) || bindingVersion < 1 || state !== "applied" && state !== "compensated") {
     throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_LOOKUP_CONFLICT", "Task-manifest binding and immutable apply receipt disagree", { plan_id: planId });
   }
   return {
     plan_id: planId,
+    operation_id: row.binding_operation_id,
+    step_id: row.binding_step_id,
     apply_receipt_id: row.apply_receipt_id,
     binding_version: bindingVersion,
     state
@@ -5175,9 +5207,15 @@ function sqliteTodosTaskManifestSchemaSql() {
       schema_version INTEGER NOT NULL CHECK(schema_version = 1),
       kind TEXT NOT NULL CHECK(kind IN ('apply', 'compensate')),
       operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
       idempotency_key TEXT NOT NULL,
       request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
       result_digest TEXT NOT NULL,
+      slug_provenance TEXT,
+      outcome TEXT NOT NULL CHECK(outcome IN ('accepted', 'terminal_nonacceptance')),
+      reason TEXT,
+      duplicate_of_receipt_id TEXT,
       binding_version INTEGER NOT NULL,
       apply_receipt_id TEXT,
       manifest_json TEXT,
@@ -5188,9 +5226,13 @@ function sqliteTodosTaskManifestSchemaSql() {
     CREATE TABLE IF NOT EXISTS todos_task_manifest_bindings (
       operation_id TEXT PRIMARY KEY,
       tenant_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
       idempotency_key TEXT NOT NULL UNIQUE,
       request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
       result_digest TEXT NOT NULL,
+      slug_provenance TEXT,
+      outcome TEXT NOT NULL CHECK(outcome IN ('accepted', 'terminal_nonacceptance')),
       apply_receipt_id TEXT NOT NULL UNIQUE REFERENCES todos_task_manifest_receipts(receipt_id),
       manifest_json TEXT NOT NULL,
       result_json TEXT NOT NULL,
@@ -5211,6 +5253,27 @@ function sqliteTodosTaskManifestSchemaSql() {
       created_at TEXT NOT NULL,
       delivered_at TEXT
     );
+    CREATE TABLE IF NOT EXISTS todos_task_manifest_terminal_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      authority TEXT NOT NULL CHECK(authority = 'todos'),
+      route TEXT NOT NULL,
+      schema_version INTEGER NOT NULL CHECK(schema_version = 1),
+      kind TEXT NOT NULL CHECK(kind IN ('apply', 'compensate')),
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'terminal_nonacceptance'),
+      reason TEXT NOT NULL,
+      binding_version INTEGER NOT NULL,
+      apply_receipt_id TEXT,
+      manifest_json TEXT,
+      result_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
     CREATE INDEX IF NOT EXISTS idx_todos_task_manifest_outbox_receipt
       ON todos_task_manifest_outbox(apply_receipt_id, status);
     CREATE TRIGGER IF NOT EXISTS todos_task_manifest_receipts_immutable_update
@@ -5221,6 +5284,14 @@ function sqliteTodosTaskManifestSchemaSql() {
       BEFORE DELETE ON todos_task_manifest_receipts BEGIN
         SELECT RAISE(ABORT, 'todos task manifest receipts are immutable');
       END;
+    CREATE TRIGGER IF NOT EXISTS todos_task_manifest_terminal_receipts_immutable_update
+      BEFORE UPDATE ON todos_task_manifest_terminal_receipts BEGIN
+        SELECT RAISE(ABORT, 'todos task manifest terminal receipts are immutable');
+      END;
+    CREATE TRIGGER IF NOT EXISTS todos_task_manifest_terminal_receipts_immutable_delete
+      BEFORE DELETE ON todos_task_manifest_terminal_receipts BEGIN
+        SELECT RAISE(ABORT, 'todos task manifest terminal receipts are immutable');
+      END;
   `;
 }
 function sqliteTableHasColumn(db, tableName, columnName) {
@@ -5237,6 +5308,24 @@ function ensureSqliteTodosTaskManifestSchema(db, tenantId) {
     if (!sqliteTableHasColumn(db, tableName, "tenant_id")) {
       db.exec(`ALTER TABLE "${tableName}" ADD COLUMN tenant_id TEXT NOT NULL DEFAULT ${tenantDefault}`);
     }
+    if (!sqliteTableHasColumn(db, tableName, "slug_provenance")) {
+      db.exec(`ALTER TABLE "${tableName}" ADD COLUMN slug_provenance TEXT`);
+    }
+  }
+  const defaults = [
+    ["todos_task_manifest_receipts", "step_id", "TEXT NOT NULL DEFAULT 'legacy-apply'"],
+    ["todos_task_manifest_receipts", "precondition_digest", `TEXT NOT NULL DEFAULT '${"0".repeat(64)}'`],
+    ["todos_task_manifest_receipts", "outcome", "TEXT NOT NULL DEFAULT 'accepted'"],
+    ["todos_task_manifest_receipts", "reason", "TEXT"],
+    ["todos_task_manifest_receipts", "duplicate_of_receipt_id", "TEXT"],
+    ["todos_task_manifest_bindings", "step_id", "TEXT NOT NULL DEFAULT 'legacy-apply'"],
+    ["todos_task_manifest_bindings", "precondition_digest", `TEXT NOT NULL DEFAULT '${"0".repeat(64)}'`],
+    ["todos_task_manifest_bindings", "outcome", "TEXT NOT NULL DEFAULT 'accepted'"]
+  ];
+  for (const [tableName, columnName, definition] of defaults) {
+    if (!sqliteTableHasColumn(db, tableName, columnName)) {
+      db.exec(`ALTER TABLE "${tableName}" ADD COLUMN "${columnName}" ${definition}`);
+    }
   }
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_todos_task_manifest_receipts_tenant
@@ -5246,6 +5335,12 @@ function ensureSqliteTodosTaskManifestSchema(db, tenantId) {
         tenant_id,
         json_extract(result_json, '$.graph.plan_id')
       );
+    DROP INDEX IF EXISTS idx_todos_task_manifest_terminal_receipts_lookup;
+    DROP INDEX IF EXISTS idx_todos_task_manifest_terminal_receipts_identity;
+    CREATE INDEX IF NOT EXISTS idx_todos_task_manifest_terminal_receipts_lookup
+      ON todos_task_manifest_terminal_receipts(tenant_id, kind, operation_id, step_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_task_manifest_terminal_receipts_identity
+      ON todos_task_manifest_terminal_receipts(tenant_id, kind, operation_id, step_id);
   `);
 }
 function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
@@ -5259,9 +5354,15 @@ function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
       schema_version integer NOT NULL CHECK(schema_version = 1),
       kind text NOT NULL CHECK(kind IN ('apply', 'compensate')),
       operation_id text NOT NULL,
+      step_id text NOT NULL,
       idempotency_key text NOT NULL,
       request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
       result_digest text NOT NULL,
+      slug_provenance text,
+      outcome text NOT NULL CHECK(outcome IN ('accepted', 'terminal_nonacceptance')),
+      reason text,
+      duplicate_of_receipt_id text,
       binding_version integer NOT NULL,
       apply_receipt_id text,
       manifest_json jsonb,
@@ -5273,12 +5374,28 @@ function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
       ADD COLUMN IF NOT EXISTS tenant_id text NOT NULL DEFAULT ${tenantDefault}`,
     `ALTER TABLE todos_task_manifest_receipts
       ALTER COLUMN tenant_id DROP DEFAULT`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS slug_provenance text`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS step_id text NOT NULL DEFAULT 'legacy-apply'`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS precondition_digest text NOT NULL DEFAULT '${"0".repeat(64)}'`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS outcome text NOT NULL DEFAULT 'accepted'`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS reason text`,
+    `ALTER TABLE todos_task_manifest_receipts
+      ADD COLUMN IF NOT EXISTS duplicate_of_receipt_id text`,
     `CREATE TABLE IF NOT EXISTS todos_task_manifest_bindings (
       operation_id text PRIMARY KEY,
       tenant_id text NOT NULL,
+      step_id text NOT NULL,
       idempotency_key text NOT NULL UNIQUE,
       request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
       result_digest text NOT NULL,
+      slug_provenance text,
+      outcome text NOT NULL CHECK(outcome IN ('accepted', 'terminal_nonacceptance')),
       apply_receipt_id text NOT NULL UNIQUE REFERENCES todos_task_manifest_receipts(receipt_id),
       manifest_json jsonb NOT NULL,
       result_json jsonb NOT NULL,
@@ -5292,6 +5409,14 @@ function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
       ADD COLUMN IF NOT EXISTS tenant_id text NOT NULL DEFAULT ${tenantDefault}`,
     `ALTER TABLE todos_task_manifest_bindings
       ALTER COLUMN tenant_id DROP DEFAULT`,
+    `ALTER TABLE todos_task_manifest_bindings
+      ADD COLUMN IF NOT EXISTS slug_provenance text`,
+    `ALTER TABLE todos_task_manifest_bindings
+      ADD COLUMN IF NOT EXISTS step_id text NOT NULL DEFAULT 'legacy-apply'`,
+    `ALTER TABLE todos_task_manifest_bindings
+      ADD COLUMN IF NOT EXISTS precondition_digest text NOT NULL DEFAULT '${"0".repeat(64)}'`,
+    `ALTER TABLE todos_task_manifest_bindings
+      ADD COLUMN IF NOT EXISTS outcome text NOT NULL DEFAULT 'accepted'`,
     `CREATE TABLE IF NOT EXISTS todos_task_manifest_outbox (
       id text PRIMARY KEY,
       apply_receipt_id text NOT NULL REFERENCES todos_task_manifest_receipts(receipt_id),
@@ -5303,10 +5428,37 @@ function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
       created_at timestamptz NOT NULL,
       delivered_at timestamptz
     )`,
+    `CREATE TABLE IF NOT EXISTS todos_task_manifest_terminal_receipts (
+      receipt_id text PRIMARY KEY,
+      tenant_id text NOT NULL,
+      authority text NOT NULL CHECK(authority = 'todos'),
+      route text NOT NULL,
+      schema_version integer NOT NULL CHECK(schema_version = 1),
+      kind text NOT NULL CHECK(kind IN ('apply', 'compensate')),
+      operation_id text NOT NULL,
+      step_id text NOT NULL,
+      idempotency_key text NOT NULL,
+      request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
+      result_digest text NOT NULL,
+      outcome text NOT NULL CHECK(outcome = 'terminal_nonacceptance'),
+      reason text NOT NULL,
+      binding_version integer NOT NULL,
+      apply_receipt_id text,
+      manifest_json jsonb,
+      result_json jsonb NOT NULL,
+      created_at timestamptz NOT NULL
+    )`,
     `CREATE INDEX IF NOT EXISTS todos_task_manifest_outbox_receipt_idx
       ON todos_task_manifest_outbox(apply_receipt_id, status)`,
     `CREATE INDEX IF NOT EXISTS todos_task_manifest_receipts_tenant_idx
       ON todos_task_manifest_receipts(tenant_id, receipt_id, kind)`,
+    `DROP INDEX IF EXISTS todos_task_manifest_terminal_receipts_lookup_idx`,
+    `DROP INDEX IF EXISTS todos_task_manifest_terminal_receipts_identity_idx`,
+    `CREATE INDEX IF NOT EXISTS todos_task_manifest_terminal_receipts_lookup_idx
+      ON todos_task_manifest_terminal_receipts(tenant_id, kind, operation_id, step_id)`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS todos_task_manifest_terminal_receipts_identity_idx
+      ON todos_task_manifest_terminal_receipts(tenant_id, kind, operation_id, step_id)`,
     `CREATE INDEX IF NOT EXISTS todos_task_manifest_bindings_tenant_plan_idx
       ON todos_task_manifest_bindings(
         tenant_id,
@@ -5319,6 +5471,10 @@ function postgresTodosTaskManifestSchemaSql(tenantId = "default") {
     `DROP TRIGGER IF EXISTS todos_task_manifest_receipts_immutable ON todos_task_manifest_receipts`,
     `CREATE TRIGGER todos_task_manifest_receipts_immutable
       BEFORE UPDATE OR DELETE ON todos_task_manifest_receipts
+      FOR EACH ROW EXECUTE FUNCTION todos_task_manifest_receipts_immutable()`,
+    `DROP TRIGGER IF EXISTS todos_task_manifest_terminal_receipts_immutable ON todos_task_manifest_terminal_receipts`,
+    `CREATE TRIGGER todos_task_manifest_terminal_receipts_immutable
+      BEFORE UPDATE OR DELETE ON todos_task_manifest_terminal_receipts
       FOR EACH ROW EXECUTE FUNCTION todos_task_manifest_receipts_immutable()`
   ];
 }
@@ -5330,7 +5486,76 @@ function fault(faults, point) {
     throw new Error(`Injected task-manifest fault at ${point}`);
 }
 function parseApplyResult(value, duplicate) {
-  return { ...JSON.parse(value), duplicate };
+  const parsed = JSON.parse(value);
+  return {
+    ...parsed,
+    duplicate,
+    receipt: {
+      ...parsed.receipt,
+      step_id: parsed.receipt.step_id ?? "legacy-apply",
+      precondition_digest: parsed.receipt.precondition_digest ?? "0".repeat(64),
+      outcome: parsed.receipt.outcome ?? "accepted",
+      reason: parsed.receipt.reason ?? null,
+      duplicate_of_receipt_id: parsed.receipt.duplicate_of_receipt_id ?? null
+    }
+  };
+}
+function terminalApplyResult(input, reason) {
+  const receipt = {
+    receipt_id: input.terminal_receipt_id,
+    authority: "todos",
+    route: "todos.task-manifest.v1",
+    schema_version: 1,
+    kind: "apply",
+    operation_id: input.manifest.operation_id,
+    step_id: input.manifest.step_id,
+    idempotency_key: input.manifest.idempotency_key,
+    request_digest: input.request_digest,
+    precondition_digest: input.manifest.precondition_digest,
+    result_digest: canonicalDigest({
+      outcome: "terminal_nonacceptance",
+      reason,
+      operation_id: input.manifest.operation_id,
+      step_id: input.manifest.step_id,
+      request_digest: input.request_digest
+    }),
+    outcome: "terminal_nonacceptance",
+    reason,
+    duplicate_of_receipt_id: null,
+    binding_version: 0,
+    apply_receipt_id: null,
+    created_at: input.now
+  };
+  return {
+    duplicate: false,
+    receipt,
+    graph: input.graph,
+    readback: { plans: 0, tasks: 0, dependencies: 0, comments: 0, verifications: 0, complete: true },
+    outbox_ids: [],
+    result_digest: receipt.result_digest
+  };
+}
+function validateCompensationPlanSlug(db, manifest, planId, slugProvenance) {
+  const plan = db.query("SELECT id, project_id, name, slug, created_at FROM plans WHERE id = ? LIMIT 1").get(planId);
+  if (!plan) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: plan changed since apply");
+  }
+  if (slugProvenance === TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE) {
+    if (plan.slug !== taskManifestPlanSlug(manifest, planId)) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: plan changed since apply");
+    }
+    return;
+  }
+  if (slugProvenance !== null && slugProvenance !== undefined) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: unknown plan slug provenance");
+  }
+  if (plan.slug === null)
+    return;
+  const rows = db.query("SELECT id, project_id, name, slug, created_at FROM plans WHERE project_id IS ? ORDER BY created_at ASC, id ASC").all(plan.project_id);
+  const expected = sqliteLegacyTaskManifestPlanSlug(rows, planId, manifest.plan.key || manifest.plan.name);
+  if (expected === null || plan.slug !== expected) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: legacy plan slug was not produced by SQLite allocation");
+  }
 }
 
 class SqliteTodosTaskManifestBackend {
@@ -5370,33 +5595,49 @@ class SqliteTodosTaskManifestBackend {
   async apply(input, faults) {
     return this.serialized(() => {
       const { manifest } = input;
+      const terminal = this.db.query(`SELECT result_json
+         FROM todos_task_manifest_terminal_receipts
+         WHERE tenant_id = ?
+           AND kind = 'apply'
+           AND (receipt_id = ? OR (operation_id = ? AND step_id = ?))
+         ORDER BY created_at ASC, receipt_id ASC
+         LIMIT 1`).get(this.tenantId, input.terminal_receipt_id, manifest.operation_id, manifest.step_id);
+      if (terminal)
+        return parseApplyResult(terminal.result_json, true);
       const binding = this.db.query("SELECT * FROM todos_task_manifest_bindings WHERE tenant_id = ? AND operation_id = ? LIMIT 1").get(this.tenantId, manifest.operation_id);
       if (binding) {
-        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest) {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Operation is already bound to a different request");
+        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest || binding["step_id"] !== manifest.step_id || binding["precondition_digest"] !== manifest.precondition_digest) {
+          return this.persistTerminal(input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
+        }
+        if (binding["outcome"] === "terminal_nonacceptance") {
+          const terminalResult = this.persistTerminal(input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
+          return { ...terminalResult, duplicate: true };
         }
         if (binding["state"] !== "applied") {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_GRAPH_CONFLICT", "Operation was already compensated");
+          return this.persistTerminal(input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
         }
         return parseApplyResult(String(binding["result_json"]), true);
       }
       const idempotency = this.db.query("SELECT operation_id, request_digest FROM todos_task_manifest_bindings WHERE tenant_id = ? AND idempotency_key = ? LIMIT 1").get(this.tenantId, manifest.idempotency_key);
       if (idempotency)
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Idempotency key is already used by another operation");
+        return this.persistTerminal(input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
+      if (manifest.idempotency_key !== input.expected_idempotency_key) {
+        return this.persistTerminal(input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_MISMATCH");
+      }
       if (manifest.if_binding_version !== undefined && manifest.if_binding_version !== 0) {
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_CAS_CONFLICT", "New manifest binding version must be 0");
+        return this.persistTerminal(input, "TODOS_TASK_MANIFEST_CAS_CONFLICT");
       }
       if (!this.db.query("SELECT 1 AS found FROM projects WHERE id = ? LIMIT 1").get(manifest.project_id)) {
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Project does not exist");
+        return this.persistTerminal(input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
       }
       if (manifest.task_list_id && !this.db.query("SELECT 1 AS found FROM task_lists WHERE id = ? AND project_id = ? LIMIT 1").get(manifest.task_list_id, manifest.project_id)) {
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Task list does not belong to the project");
+        return this.persistTerminal(input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
       }
       const allIds = [input.graph.plan_id, ...Object.values(input.graph.task_ids), ...input.graph.comment_ids, ...input.graph.verification_ids];
       for (const id of allIds) {
         for (const table of ["plans", "tasks", "task_comments", "task_verifications"]) {
           if (this.db.query(`SELECT 1 AS found FROM ${table} WHERE id = ? LIMIT 1`).get(id)) {
-            throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_GRAPH_CONFLICT", `Deterministic id already exists: ${id}`);
+            return this.persistTerminal(input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
           }
         }
       }
@@ -5452,9 +5693,14 @@ class SqliteTodosTaskManifestBackend {
         schema_version: 1,
         kind: "apply",
         operation_id: manifest.operation_id,
+        step_id: manifest.step_id,
         idempotency_key: manifest.idempotency_key,
         request_digest: input.request_digest,
+        precondition_digest: manifest.precondition_digest,
         result_digest: input.result_digest,
+        outcome: "accepted",
+        reason: null,
+        duplicate_of_receipt_id: null,
         binding_version: 1,
         apply_receipt_id: null,
         created_at: input.now
@@ -5470,9 +5716,10 @@ class SqliteTodosTaskManifestBackend {
       const resultJson = canonicalJson(result);
       const manifestJson = canonicalJson(manifest);
       this.db.query(`INSERT INTO todos_task_manifest_receipts (
-        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, idempotency_key,
-        request_digest, result_digest, binding_version, apply_receipt_id, manifest_json, result_json, created_at
-      ) VALUES (?, ?, 'todos', 'todos.task-manifest.v1', 1, 'apply', ?, ?, ?, ?, 1, NULL, ?, ?, ?)`).run(input.receipt_id, this.tenantId, manifest.operation_id, manifest.idempotency_key, input.request_digest, input.result_digest, manifestJson, resultJson, input.now);
+        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, step_id, idempotency_key,
+        request_digest, precondition_digest, result_digest, slug_provenance, outcome, reason,
+        duplicate_of_receipt_id, binding_version, apply_receipt_id, manifest_json, result_json, created_at
+      ) VALUES (?, ?, 'todos', 'todos.task-manifest.v1', 1, 'apply', ?, ?, ?, ?, ?, ?, ?, 'accepted', NULL, NULL, 1, NULL, ?, ?, ?)`).run(input.receipt_id, this.tenantId, manifest.operation_id, manifest.step_id, manifest.idempotency_key, input.request_digest, manifest.precondition_digest, input.result_digest, TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE, manifestJson, resultJson, input.now);
       for (const entry of input.outbox) {
         this.db.query(`INSERT INTO todos_task_manifest_outbox (
           id, apply_receipt_id, topic, payload, payload_digest, status, created_at
@@ -5480,18 +5727,37 @@ class SqliteTodosTaskManifestBackend {
       }
       fault(faults, "after_outbox_write");
       this.db.query(`INSERT INTO todos_task_manifest_bindings (
-        operation_id, tenant_id, idempotency_key, request_digest, result_digest, apply_receipt_id,
-        manifest_json, result_json, state, version, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'applied', 1, ?, ?)`).run(manifest.operation_id, this.tenantId, manifest.idempotency_key, input.request_digest, input.result_digest, input.receipt_id, manifestJson, resultJson, input.now, input.now);
+        operation_id, tenant_id, step_id, idempotency_key, request_digest, precondition_digest, result_digest,
+        slug_provenance, outcome, apply_receipt_id, manifest_json, result_json, state, version, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'accepted', ?, ?, ?, 'applied', 1, ?, ?)`).run(manifest.operation_id, this.tenantId, manifest.step_id, manifest.idempotency_key, input.request_digest, manifest.precondition_digest, input.result_digest, TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE, input.receipt_id, manifestJson, resultJson, input.now, input.now);
       fault(faults, "after_receipt_write");
       return result;
     });
   }
+  persistTerminal(input, reason) {
+    const result = terminalApplyResult(input, reason);
+    const resultJson = canonicalJson(result);
+    this.db.query(`INSERT OR IGNORE INTO todos_task_manifest_terminal_receipts (
+      receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, step_id,
+      idempotency_key, request_digest, precondition_digest, result_digest, outcome, reason,
+      binding_version, apply_receipt_id, manifest_json, result_json, created_at
+    ) VALUES (?, ?, 'todos', 'todos.task-manifest.v1', 1, 'apply', ?, ?, ?, ?, ?, ?, 'terminal_nonacceptance', ?, 0, NULL, ?, ?, ?)`).run(result.receipt.receipt_id, this.tenantId, input.manifest.operation_id, input.manifest.step_id, input.manifest.idempotency_key, input.request_digest, input.manifest.precondition_digest, result.receipt.result_digest, reason, canonicalJson(input.manifest), resultJson, input.now);
+    const stored = this.db.query(`SELECT receipt_id, result_json
+       FROM todos_task_manifest_terminal_receipts
+       WHERE tenant_id = ? AND kind = 'apply'
+         AND (receipt_id = ? OR (operation_id = ? AND step_id = ?))
+       ORDER BY created_at ASC, receipt_id ASC
+       LIMIT 1`).get(this.tenantId, result.receipt.receipt_id, input.manifest.operation_id, input.manifest.step_id);
+    return stored ? parseApplyResult(stored.result_json, stored.receipt_id !== result.receipt.receipt_id) : result;
+  }
   async readExact(receiptId) {
     const row = this.db.query("SELECT result_json FROM todos_task_manifest_receipts WHERE tenant_id = ? AND receipt_id = ? AND kind = 'apply' LIMIT 1").get(this.tenantId, receiptId);
-    if (!row)
+    if (row)
+      return parseApplyResult(row.result_json, false);
+    const terminal = this.db.query("SELECT result_json FROM todos_task_manifest_terminal_receipts WHERE tenant_id = ? AND receipt_id = ? AND kind = 'apply' LIMIT 1").get(this.tenantId, receiptId);
+    if (!terminal)
       throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_RECEIPT_NOT_FOUND", `Apply receipt not found: ${receiptId}`);
-    return parseApplyResult(row.result_json, false);
+    return parseApplyResult(terminal.result_json, false);
   }
   async lookupBindingByPlanId(planId) {
     const rows = this.db.query(`
@@ -5501,6 +5767,7 @@ class SqliteTodosTaskManifestBackend {
         b.version AS binding_version,
         b.tenant_id AS binding_tenant_id,
         b.operation_id AS binding_operation_id,
+        b.step_id AS binding_step_id,
         json_extract(b.result_json, '$.graph.plan_id') AS binding_plan_id,
         r.tenant_id AS receipt_tenant_id,
         r.authority AS receipt_authority,
@@ -5508,6 +5775,7 @@ class SqliteTodosTaskManifestBackend {
         r.schema_version AS receipt_schema_version,
         r.kind AS receipt_kind,
         r.operation_id AS receipt_operation_id,
+        r.step_id AS receipt_step_id,
         json_extract(r.result_json, '$.graph.plan_id') AS receipt_plan_id
       FROM todos_task_manifest_bindings b
       LEFT JOIN todos_task_manifest_receipts r
@@ -5570,6 +5838,12 @@ class SqliteTodosTaskManifestBackend {
       if (!binding || Number(binding["version"]) !== input.if_binding_version) {
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_CAS_CONFLICT", "Binding version changed before compensation");
       }
+      const storedStepId = String(row["step_id"] ?? "legacy-apply");
+      const storedRequestDigest = String(row["request_digest"]);
+      const storedPreconditionDigest = String(row["precondition_digest"] ?? "0".repeat(64));
+      if (String(row["receipt_id"]) !== input.receipt_id || String(row["operation_id"]) !== input.operation_id || String(binding["operation_id"]) !== String(row["operation_id"]) || String(binding["step_id"] ?? "legacy-apply") !== storedStepId || String(binding["idempotency_key"]) !== String(row["idempotency_key"]) || String(binding["request_digest"]) !== storedRequestDigest || String(binding["precondition_digest"] ?? "0".repeat(64)) !== storedPreconditionDigest || String(binding["apply_receipt_id"]) !== input.receipt_id || binding["slug_provenance"] !== row["slug_provenance"]) {
+        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: receipt and binding identity disagree");
+      }
       if (binding["state"] !== "applied")
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Graph is not in applied state");
       const delivered = this.db.query(`SELECT o.id FROM todos_task_manifest_outbox o
@@ -5580,10 +5854,16 @@ class SqliteTodosTaskManifestBackend {
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: delivered outbox row exists");
       const applyResult = parseApplyResult(String(row["result_json"]), false);
       const manifest = JSON.parse(String(row["manifest_json"]));
+      const manifestRecord = manifest;
+      const applyStepId = typeof manifestRecord["step_id"] === "string" ? String(manifestRecord["step_id"]) : null;
       const expectedEffects = [
         {
           topic: "todos.task-manifest.applied",
-          payload: { operation_id: manifest.operation_id, project_id: manifest.project_id }
+          payload: {
+            operation_id: manifest.operation_id,
+            ...applyStepId ? { step_id: applyStepId } : {},
+            project_id: manifest.project_id
+          }
         },
         ...(manifest.effects ?? []).map((effect2) => ({ topic: effect2.topic, payload: effect2.payload }))
       ];
@@ -5623,8 +5903,10 @@ class SqliteTodosTaskManifestBackend {
       if (canonicalJson(actualReadback) !== canonicalJson(applyResult.readback)) {
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: graph changed since apply", { actualReadback });
       }
-      const plan = this.db.query("SELECT project_id, name, description, status, task_list_id, slug FROM plans WHERE id = ? LIMIT 1").get(applyResult.graph.plan_id);
-      if (!plan || plan["project_id"] !== manifest.project_id || plan["name"] !== manifest.plan.name || plan["description"] !== (manifest.plan.description ?? null) || plan["status"] !== (manifest.plan.status ?? "active") || plan["task_list_id"] !== (manifest.task_list_id ?? null) || plan["slug"] !== taskManifestPlanSlug(manifest, applyResult.graph.plan_id)) {
+      const slugProvenance = row["slug_provenance"];
+      validateCompensationPlanSlug(this.db, manifest, applyResult.graph.plan_id, slugProvenance);
+      const plan = this.db.query("SELECT project_id, name, description, status, task_list_id FROM plans WHERE id = ? LIMIT 1").get(applyResult.graph.plan_id);
+      if (!plan || plan["project_id"] !== manifest.project_id || plan["name"] !== manifest.plan.name || plan["description"] !== (manifest.plan.description ?? null) || plan["status"] !== (manifest.plan.status ?? "active") || plan["task_list_id"] !== (manifest.task_list_id ?? null)) {
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: plan changed since apply");
       }
       for (const task2 of manifest.tasks) {
@@ -5701,9 +5983,10 @@ class SqliteTodosTaskManifestBackend {
       const result = { duplicate: false, receipt, absent: true, readback };
       const resultJson = canonicalJson(result);
       this.db.query(`INSERT INTO todos_task_manifest_receipts (
-        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, idempotency_key,
-        request_digest, result_digest, binding_version, apply_receipt_id, manifest_json, result_json, created_at
-      ) VALUES (?, ?, 'todos', 'todos.task-manifest.v1', 1, 'compensate', ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(compensationReceiptId, this.tenantId, receipt.operation_id, input.idempotency_key, requestDigest, receipt.result_digest, receipt.binding_version, input.receipt_id, resultJson, now);
+        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, step_id, idempotency_key,
+        request_digest, precondition_digest, result_digest, slug_provenance, outcome, reason,
+        duplicate_of_receipt_id, binding_version, apply_receipt_id, manifest_json, result_json, created_at
+      ) VALUES (?, ?, 'todos', 'todos.task-manifest.v1', 1, 'compensate', ?, ?, ?, ?, ?, ?, NULL, 'accepted', NULL, NULL, ?, ?, NULL, ?, ?)`).run(compensationReceiptId, this.tenantId, receipt.operation_id, receipt.step_id, input.idempotency_key, requestDigest, input.precondition_digest, receipt.result_digest, receipt.binding_version, input.receipt_id, resultJson, now);
       const updated = this.db.query(`UPDATE todos_task_manifest_bindings SET state = 'compensated', version = ?, compensation_receipt_id = ?, updated_at = ?
         WHERE tenant_id = ? AND operation_id = ? AND state = 'applied' AND version = ?`).run(receipt.binding_version, compensationReceiptId, now, this.tenantId, receipt.operation_id, input.if_binding_version);
       if (updated.changes !== 1) {
@@ -6141,6 +6424,39 @@ function safeIdentifier(value, field) {
 function parseJson(value) {
   return typeof value === "string" ? JSON.parse(value) : value;
 }
+function parseApplyResult2(value, duplicate) {
+  const parsed = parseJson(value);
+  return {
+    ...parsed,
+    duplicate,
+    receipt: {
+      ...parsed.receipt,
+      step_id: parsed.receipt.step_id ?? "legacy-apply",
+      precondition_digest: parsed.receipt.precondition_digest ?? "0".repeat(64),
+      outcome: parsed.receipt.outcome ?? "accepted",
+      reason: parsed.receipt.reason ?? null,
+      duplicate_of_receipt_id: parsed.receipt.duplicate_of_receipt_id ?? null
+    }
+  };
+}
+function validatePostgresPlanSlug(manifest, planId, slug, provenance) {
+  if (provenance === TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE) {
+    const expected = taskManifestPlanSlug(manifest, planId);
+    if (slug !== expected) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: plan slug changed since apply");
+    }
+    return expected;
+  }
+  if (provenance !== null && provenance !== undefined) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: unknown plan slug provenance");
+  }
+  if (slug === null || slug === undefined)
+    return null;
+  if (slug !== null && slug !== undefined) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: legacy PostgreSQL plan slug must be NULL");
+  }
+  return null;
+}
 function timestamp(value) {
   return value instanceof Date ? value.toISOString() : new Date(String(value)).toISOString();
 }
@@ -6148,6 +6464,41 @@ function fault2(faults, point) {
   if (faults.points.has(point))
     throw new Error(`Injected task-manifest fault at ${point}`);
 }
+function terminalApplyResult2(input, reason) {
+  const receipt = {
+    receipt_id: input.terminal_receipt_id,
+    authority: "todos",
+    route: "todos.task-manifest.v1",
+    schema_version: 1,
+    kind: "apply",
+    operation_id: input.manifest.operation_id,
+    step_id: input.manifest.step_id,
+    idempotency_key: input.manifest.idempotency_key,
+    request_digest: input.request_digest,
+    precondition_digest: input.manifest.precondition_digest,
+    result_digest: canonicalDigest({
+      outcome: "terminal_nonacceptance",
+      reason,
+      operation_id: input.manifest.operation_id,
+      step_id: input.manifest.step_id,
+      request_digest: input.request_digest
+    }),
+    outcome: "terminal_nonacceptance",
+    reason,
+    duplicate_of_receipt_id: null,
+    binding_version: 0,
+    apply_receipt_id: null,
+    created_at: input.now
+  };
+  return {
+    duplicate: false,
+    receipt,
+    graph: input.graph,
+    readback: { plans: 0, tasks: 0, dependencies: 0, comments: 0, verifications: 0, complete: true },
+    outbox_ids: [],
+    result_digest: receipt.result_digest
+  };
+}
 function receiptFromRow(row) {
   return {
     receipt_id: String(row["receipt_id"]),
@@ -6156,9 +6507,14 @@ function receiptFromRow(row) {
     schema_version: 1,
     kind: row["kind"],
     operation_id: String(row["operation_id"]),
+    step_id: String(row["step_id"] ?? "legacy-apply"),
     idempotency_key: String(row["idempotency_key"]),
     request_digest: String(row["request_digest"]),
+    precondition_digest: String(row["precondition_digest"] ?? "0".repeat(64)),
     result_digest: String(row["result_digest"]),
+    outcome: row["outcome"] ?? "accepted",
+    reason: row["reason"] == null ? null : row["reason"],
+    duplicate_of_receipt_id: row["duplicate_of_receipt_id"] == null ? null : String(row["duplicate_of_receipt_id"]),
     binding_version: Number(row["binding_version"]),
     apply_receipt_id: row["apply_receipt_id"] == null ? null : String(row["apply_receipt_id"]),
     created_at: timestamp(row["created_at"])
@@ -6276,46 +6632,89 @@ class PostgresTodosTaskManifestBackend {
       now
     ]);
   }
+  async persistTerminal(tx, input, reason) {
+    const result = terminalApplyResult2(input, reason);
+    const resultJson = canonicalJson(result);
+    await tx.query(`INSERT INTO todos_task_manifest_terminal_receipts (
+      receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, step_id,
+      idempotency_key, request_digest, precondition_digest, result_digest, outcome, reason,
+      binding_version, apply_receipt_id, manifest_json, result_json, created_at
+    ) VALUES ($1, $2, 'todos', 'todos.task-manifest.v1', 1, 'apply', $3, $4, $5, $6, $7, $8,
+      'terminal_nonacceptance', $9, 0, NULL, $10::jsonb, $11::jsonb, $12)
+      ON CONFLICT (tenant_id, kind, operation_id, step_id) DO NOTHING`, [
+      result.receipt.receipt_id,
+      this.tenantId,
+      input.manifest.operation_id,
+      input.manifest.step_id,
+      input.manifest.idempotency_key,
+      input.request_digest,
+      input.manifest.precondition_digest,
+      result.receipt.result_digest,
+      reason,
+      canonicalJson(input.manifest),
+      resultJson,
+      input.now
+    ]);
+    const stored = await tx.query(`SELECT receipt_id, result_json
+       FROM todos_task_manifest_terminal_receipts
+       WHERE tenant_id = $1 AND kind = 'apply'
+         AND (receipt_id = $2 OR (operation_id = $3 AND step_id = $4))
+       ORDER BY created_at ASC, receipt_id ASC
+       LIMIT 1`, [this.tenantId, result.receipt.receipt_id, input.manifest.operation_id, input.manifest.step_id]);
+    return stored.rows[0] ? parseApplyResult2(stored.rows[0]["result_json"], stored.rows[0]["receipt_id"] !== result.receipt.receipt_id) : result;
+  }
   async apply(input, faults) {
     await this.ensureSchema();
     return this.client.transaction(async (tx) => {
       const { manifest } = input;
       await tx.query("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [`${this.service}\x1F${manifest.operation_id}`]);
       await tx.query("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [`${this.service}\x1Fidempotency\x1F${manifest.idempotency_key}`]);
+      const terminal = await tx.query(`SELECT result_json FROM todos_task_manifest_terminal_receipts
+         WHERE tenant_id = $1
+           AND kind = 'apply'
+           AND (receipt_id = $2 OR (operation_id = $3 AND step_id = $4))
+         ORDER BY created_at ASC, receipt_id ASC
+         LIMIT 1`, [this.tenantId, input.terminal_receipt_id, manifest.operation_id, manifest.step_id]);
+      if (terminal.rows[0]) {
+        return parseApplyResult2(terminal.rows[0]["result_json"], true);
+      }
       const existing = await tx.query("SELECT * FROM todos_task_manifest_bindings WHERE tenant_id = $1 AND operation_id = $2 LIMIT 1 FOR UPDATE", [this.tenantId, manifest.operation_id]);
       if (existing.rows[0]) {
         const binding = existing.rows[0];
-        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest) {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Operation is already bound to a different request");
+        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest || binding["step_id"] !== manifest.step_id || binding["precondition_digest"] !== manifest.precondition_digest) {
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
         }
         if (binding["state"] !== "applied") {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_GRAPH_CONFLICT", "Operation was already compensated");
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
         }
-        return { ...parseJson(binding["result_json"]), duplicate: true };
+        return parseApplyResult2(binding["result_json"], true);
       }
       const reused = await tx.query("SELECT operation_id FROM todos_task_manifest_bindings WHERE tenant_id = $1 AND idempotency_key = $2 LIMIT 1", [this.tenantId, manifest.idempotency_key]);
       if (reused.rows[0])
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Idempotency key is already used");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
+      if (manifest.idempotency_key !== input.expected_idempotency_key) {
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_MISMATCH");
+      }
       if (manifest.if_binding_version !== undefined && manifest.if_binding_version !== 0) {
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_CAS_CONFLICT", "New manifest binding version must be 0");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_CAS_CONFLICT");
       }
       const project = await tx.query(`SELECT 1 AS found FROM ${this.tableName}
         WHERE service = $1 AND object_type = 'projects' AND object_id = $2 AND deleted_at IS NULL LIMIT 1`, [this.service, manifest.project_id]);
       if (!project.rows[0])
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Project does not exist");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
       if (manifest.task_list_id) {
         const taskList = await tx.query(`SELECT payload FROM ${this.tableName}
           WHERE service = $1 AND object_type = 'task_lists' AND object_id = $2 AND deleted_at IS NULL LIMIT 1`, [this.service, manifest.task_list_id]);
         const payload = taskList.rows[0] ? parseJson(taskList.rows[0]["payload"]) : null;
         if (!payload || payload["project_id"] !== manifest.project_id) {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Task list does not belong to the project");
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
         }
       }
       const objectIds = [input.graph.plan_id, ...Object.values(input.graph.task_ids), ...input.graph.comment_ids, ...input.graph.verification_ids, ...input.graph.dependency_ids];
       const conflict = await tx.query(`SELECT object_id FROM ${this.tableName}
         WHERE service = $1 AND object_id IN (${placeholders2(2, objectIds.length)}) LIMIT 1`, [this.service, ...objectIds]);
       if (conflict.rows[0])
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_GRAPH_CONFLICT", "A deterministic graph id already exists");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
       await this.insertSync(tx, "plans", input.graph.plan_id, planPayload(input), input.now);
       fault2(faults, "after_plan_write");
       for (const task2 of manifest.tasks) {
@@ -6385,9 +6784,14 @@ class PostgresTodosTaskManifestBackend {
         schema_version: 1,
         kind: "apply",
         operation_id: manifest.operation_id,
+        step_id: manifest.step_id,
         idempotency_key: manifest.idempotency_key,
         request_digest: input.request_digest,
+        precondition_digest: manifest.precondition_digest,
         result_digest: input.result_digest,
+        outcome: "accepted",
+        reason: null,
+        duplicate_of_receipt_id: null,
         binding_version: 1,
         apply_receipt_id: null,
         created_at: input.now
@@ -6404,14 +6808,18 @@ class PostgresTodosTaskManifestBackend {
       const resultJson = canonicalJson(result);
       await tx.query(`INSERT INTO todos_task_manifest_receipts (
         receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, idempotency_key,
-        request_digest, result_digest, binding_version, apply_receipt_id, manifest_json, result_json, created_at
-      ) VALUES ($1, $2, 'todos', 'todos.task-manifest.v1', 1, 'apply', $3, $4, $5, $6, 1, NULL, $7::jsonb, $8::jsonb, $9)`, [
+        step_id, request_digest, precondition_digest, result_digest, slug_provenance, outcome,
+        reason, duplicate_of_receipt_id, binding_version, apply_receipt_id, manifest_json, result_json, created_at
+      ) VALUES ($1, $2, 'todos', 'todos.task-manifest.v1', 1, 'apply', $3, $4, $5, $6, $7, $8, $9, 'accepted', NULL, NULL, 1, NULL, $10::jsonb, $11::jsonb, $12)`, [
         input.receipt_id,
         this.tenantId,
         manifest.operation_id,
         manifest.idempotency_key,
+        manifest.step_id,
         input.request_digest,
+        manifest.precondition_digest,
         input.result_digest,
+        TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE,
         manifestJson,
         resultJson,
         input.now
@@ -6430,14 +6838,18 @@ class PostgresTodosTaskManifestBackend {
       }
       fault2(faults, "after_outbox_write");
       await tx.query(`INSERT INTO todos_task_manifest_bindings (
-        operation_id, tenant_id, idempotency_key, request_digest, result_digest, apply_receipt_id,
-        manifest_json, result_json, state, version, created_at, updated_at
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8::jsonb, 'applied', 1, $9, $9)`, [
+        operation_id, tenant_id, step_id, idempotency_key, request_digest, precondition_digest,
+        result_digest, slug_provenance, outcome, apply_receipt_id, manifest_json, result_json,
+        state, version, created_at, updated_at
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'accepted', $9, $10::jsonb, $11::jsonb, 'applied', 1, $12, $12)`, [
         manifest.operation_id,
         this.tenantId,
+        manifest.step_id,
         manifest.idempotency_key,
         input.request_digest,
+        manifest.precondition_digest,
         input.result_digest,
+        TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE,
         input.receipt_id,
         manifestJson,
         resultJson,
@@ -6450,9 +6862,12 @@ class PostgresTodosTaskManifestBackend {
   async readExact(receiptId) {
     await this.ensureSchema();
     const result = await this.client.query("SELECT result_json FROM todos_task_manifest_receipts WHERE tenant_id = $1 AND receipt_id = $2 AND kind = 'apply' LIMIT 1", [this.tenantId, receiptId]);
-    if (!result.rows[0])
+    if (result.rows[0])
+      return parseApplyResult2(result.rows[0]["result_json"], false);
+    const terminal = await this.client.query("SELECT result_json FROM todos_task_manifest_terminal_receipts WHERE tenant_id = $1 AND receipt_id = $2 AND kind = 'apply' LIMIT 1", [this.tenantId, receiptId]);
+    if (!terminal.rows[0])
       throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_RECEIPT_NOT_FOUND", `Apply receipt not found: ${receiptId}`);
-    return { ...parseJson(result.rows[0]["result_json"]), duplicate: false };
+    return parseApplyResult2(terminal.rows[0]["result_json"], false);
   }
   async lookupBindingByPlanId(planId) {
     await this.ensureSchema();
@@ -6463,6 +6878,7 @@ class PostgresTodosTaskManifestBackend {
         b.version AS binding_version,
         b.tenant_id AS binding_tenant_id,
         b.operation_id AS binding_operation_id,
+        b.step_id AS binding_step_id,
         b.result_json #>> '{graph,plan_id}' AS binding_plan_id,
         r.tenant_id AS receipt_tenant_id,
         r.authority AS receipt_authority,
@@ -6470,6 +6886,7 @@ class PostgresTodosTaskManifestBackend {
         r.schema_version AS receipt_schema_version,
         r.kind AS receipt_kind,
         r.operation_id AS receipt_operation_id,
+        r.step_id AS receipt_step_id,
         r.result_json #>> '{graph,plan_id}' AS receipt_plan_id
       FROM todos_task_manifest_bindings b
       LEFT JOIN todos_task_manifest_receipts r
@@ -6556,6 +6973,10 @@ class PostgresTodosTaskManifestBackend {
       if (!binding || Number(binding["version"]) !== input.if_binding_version) {
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_CAS_CONFLICT", "Binding version changed before compensation");
       }
+      const appliedReceipt = receiptFromRow(applyRow);
+      if (appliedReceipt.receipt_id !== input.receipt_id || appliedReceipt.operation_id !== input.operation_id || String(binding["operation_id"]) !== appliedReceipt.operation_id || String(binding["step_id"] ?? "legacy-apply") !== appliedReceipt.step_id || String(binding["idempotency_key"]) !== appliedReceipt.idempotency_key || String(binding["request_digest"]) !== appliedReceipt.request_digest || String(binding["precondition_digest"] ?? "0".repeat(64)) !== appliedReceipt.precondition_digest || String(binding["apply_receipt_id"]) !== input.receipt_id || binding["slug_provenance"] !== applyRow["slug_provenance"]) {
+        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: receipt and binding identity disagree");
+      }
       if (binding["state"] !== "applied")
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Graph is not applied");
       const delivered = await tx.query(`SELECT o.id FROM todos_task_manifest_outbox o
@@ -6570,12 +6991,18 @@ class PostgresTodosTaskManifestBackend {
          LIMIT 1`, [this.tenantId, input.receipt_id]);
       if (delivered.rows[0])
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: delivered outbox row exists");
-      const applyResult = parseJson(applyRow["result_json"]);
+      const applyResult = parseApplyResult2(applyRow["result_json"], false);
       const manifest = parseJson(applyRow["manifest_json"]);
+      const manifestRecord = manifest;
+      const applyStepId = typeof manifestRecord["step_id"] === "string" ? String(manifestRecord["step_id"]) : null;
       const expectedEffects = [
         {
           topic: "todos.task-manifest.applied",
-          payload: { operation_id: manifest.operation_id, project_id: manifest.project_id }
+          payload: {
+            operation_id: manifest.operation_id,
+            ...applyStepId ? { step_id: applyStepId } : {},
+            project_id: manifest.project_id
+          }
         },
         ...(manifest.effects ?? []).map((effect2) => ({ topic: effect2.topic, payload: effect2.payload }))
       ];
@@ -6623,9 +7050,15 @@ class PostgresTodosTaskManifestBackend {
       }
       const appliedAt = receiptFromRow(applyRow).created_at;
       const expectedPayloads = new Map;
+      const planRow = await tx.query(`SELECT payload FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'plans' AND object_id = $2
+         LIMIT 1`, [this.service, applyResult.graph.plan_id]);
+      const actualPlan = planRow.rows[0] ? parseJson(planRow.rows[0]["payload"]) : null;
+      const planExpected = planPayload({ manifest, graph: applyResult.graph, now: appliedAt });
+      planExpected.slug = validatePostgresPlanSlug(manifest, applyResult.graph.plan_id, actualPlan?.["slug"], applyRow["slug_provenance"]);
       expectedPayloads.set(applyResult.graph.plan_id, {
         type: "plans",
-        payload: canonicalJson(planPayload({ manifest, graph: applyResult.graph, now: appliedAt }))
+        payload: canonicalJson(planExpected)
       });
       for (const task2 of manifest.tasks)
         expectedPayloads.set(applyResult.graph.task_ids[task2.key], {
@@ -6725,14 +7158,17 @@ class PostgresTodosTaskManifestBackend {
       const readback = await this.readback(tx, applyResult.graph);
       const result = { duplicate: false, receipt, absent: true, readback };
       await tx.query(`INSERT INTO todos_task_manifest_receipts (
-        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, idempotency_key,
-        request_digest, result_digest, binding_version, apply_receipt_id, manifest_json, result_json, created_at
-      ) VALUES ($1, $2, 'todos', 'todos.task-manifest.v1', 1, 'compensate', $3, $4, $5, $6, $7, $8, NULL, $9::jsonb, $10)`, [
+        receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, step_id, idempotency_key,
+        request_digest, precondition_digest, result_digest, slug_provenance, outcome, reason,
+        duplicate_of_receipt_id, binding_version, apply_receipt_id, manifest_json, result_json, created_at
+      ) VALUES ($1, $2, 'todos', 'todos.task-manifest.v1', 1, 'compensate', $3, $4, $5, $6, $7, $8, NULL, 'accepted', NULL, NULL, $9, $10, NULL, $11::jsonb, $12)`, [
         compensationReceiptId,
         this.tenantId,
         receipt.operation_id,
+        receipt.step_id,
         input.idempotency_key,
         requestDigest,
+        input.precondition_digest,
         receipt.result_digest,
         receipt.binding_version,
         input.receipt_id,
@@ -6792,36 +7228,83 @@ function resolveTenantId(value) {
   }
   return tenantId;
 }
+function taskManifestRequestDigest(manifest) {
+  const { idempotency_key: _idempotencyKey, ...request } = manifest;
+  return canonicalDigest(request);
+}
+function taskManifestCompensationRequestDigest(request) {
+  return canonicalDigest(request);
+}
+function deriveTodosTaskManifestApplyPreconditionDigest(input) {
+  return canonicalDigest({
+    route: TODOS_TASK_MANIFEST_CALLER_ROUTE,
+    direction: "apply",
+    operation_id: input.operation_id,
+    step_id: input.step_id,
+    project_id: input.project_id,
+    task_list_id: input.task_list_id ?? null,
+    expected_binding_version: input.if_binding_version ?? 0
+  });
+}
+function deriveTodosTaskManifestCompensationPreconditionDigest(input) {
+  return canonicalDigest({
+    route: TODOS_TASK_MANIFEST_CALLER_ROUTE,
+    direction: "compensate",
+    operation_id: input.operation_id,
+    step_id: input.step_id,
+    apply_receipt_id: input.receipt_id,
+    expected_binding_version: input.if_binding_version
+  });
+}
+function deriveTodosTaskManifestIdempotencyKey(input) {
+  return `tmk_${canonicalDigest({
+    route: TODOS_TASK_MANIFEST_CALLER_ROUTE,
+    ...input
+  }).slice(0, 48)}`;
+}
 function normalize(input, now) {
   const parsed = parseTodosTaskManifest(input);
   const requestBytes = Buffer.byteLength(canonicalJson(parsed), "utf8");
   if (requestBytes > TODOS_TASK_MANIFEST_BOUNDS.request_bytes) {
     throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_BOUNDS_EXCEEDED", `Task manifest requires ${requestBytes} bytes but the bound is ${TODOS_TASK_MANIFEST_BOUNDS.request_bytes}`, { request_bytes: requestBytes, request_byte_limit: TODOS_TASK_MANIFEST_BOUNDS.request_bytes });
   }
+  const { idempotency_key: _idempotencyKey, ...request } = parsed;
+  const request_digest = taskManifestRequestDigest(request);
   const manifest = sanitizeManifest(parsed);
+  const expectedPreconditionDigest = deriveTodosTaskManifestApplyPreconditionDigest(manifest);
+  if (manifest.precondition_digest !== expectedPreconditionDigest) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_DIGEST_MISMATCH", "precondition_digest does not match the exact apply target and binding version", { expected_precondition_digest: expectedPreconditionDigest });
+  }
+  const expectedIdempotencyKey = deriveTodosTaskManifestIdempotencyKey({
+    operation_id: manifest.operation_id,
+    step_id: manifest.step_id,
+    direction: "apply",
+    target_selector: manifest.project_id,
+    request_digest,
+    precondition_digest: manifest.precondition_digest
+  });
   const task_ids = Object.fromEntries(manifest.tasks.map((task2) => [
     task2.key,
-    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "task", task2.key)
+    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "task", task2.key)
   ]));
   const graph = {
-    plan_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "plan", manifest.plan.key),
+    plan_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "plan", manifest.plan.key),
     task_ids,
-    comment_ids: manifest.tasks.flatMap((task2) => (task2.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "comment", task2.key, String(index)))),
-    verification_ids: manifest.tasks.flatMap((task2) => (task2.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "verification", task2.key, String(index)))),
+    comment_ids: manifest.tasks.flatMap((task2) => (task2.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "comment", task2.key, String(index)))),
+    verification_ids: manifest.tasks.flatMap((task2) => (task2.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "verification", task2.key, String(index)))),
     dependency_ids: (manifest.dependencies ?? []).map((edge) => `${task_ids[edge.task]}::${task_ids[edge.depends_on]}`)
   };
-  const request_digest = canonicalDigest(parsed);
   const effectInputs = [
     {
       topic: "todos.task-manifest.applied",
-      payload: { operation_id: manifest.operation_id, project_id: manifest.project_id }
+      payload: { operation_id: manifest.operation_id, step_id: manifest.step_id, project_id: manifest.project_id }
     },
     ...manifest.effects ?? []
   ];
   const outbox = effectInputs.map((effect2, index) => {
     const payload = { ...effect2.payload };
     return {
-      id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "outbox", String(index)),
+      id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "outbox", String(index)),
       topic: effect2.topic,
       payload,
       digest: canonicalDigest({ topic: effect2.topic, payload })
@@ -6831,11 +7314,14 @@ function normalize(input, now) {
   return {
     manifest,
     request_digest,
+    expected_idempotency_key: expectedIdempotencyKey,
     result_digest,
-    receipt_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, "apply", manifest.operation_id, manifest.idempotency_key, request_digest),
+    receipt_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, "apply", manifest.operation_id, manifest.step_id, manifest.idempotency_key, request_digest),
+    terminal_receipt_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, "terminal", "apply", manifest.operation_id, manifest.step_id, manifest.idempotency_key, request_digest),
     graph,
     outbox,
-    now
+    now,
+    plan_slug_provenance: TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE
   };
 }
 function sanitizeManifest(manifest) {
@@ -6893,6 +7379,10 @@ class PackageOwnedTodosTaskManifestAuthority {
       tenant_id: this.tenantId,
       backend: this.backend.kind,
       deterministic_ids: true,
+      operation_step_identity: true,
+      deterministic_idempotency_keys: true,
+      terminal_nonacceptance_receipts: true,
+      plan_slug_provenance: TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE,
       immutable_receipts: true,
       transactional_outbox: true,
       idempotent_outbox_delivery: true,
@@ -6922,7 +7412,11 @@ class PackageOwnedTodosTaskManifestAuthority {
   async apply(input) {
     const normalized = normalize(input, this.now());
     const faults = await this.prepareFaults();
-    return this.bounded(await this.backend.apply(normalized, faults));
+    const result = this.bounded(await this.backend.apply(normalized, faults));
+    if (result.receipt.outcome === "terminal_nonacceptance") {
+      throw new TodosTaskManifestError(result.receipt.reason ?? "TODOS_TASK_MANIFEST_GRAPH_CONFLICT", "Task-manifest apply reached an immutable terminal nonacceptance", { receipt: result.receipt });
+    }
+    return result;
   }
   readExact(receiptId) {
     if (!receiptId || receiptId.length > 200) {
@@ -6955,18 +7449,48 @@ class PackageOwnedTodosTaskManifestAuthority {
   async compensate(input) {
     const request = parseTodosTaskManifestCompensation(input);
     const applied = await this.backend.readExact(request.receipt_id);
-    const requestDigest = canonicalDigest(request);
-    const compensationReceiptId = deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, "compensate", applied.receipt.operation_id, request.idempotency_key, requestDigest);
+    if (applied.receipt.outcome !== "accepted") {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: apply receipt is terminal nonacceptance");
+    }
+    if (request.operation_id !== applied.receipt.operation_id) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Compensation operation_id must match the accepted apply operation");
+    }
+    if (request.step_id === applied.receipt.step_id) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_INVALID_INPUT", "Compensation must use a distinct step_id from apply");
+    }
+    const expectedPreconditionDigest = deriveTodosTaskManifestCompensationPreconditionDigest(request);
+    if (request.precondition_digest !== expectedPreconditionDigest) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_DIGEST_MISMATCH", "precondition_digest does not match the exact compensation receipt and binding version", { expected_precondition_digest: expectedPreconditionDigest });
+    }
+    const { idempotency_key: _requestIdempotencyKey, ...compensationRequestWithoutKey } = request;
+    const requestDigest = taskManifestCompensationRequestDigest(compensationRequestWithoutKey);
+    const expectedIdempotencyKey = deriveTodosTaskManifestIdempotencyKey({
+      operation_id: request.operation_id,
+      step_id: request.step_id,
+      direction: "compensate",
+      target_selector: request.receipt_id,
+      request_digest: requestDigest,
+      precondition_digest: request.precondition_digest
+    });
+    if (request.idempotency_key !== expectedIdempotencyKey) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_MISMATCH", "idempotency_key does not match the deterministic operation/step/compensation semantics", { expected_idempotency_key: expectedIdempotencyKey });
+    }
+    const compensationReceiptId = deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, "compensate", request.operation_id, request.step_id, request.idempotency_key, requestDigest);
     const receipt = {
       receipt_id: compensationReceiptId,
       authority: "todos",
       route: TODOS_TASK_MANIFEST_ROUTE,
       schema_version: 1,
       kind: "compensate",
-      operation_id: applied.receipt.operation_id,
+      operation_id: request.operation_id,
+      step_id: request.step_id,
       idempotency_key: request.idempotency_key,
       request_digest: requestDigest,
+      precondition_digest: request.precondition_digest,
       result_digest: canonicalDigest({ absent: true, apply_receipt_id: applied.receipt.receipt_id }),
+      outcome: "accepted",
+      reason: null,
+      duplicate_of_receipt_id: null,
       binding_version: request.if_binding_version + 1,
       apply_receipt_id: applied.receipt.receipt_id,
       created_at: this.now()
@@ -7148,6 +7672,8 @@ function createTodosTaskManifestHttpClient(options) {
   return new TodosTaskManifestHttpClient(options);
 }
 export {
+  taskManifestRequestDigest,
+  taskManifestCompensationRequestDigest,
   supportsIdempotentOutboxDelivery,
   sqliteTodosTaskManifestSchemaSql,
   postgresTodosTaskManifestSchemaSql,
@@ -7157,6 +7683,9 @@ export {
   handleTodosTaskManifestHttpRequest,
   canonicalDigest as digestTodosTaskManifest,
   deterministicUuid as deterministicTodosTaskManifestId,
+  deriveTodosTaskManifestIdempotencyKey,
+  deriveTodosTaskManifestCompensationPreconditionDigest,
+  deriveTodosTaskManifestApplyPreconditionDigest,
   createTodosTaskManifestHttpClient,
   createSqliteTodosTaskManifestAuthority,
   createPostgresTodosTaskManifestAuthority,
@@ -7165,6 +7694,8 @@ export {
   TodosTaskManifestError,
   TODOS_TASK_MANIFEST_SCHEMA_VERSION,
   TODOS_TASK_MANIFEST_ROUTE,
+  TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE,
+  TODOS_TASK_MANIFEST_CALLER_ROUTE,
   TODOS_TASK_MANIFEST_BOUNDS,
   SqliteTodosTaskManifestBackend,
   PostgresTodosTaskManifestBackend,