@hasna/todos 0.15.29 → 0.15.32

package/dist/index.js

@@ -7917,6 +7917,46 @@ function guardPlanRowsSqlite(planIds, db) {
   }
 }
 
+// src/lib/task-parent-integrity.ts
+function parentCycleError(taskId, parentId) {
+  return new ResourceConflictError("TASK_PARENT_CYCLE", `TASK_PARENT_CYCLE: assigning parent ${parentId} to task ${taskId} would create or retain a parent cycle`);
+}
+function assertTaskParentIntegrity(taskId, parentId, getTask) {
+  if (parentId === undefined || parentId === null)
+    return;
+  const visited = new Set;
+  let cursor = parentId;
+  while (cursor) {
+    if (cursor === taskId || visited.has(cursor)) {
+      throw parentCycleError(taskId, parentId);
+    }
+    visited.add(cursor);
+    const parent = getTask(cursor);
+    if (!parent)
+      throw new TaskNotFoundError(cursor);
+    cursor = parent.parent_id;
+  }
+}
+async function assertTaskParentIntegrityAsync(taskId, parentId, getTask) {
+  if (parentId === undefined || parentId === null)
+    return;
+  const visited = new Set;
+  let cursor = parentId;
+  while (cursor) {
+    if (cursor === taskId || visited.has(cursor)) {
+      throw parentCycleError(taskId, parentId);
+    }
+    visited.add(cursor);
+    const parent = await getTask(cursor);
+    if (!parent)
+      throw new TaskNotFoundError(cursor);
+    cursor = parent.parent_id;
+  }
+}
+var init_task_parent_integrity = __esm(() => {
+  init_types();
+});
+
 // src/lib/creator-identity.ts
 function canonicalAgentRef(value) {
   return value.trim().toLowerCase();
@@ -9440,6 +9480,7 @@ function createTaskStored(input, d) {
   let id = uuid();
   for (let attempt = 0;attempt < 3; attempt++) {
     try {
+      assertTaskParentIntegrity(id, input.parent_id, (candidateId) => getTask(candidateId, d));
       d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, sla_minutes, confidence, retry_count, max_retries, retry_after, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, created_by, assigned_from_project, task_type, machine_id)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         id,
@@ -9818,6 +9859,7 @@ function updateTaskStored(id, input, db) {
     throw new VersionConflictError(id, input.version, task.version);
   }
   input = sanitizeUpdateTaskInput(input);
+  assertTaskParentIntegrity(id, input.parent_id, (candidateId) => getTask(candidateId, d));
   const effectivePlanId = input.plan_id !== undefined ? input.plan_id : task.plan_id;
   const linkedProjectId = linkedPlanProjectId(effectivePlanId, d);
   if (linkedProjectId) {
@@ -9871,6 +9913,10 @@ function updateTaskStored(id, input, db) {
     sets.push("project_id = ?");
     params.push(input.project_id);
   }
+  if (input.parent_id !== undefined) {
+    sets.push("parent_id = ?");
+    params.push(input.parent_id);
+  }
   if (input.assigned_to !== undefined) {
     sets.push("assigned_to = ?");
     params.push(input.assigned_to);
@@ -9986,6 +10032,8 @@ function updateTaskStored(id, input, db) {
     logTaskChange(id, "update", "priority", task.priority, input.priority, agentId, d);
   if (input.title !== undefined && input.title !== task.title)
     logTaskChange(id, "update", "title", task.title, input.title, agentId, d);
+  if (input.parent_id !== undefined && input.parent_id !== task.parent_id)
+    logTaskChange(id, "update", "parent_id", task.parent_id, input.parent_id, agentId, d);
   if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to)
     logTaskChange(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
   if (input.working_dir !== undefined && input.working_dir !== task.working_dir)
@@ -10043,7 +10091,8 @@ function updateTask(id, input, db) {
   if (!before)
     throw new TaskNotFoundError(id);
   const guardedPlanIds = [before.plan_id, input.plan_id];
-  if (!guardedPlanIds.some(Boolean))
+  const needsSerializedWrite = input.parent_id !== undefined || guardedPlanIds.some(Boolean);
+  if (!needsSerializedWrite)
     return updateTaskStored(id, input, d);
   return d.transaction(() => {
     guardPlanRowsSqlite(guardedPlanIds, d);
@@ -10079,6 +10128,7 @@ var init_task_crud = __esm(() => {
   init_checklists();
   init_storage_tombstones();
   init_prewrite_secrets();
+  init_task_parent_integrity();
 });
 
 // src/db/task-status.ts
@@ -12783,7 +12833,7 @@ var init_dispatches = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.15.29",
+  version: "0.15.32",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -27505,6 +27555,7 @@ function assertSafeIdentifier(value) {
 
 // src/storage/postgres-adapter.ts
 init_redaction();
+init_task_parent_integrity();
 
 // src/task-manifest/canonical.ts
 import { createHash as createHash11 } from "crypto";
@@ -27548,8 +27599,8 @@ function createPostgresTodosStorageAdapter(options) {
       resolveRef: (ref) => store.resolveTaskRef(ref),
       list: (filter = {}) => store.listTasks(filter),
       count: (filter = {}) => store.countTasks(filter),
-      update: (id, input) => updateTask2(id, input, store),
-      delete: (id, context) => store.delete("tasks", id, context),
+      update: (id, input, context) => updateTask2(id, input, store, context),
+      delete: (id, context) => store.deleteTaskHierarchy(id, context),
       start: (id, agentId) => startTask2(id, agentId, store),
       complete: (id, agentId, options2) => completeTask2(id, agentId, options2, store),
       fail: (id, agentId, reason, options2) => failTask2(id, agentId, reason, options2, store),
@@ -28082,22 +28133,70 @@ class PostgresJsonRecordStore {
       return "identical";
     throw new Error(divergentAuditHistoryReplayError(value.id));
   }
-  async upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context = {}) {
+  async withTaskParentIntegrityTransaction(fn) {
+    if (typeof this.options.client.transaction !== "function") {
+      throw new Error("TASK_PARENT_ATOMICITY_UNAVAILABLE: PostgreSQL parent writes and task deletion require transaction(callback)");
+    }
+    return this.options.client.transaction(async (client) => {
+      await client.query("/* todos:task-parent-integrity-lock */ SELECT pg_advisory_xact_lock(hashtextextended($1 || ':task-parent-integrity', 0))", [this.service]);
+      return fn(client);
+    });
+  }
+  async upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context = {}, parentGuard, queryClient) {
     const planIds = [...new Set(guardedPlanIds.filter(Boolean))].sort();
-    if (planIds.length === 0)
+    if (planIds.length === 0 && !parentGuard)
       return this.upsert("tasks", value, context);
     await this.ensureSchema();
+    if (parentGuard && !queryClient) {
+      return this.withTaskParentIntegrityTransaction((client2) => this.upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context, parentGuard, client2));
+    }
+    const client = queryClient ?? this.options.client;
     const updatedAt = value.updated_at;
     const targetPlanId = value.plan_id;
-    const result = await this.options.client.query(`/* todos:task-plan-membership-guard */ WITH
+    const result = await client.query(`/* todos:task-plan-membership-guard todos:task-parent-integrity-guard */ WITH RECURSIVE
+       locked_task AS MATERIALIZED (
+         SELECT payload FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'tasks' AND object_id = $2 AND deleted_at IS NULL
+         FOR UPDATE
+       ),
        locked_plans AS MATERIALIZED (
          SELECT object_id, payload FROM ${this.tableName}
          WHERE service = $1 AND object_type = 'plans' AND deleted_at IS NULL
            AND object_id IN (SELECT value FROM jsonb_array_elements_text($7::jsonb))
          ORDER BY object_id
          FOR UPDATE
+       ), parent_chain(object_id, payload, path, cycle) AS (
+         SELECT parent.object_id, parent.payload, ARRAY[parent.object_id], false
+         FROM ${this.tableName} AS parent
+         WHERE $10::boolean
+           AND $11::text IS NOT NULL
+           AND parent.service = $1
+           AND parent.object_type = 'tasks'
+           AND parent.object_id = $11
+           AND parent.deleted_at IS NULL
+         UNION ALL
+         SELECT ancestor.object_id,
+                ancestor.payload,
+                chain.path || ancestor.object_id,
+                ancestor.object_id = ANY(chain.path)
+         FROM parent_chain AS chain
+         JOIN ${this.tableName} AS ancestor
+           ON ancestor.service = $1
+          AND ancestor.object_type = 'tasks'
+          AND ancestor.object_id = chain.payload->>'parent_id'
+          AND ancestor.deleted_at IS NULL
+         WHERE NOT chain.cycle
        ), validation AS (
          SELECT
+           (NOT $10::boolean OR NOT $13::boolean OR EXISTS (SELECT 1 FROM locked_task)) AS task_found,
+           (NOT $10::boolean OR NOT $13::boolean
+             OR (SELECT (payload->>'version')::integer FROM locked_task) = $12::integer) AS version_matches,
+           (NOT $10::boolean OR $11::text IS NULL
+             OR EXISTS (SELECT 1 FROM parent_chain WHERE object_id = $11)) AS parent_found,
+           (NOT $10::boolean OR $11::text IS NULL
+             OR ($11::text <> $2
+               AND NOT EXISTS (SELECT 1 FROM parent_chain WHERE object_id = $2)
+               AND NOT EXISTS (SELECT 1 FROM parent_chain WHERE cycle))) AS parent_acyclic,
            (SELECT count(*) FROM locked_plans) = jsonb_array_length($7::jsonb) AS all_plans_found,
            ($8::text IS NULL OR EXISTS (SELECT 1 FROM locked_plans WHERE object_id = $8)) AS target_plan_found,
            (SELECT payload->>'project_id' FROM locked_plans WHERE object_id = $8) AS target_project_id
@@ -28118,7 +28217,13 @@ class PostgresJsonRecordStore {
          )
          SELECT $1, 'tasks', $2, guarded.payload, $4::timestamptz, NULL, $5, $6
          FROM guarded
-         WHERE guarded.all_plans_found AND guarded.target_plan_found AND NOT guarded.project_conflict
+         WHERE guarded.task_found
+           AND guarded.version_matches
+           AND guarded.parent_found
+           AND guarded.parent_acyclic
+           AND guarded.all_plans_found
+           AND guarded.target_plan_found
+           AND NOT guarded.project_conflict
          ON CONFLICT (service, object_type, object_id) DO UPDATE SET
            payload = EXCLUDED.payload,
            updated_at = EXCLUDED.updated_at,
@@ -28131,8 +28236,10 @@ class PostgresJsonRecordStore {
                 AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))
          RETURNING payload
        )
-       SELECT guarded.all_plans_found, guarded.target_plan_found, guarded.project_conflict,
-              (SELECT payload FROM stored) AS payload
+       SELECT guarded.task_found, guarded.version_matches, guarded.parent_found, guarded.parent_acyclic,
+              guarded.all_plans_found, guarded.target_plan_found, guarded.project_conflict,
+              (SELECT payload FROM stored) AS payload,
+              (SELECT payload FROM locked_task) AS current_payload
        FROM guarded`, [
       this.service,
       value.id,
@@ -28142,9 +28249,26 @@ class PostgresJsonRecordStore {
       numberValue3(value.version),
       jsonbParam(planIds),
       targetPlanId,
-      explicitProject
+      explicitProject,
+      Boolean(parentGuard),
+      parentGuard?.parentId ?? null,
+      parentGuard?.expectedVersion ?? null,
+      parentGuard?.operation === "update"
     ]);
     const row = result.rows[0];
+    if (parentGuard && !row?.task_found) {
+      throw new TaskNotFoundError(value.id);
+    }
+    if (parentGuard && !row?.version_matches) {
+      const current = row?.current_payload ? payloadRecord2(row.current_payload) : await this.get("tasks", value.id);
+      throw new VersionConflictError(value.id, parentGuard.expectedVersion, current?.version ?? -1);
+    }
+    if (parentGuard && !row?.parent_found && parentGuard.parentId) {
+      throw new TaskNotFoundError(parentGuard.parentId);
+    }
+    if (parentGuard && !row?.parent_acyclic && parentGuard.parentId) {
+      throw new ResourceConflictError("TASK_PARENT_CYCLE", `TASK_PARENT_CYCLE: assigning parent ${parentGuard.parentId} to task ${value.id} would create or retain a parent cycle`);
+    }
     if (!row?.all_plans_found || !row.target_plan_found) {
       throw new PlanProjectLinkError("PLAN_PROJECT_LINK_PLAN_NOT_FOUND", `Plan membership changed through a missing plan: ${targetPlanId ?? planIds.join(", ")}`, { plan_ids: planIds, target_plan_id: targetPlanId });
     }
@@ -28152,6 +28276,8 @@ class PostgresJsonRecordStore {
       throw new ResourceConflictError("PLAN_PROJECT_LINK_CONFLICT", `Task project conflicts with linked plan ${targetPlanId}`);
     }
     if (!row.payload) {
+      if (row.current_payload)
+        return payloadRecord2(row.current_payload);
       return await requireRecord("tasks", value.id, this);
     }
     return payloadRecord2(row.payload);
@@ -28477,6 +28603,80 @@ class PostgresJsonRecordStore {
       version: numberValue3(existing["version"])
     }, context);
   }
+  async deleteTaskHierarchy(id, context = {}) {
+    await this.ensureSchema();
+    return this.withTaskParentIntegrityTransaction(async (client) => {
+      const timestamp3 = new Date().toISOString();
+      const result = await client.query(`/* todos:task-parent-integrity-delete */ WITH RECURSIVE
+       task_tree(object_id, path, cycle) AS (
+         SELECT task.object_id, ARRAY[task.object_id], false
+         FROM ${this.tableName} AS task
+         WHERE task.service = $1
+           AND task.object_type = 'tasks'
+           AND task.object_id = $2
+           AND task.deleted_at IS NULL
+         UNION ALL
+         SELECT child.object_id,
+                tree.path || child.object_id,
+                child.object_id = ANY(tree.path)
+         FROM task_tree AS tree
+         JOIN ${this.tableName} AS child
+           ON child.service = $1
+          AND child.object_type = 'tasks'
+          AND child.payload->>'parent_id' = tree.object_id
+          AND child.deleted_at IS NULL
+         WHERE NOT tree.cycle
+       ), tombstoned AS (
+         UPDATE ${this.tableName} AS task
+         SET deleted_at = $3::timestamptz,
+             updated_at = $3::timestamptz,
+             source_machine_id = $4
+         WHERE task.service = $1
+           AND task.object_type = 'tasks'
+           AND task.deleted_at IS NULL
+           AND task.object_id IN (
+             SELECT object_id FROM task_tree WHERE NOT cycle
+           )
+         RETURNING task.object_id
+       ), tombstoned_related AS (
+         UPDATE ${this.tableName} AS related
+         SET deleted_at = $3::timestamptz,
+             updated_at = $3::timestamptz,
+             source_machine_id = $4
+         WHERE related.service = $1
+           AND related.deleted_at IS NULL
+           AND (
+             (
+               related.object_type = 'dependencies'
+               AND (
+                 related.payload->>'task_id' IN (
+                   SELECT object_id FROM task_tree WHERE NOT cycle
+                 )
+                 OR related.payload->>'depends_on' IN (
+                   SELECT object_id FROM task_tree WHERE NOT cycle
+                 )
+               )
+             )
+             OR (
+               related.object_type IN ('comments', 'verifications', 'commits', 'refs')
+               AND related.payload->>'task_id' IN (
+                 SELECT object_id FROM task_tree WHERE NOT cycle
+               )
+             )
+           )
+         RETURNING related.object_id
+       )
+       SELECT EXISTS (SELECT 1 FROM task_tree WHERE object_id = $2) AS found,
+              (SELECT count(*) FROM tombstoned) AS deleted_count,
+              (SELECT count(*) FROM tombstoned_related) AS related_deleted_count`, [
+        this.service,
+        id,
+        timestamp3,
+        context.requestId ?? this.sourceMachineId ?? null
+      ]);
+      return Boolean(result.rows[0]?.found);
+    });
+  }
   async getPlanProjectLinkReceipt(receiptId) {
     const value = await this.get("plan_project_link_receipts", receiptId);
     return value ? assertPlanProjectLinkReceipt(value) : null;
@@ -28897,9 +29097,8 @@ class PostgresJsonRecordStore {
 }
 async function createTask2(input, store, context) {
   const timestamp3 = new Date().toISOString();
-  if (input.parent_id && !await store.get("tasks", input.parent_id)) {
-    throw new TaskNotFoundError(input.parent_id);
-  }
+  const taskId = randomUUID3();
+  await assertTaskParentIntegrityAsync(taskId, input.parent_id, (id) => store.get("tasks", id));
   const linkedPlan = input.plan_id ? await store.get("plans", input.plan_id) : null;
   const requestedProjectId = input.project_id ?? context?.projectId ?? null;
   if (linkedPlan?.project_id && requestedProjectId && requestedProjectId !== linkedPlan.project_id) {
@@ -28908,7 +29107,7 @@ async function createTask2(input, store, context) {
   const effectiveProjectId = linkedPlan?.project_id ?? requestedProjectId;
   const shortId = effectiveProjectId ? await nextTaskShortId2(effectiveProjectId, store, context) : null;
   const task2 = {
-    id: randomUUID3(),
+    id: taskId,
     short_id: shortId,
     project_id: effectiveProjectId,
     parent_id: input.parent_id ?? null,
@@ -28964,15 +29163,16 @@ async function createTask2(input, store, context) {
     synced_at: null,
     archived_at: null
   };
-  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task2, task2.plan_id ? [task2.plan_id] : [], input.project_id !== undefined || context?.projectId !== undefined, context);
+  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task2, task2.plan_id ? [task2.plan_id] : [], input.project_id !== undefined || context?.projectId !== undefined, context, input.parent_id ? { operation: "create", expectedVersion: 0, parentId: input.parent_id } : undefined);
   await logTaskChange2(storedTask.id, "created", "status", null, storedTask.status, storedTask.assigned_by ?? storedTask.agent_id, store, context);
   return storedTask;
 }
-async function updateTask2(id, input, store) {
+async function updateTask2(id, input, store, context) {
   const existing = await requireRecord("tasks", id, store);
   if (existing.version !== input.version) {
-    throw new Error(`Task ${id} version conflict: expected ${existing.version}, got ${input.version}`);
+    throw new VersionConflictError(id, input.version, existing.version);
   }
+  await assertTaskParentIntegrityAsync(id, input.parent_id, (candidateId) => store.get("tasks", candidateId));
   const effectivePlanId = input.plan_id !== undefined ? input.plan_id : existing.plan_id;
   const linkedPlan = effectivePlanId ? await store.get("plans", effectivePlanId) : null;
   if (linkedPlan?.project_id) {
@@ -28997,10 +29197,19 @@ async function updateTask2(id, input, store) {
     metadata: input.metadata ?? existing.metadata,
     requires_approval: input.requires_approval ?? existing.requires_approval,
     task_list_id: input.task_list_id !== undefined ? input.task_list_id : existing.task_list_id,
+    parent_id: input.parent_id !== undefined ? input.parent_id : existing.parent_id,
     created_by: existing.created_by,
     completed_at: reopened ? null : input.completed_at !== undefined ? input.completed_at : existing.completed_at
   };
-  return store.upsertTaskWithPlanMembershipGuard(task2, [existing.plan_id, effectivePlanId].filter((planId) => Boolean(planId)), input.project_id !== undefined);
+  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task2, [existing.plan_id, effectivePlanId].filter((planId) => Boolean(planId)), input.project_id !== undefined, context, {
+    operation: "update",
+    expectedVersion: input.version,
+    parentId: input.parent_id !== undefined ? input.parent_id : existing.parent_id
+  });
+  if (input.parent_id !== undefined && input.parent_id !== existing.parent_id) {
+    await logTaskChange2(id, "update", "parent_id", existing.parent_id, input.parent_id, existing.assigned_to ?? existing.agent_id, store, context);
+  }
+  return storedTask;
 }
 async function startTask2(id, agentId, store) {
   const task2 = await requireRecord("tasks", id, store);
@@ -29064,7 +29273,11 @@ async function patchTask(task2, patch, store) {
     version: task2.version + 1,
     updated_at: new Date().toISOString()
   };
-  return store.upsertTaskWithPlanMembershipGuard(updated, [task2.plan_id, updated.plan_id].filter((planId) => Boolean(planId)), Object.prototype.hasOwnProperty.call(patch, "project_id"));
+  return store.upsertTaskWithPlanMembershipGuard(updated, [task2.plan_id, updated.plan_id].filter((planId) => Boolean(planId)), Object.prototype.hasOwnProperty.call(patch, "project_id"), {}, {
+    operation: "update",
+    expectedVersion: task2.version,
+    parentId: updated.parent_id
+  });
 }
 var CLOUD_LOCK_EXPIRY_MINUTES = 30;
 function sameCloudLockHolder(stored, incoming) {
@@ -34184,7 +34397,7 @@ function createLocalPrGroupLedger(db = getDatabase()) {
   return new PrGroupLedger(new SqlitePrGroupLedgerPersistence(db));
 }
 // src/project-registration/authority.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 // src/project-registration/types.ts
 var TODOS_PROJECT_REGISTRATION_ROUTE = "todos.project-registration.v1";
 var TODOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
@@ -34478,6 +34691,7 @@ class PostgresTodosProjectRegistrationTransaction {
         AND (payload->>'path' = $2 OR payload->>'task_list_id' = $3)
       ORDER BY payload->>'created_at' ASC, object_id ASC
       LIMIT 1
+      FOR UPDATE
     `, [this.service, path, taskListSlug]);
     return result.rows[0] ? parsePayload3(result.rows[0].payload) : null;
   }
@@ -34488,6 +34702,7 @@ class PostgresTodosProjectRegistrationTransaction {
         AND payload->>'project_id' = $2 AND payload->>'slug' = $3
       ORDER BY payload->>'created_at' ASC, object_id ASC
       LIMIT 1
+      FOR UPDATE
     `, [this.service, projectId, slug]);
     return result.rows[0] ? parsePayload3(result.rows[0].payload) : null;
   }
@@ -34498,10 +34713,24 @@ class PostgresTodosProjectRegistrationTransaction {
     return await this.storage.taskLists.create(input);
   }
   async getProject(id) {
-    return await this.storage.projects.get(id);
+    const result = await this.client.query(`
+      SELECT payload FROM ${this.tableName}
+      WHERE service = $1 AND object_type = 'projects' AND object_id = $2
+        AND deleted_at IS NULL
+      LIMIT 1
+      FOR SHARE
+    `, [this.service, id]);
+    return result.rows[0] ? parsePayload3(result.rows[0].payload) : null;
   }
   async getTaskList(id) {
-    return await this.storage.taskLists.get(id);
+    const result = await this.client.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
+      FOR SHARE
+    `, [this.service, id]);
+    return result.rows[0] ? parsePayload3(result.rows[0].payload) : null;
   }
   async lockCompensationWrites() {
     await this.client.query(`LOCK TABLE ${this.tableName} IN SHARE ROW EXCLUSIVE MODE`);
@@ -34581,11 +34810,102 @@ class PostgresTodosProjectRegistrationBackend {
   async getTaskList(id) {
     return (await this.direct()).getTaskList(id);
   }
+  async getProjectResourceCollectionRevision(input) {
+    await this.ensureSchema();
+    const result = await this.client.query(`
+      WITH resources(kind_rank, target_id, revision) AS (
+        SELECT 0, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'projects'
+          AND deleted_at IS NULL AND object_id = $2
+        UNION ALL
+        SELECT 1, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'task_lists'
+          AND deleted_at IS NULL AND object_id = $3
+          AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 2, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'plans'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 3, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'tasks'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+      )
+      SELECT 'md5:' || md5(COALESCE(string_agg(
+        kind_rank::text || chr(31) || target_id || chr(31) || revision,
+        chr(30) ORDER BY kind_rank ASC, target_id ASC
+      ), '')) AS revision
+      FROM resources
+    `, [
+      this.service,
+      input.todos_project_id,
+      input.task_list_id,
+      input.include_anchors
+    ]);
+    const revision = result.rows[0]?.revision;
+    if (!revision) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "could not derive the hosted project-resource collection revision");
+    }
+    return revision;
+  }
+  async listProjectResourceCandidates(input) {
+    await this.ensureSchema();
+    const afterRank = input.after?.kind_rank ?? -1;
+    const afterId = input.after?.target_id ?? "";
+    const result = await this.client.query(`
+      WITH resources(kind, kind_rank, target_id, parent_id, revision) AS (
+        SELECT 'project'::text, 0, object_id, NULL::text,
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'projects'
+          AND deleted_at IS NULL AND object_id = $2
+        UNION ALL
+        SELECT 'task_list'::text, 1, object_id, payload->>'project_id',
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'task_lists'
+          AND deleted_at IS NULL AND object_id = $3
+          AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 'plan'::text, 2, object_id, payload->>'project_id',
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'plans'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 'task'::text, 3, object_id,
+          COALESCE(payload->>'plan_id', payload->>'project_id'),
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'tasks'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+      )
+      SELECT kind, kind_rank, target_id, parent_id, revision
+      FROM resources
+      WHERE kind_rank > $5 OR (kind_rank = $5 AND target_id > $6)
+      ORDER BY kind_rank ASC, target_id ASC
+      LIMIT $7
+    `, [
+      this.service,
+      input.todos_project_id,
+      input.task_list_id,
+      input.include_anchors,
+      afterRank,
+      afterId,
+      input.limit
+    ]);
+    return result.rows;
+  }
 }
 
 // src/project-registration/sqlite.ts
 init_database();
 init_storage_tombstones();
+import { createHash as createHash14 } from "crypto";
 var sqliteTransactionTails2 = new WeakMap;
 var PROJECT_REFERENCE_COLUMNS = new Set([
   "project_id",
@@ -35239,6 +35559,64 @@ class SqliteTodosProjectRegistrationBackend {
   getTaskList(id) {
     return this.direct.getTaskList(id);
   }
+  async getProjectResourceCollectionRevision(input) {
+    const digest = createHash14("sha256");
+    const rows = this.db.query(`
+      WITH resources(kind_rank, target_id, revision) AS (
+        SELECT 0, id, updated_at
+        FROM projects
+        WHERE id = ?
+        UNION ALL
+        SELECT 1, id, updated_at
+        FROM task_lists
+        WHERE id = ? AND project_id = ?
+        UNION ALL
+        SELECT 2, id, updated_at
+        FROM plans
+        WHERE ? = 1 AND project_id = ?
+        UNION ALL
+        SELECT 3, id, updated_at
+        FROM tasks
+        WHERE ? = 1 AND project_id = ?
+      )
+      SELECT kind_rank, target_id, revision
+      FROM resources
+      ORDER BY kind_rank ASC, target_id ASC
+    `).iterate(input.todos_project_id, input.task_list_id, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id);
+    for (const row of rows) {
+      digest.update(`${row.kind_rank}\x00${row.target_id}\x00${row.revision}
+`);
+    }
+    return `sha256:${digest.digest("hex")}`;
+  }
+  async listProjectResourceCandidates(input) {
+    const afterRank = input.after?.kind_rank ?? -1;
+    const afterId = input.after?.target_id ?? "";
+    return this.db.query(`
+      WITH resources(kind, kind_rank, target_id, parent_id, revision) AS (
+        SELECT 'project', 0, id, NULL, updated_at
+        FROM projects
+        WHERE id = ?
+        UNION ALL
+        SELECT 'task_list', 1, id, project_id, updated_at
+        FROM task_lists
+        WHERE id = ? AND project_id = ?
+        UNION ALL
+        SELECT 'plan', 2, id, project_id, updated_at
+        FROM plans
+        WHERE ? = 1 AND project_id = ?
+        UNION ALL
+        SELECT 'task', 3, id, COALESCE(plan_id, project_id), updated_at
+        FROM tasks
+        WHERE ? = 1 AND project_id = ?
+      )
+      SELECT kind, kind_rank, target_id, parent_id, revision
+      FROM resources
+      WHERE kind_rank > ? OR (kind_rank = ? AND target_id > ?)
+      ORDER BY kind_rank ASC, target_id ASC
+      LIMIT ?
+    `).all(input.todos_project_id, input.task_list_id, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, afterRank, afterRank, afterId, input.limit);
+  }
 }
 
 // src/project-registration/authority.ts
@@ -35250,6 +35628,8 @@ var AUTHORITY_ROUTE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/;
 var PACKAGE_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 var IDEMPOTENCY_PATTERN = /^prk_[0-9a-f]{48}$/;
+var PROJECT_RESOURCE_PAGE_LIMIT = 500;
+var PROJECT_RESOURCE_CURSOR_VERSION = 1;
 
 class WriteBoundaryError extends Error {
   point;
@@ -35277,7 +35657,7 @@ function canonicalize4(value) {
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash14("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash15("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -35389,35 +35769,68 @@ function projectRecord(project) {
   return {
     target_id: project.id,
     revision: project.updated_at,
-    digest: digestProjectRegistrationValue({
-      id: project.id,
-      name: project.name,
-      path: project.path,
-      description: project.description,
-      task_list_id: project.task_list_id,
-      task_prefix: project.task_prefix,
-      task_counter: project.task_counter,
-      created_at: project.created_at,
-      updated_at: project.updated_at
-    })
+    digest: projectRegistrationDigest(project)
   };
 }
 function taskListRecord(taskList) {
   return {
     target_id: taskList.id,
     revision: taskList.updated_at,
-    digest: digestProjectRegistrationValue({
-      id: taskList.id,
-      project_id: taskList.project_id,
-      slug: taskList.slug,
-      name: taskList.name,
-      description: taskList.description,
-      metadata: taskList.metadata,
-      created_at: taskList.created_at,
-      updated_at: taskList.updated_at
+    digest: taskListRegistrationDigest(taskList)
+  };
+}
+function boundExistingProjectRecord(project) {
+  return {
+    target_id: project.id,
+    revision: project.created_at,
+    digest: projectRegistrationDigest({
+      ...project,
+      updated_at: project.created_at
     })
   };
 }
+function boundExistingTaskListRecord(taskList) {
+  return {
+    target_id: taskList.id,
+    revision: taskList.created_at,
+    digest: taskListRegistrationDigest({
+      ...taskList,
+      updated_at: taskList.created_at
+    })
+  };
+}
+function projectRegistrationDigest(project) {
+  return digestProjectRegistrationValue({
+    id: project.id,
+    name: project.name,
+    path: project.path,
+    description: project.description,
+    task_list_id: project.task_list_id,
+    task_prefix: project.task_prefix,
+    task_counter: project.task_counter,
+    created_at: project.created_at,
+    updated_at: project.updated_at
+  });
+}
+function taskListRegistrationDigest(taskList) {
+  return digestProjectRegistrationValue({
+    id: taskList.id,
+    project_id: taskList.project_id,
+    slug: taskList.slug,
+    name: taskList.name,
+    description: taskList.description,
+    metadata: taskList.metadata,
+    created_at: taskList.created_at,
+    updated_at: taskList.updated_at
+  });
+}
+function canonicalValuesEqual(left, right) {
+  try {
+    return canonicalProjectRegistrationJson(left) === canonicalProjectRegistrationJson(right);
+  } catch {
+    return false;
+  }
+}
 function receiptId(input) {
   return `tpr_${digestProjectRegistrationValue(input).slice(0, 40)}`;
 }
@@ -35455,9 +35868,37 @@ function normalizedCallDigest(request) {
     project_slug: request.project_slug,
     project_name: request.project_name,
     desired: request.desired,
+    bind_existing: request.bind_existing === true,
     accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
   });
 }
+function legacyNormalizedCallDigestBeforeBindExisting(request) {
+  return digestProjectRegistrationValue({
+    authority_route: request.authority_route,
+    package_version: request.package_version,
+    authority_id: request.authority_id,
+    tenant_id: request.tenant_id,
+    corpus_id: request.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    resource_kind: request.resource_kind,
+    direction: request.direction,
+    target_selector: request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    project_id: request.project_id,
+    project_slug: request.project_slug,
+    project_name: request.project_name,
+    desired: request.desired,
+    accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
+  });
+}
+function acceptedCallMatches(request, accepted, callDigest = normalizedCallDigest(request)) {
+  if (accepted.normalized_call_digest === callDigest)
+    return true;
+  return request.bind_existing !== true && accepted.normalized_call_digest === legacyNormalizedCallDigestBeforeBindExisting(request);
+}
 function assertCommonRequest(request, capability2) {
   assertBounds(request);
   assertResourceKind(request.resource_kind);
@@ -35499,6 +35940,9 @@ function assertCommonRequest(request, capability2) {
   if (!request.desired || typeof request.desired !== "object" || Array.isArray(request.desired)) {
     throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "desired must be a JSON object");
   }
+  if (request.bind_existing !== undefined && typeof request.bind_existing !== "boolean") {
+    throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "bind_existing must be boolean when supplied");
+  }
   const expectedKey = deriveTodosProjectRegistrationIdempotencyKey({
     operation_id: request.operation_id,
     step_id: request.step_id,
@@ -35520,7 +35964,7 @@ function assertForwardRequest(request, capability2) {
   const expectedRequestDigest = digestProjectRegistrationValue(request.desired);
   const expectedPreconditionDigest = digestProjectRegistrationValue({
     target_selector: request.target_selector,
-    expected: "absent"
+    expected: request.bind_existing === true ? "absent_or_matching_existing" : "absent"
   });
   if (request.request_digest !== expectedRequestDigest || request.precondition_digest !== expectedPreconditionDigest) {
     throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "request_digest or precondition_digest does not match normalized forward semantics", {
@@ -35599,7 +36043,7 @@ function receiptBase(request, callDigest, capability2) {
     normalized_call_digest: callDigest
   };
 }
-function makeAcceptedReceipt(request, callDigest, capability2, record, createdAt2) {
+function makeAcceptedReceipt(request, callDigest, capability2, record, createdAt2, createdByOperation = true) {
   return makeReceipt({
     ...receiptBase(request, callDigest, capability2),
     outcome: "accepted",
@@ -35609,7 +36053,7 @@ function makeAcceptedReceipt(request, callDigest, capability2, record, createdAt
     result_digest: record.digest,
     duplicate_of_receipt_id: null,
     accepted_receipt_id: request.direction === "inverse" ? request.accepted_receipt.receipt_id : null,
-    created_by_operation: true
+    created_by_operation: createdByOperation
   }, createdAt2);
 }
 function makeDuplicateReceipt(request, callDigest, capability2, accepted, createdAt2) {
@@ -35671,6 +36115,53 @@ function bindingFor(request, callDigest, timestamp3, capability2) {
     updated_at: timestamp3
   };
 }
+function encodeProjectResourceCursor(input) {
+  return Buffer.from(JSON.stringify({
+    version: PROJECT_RESOURCE_CURSOR_VERSION,
+    ...input
+  }), "utf8").toString("base64url");
+}
+function decodeProjectResourceCursor(cursor, expected) {
+  if (!cursor)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "cursor is not a valid project-resource cursor");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "cursor is not a valid project-resource cursor");
+  }
+  const value = parsed;
+  if (value["version"] !== PROJECT_RESOURCE_CURSOR_VERSION || value["source_project_id"] !== expected.source_project_id || value["include_anchors"] !== expected.include_anchors || !Number.isSafeInteger(value["kind_rank"]) || Number(value["kind_rank"]) < 0 || Number(value["kind_rank"]) > 3 || typeof value["target_id"] !== "string" || !UUID_PATTERN.test(value["target_id"]) || typeof value["collection_revision"] !== "string" || value["collection_revision"].length < 16 || value["collection_revision"].length > 128) {
+    throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "cursor does not match this project-resource query");
+  }
+  return {
+    kind_rank: Number(value["kind_rank"]),
+    target_id: value["target_id"],
+    collection_revision: value["collection_revision"]
+  };
+}
+function projectResourceFromCandidate(sourceProjectId, candidate) {
+  const scope = candidate.kind === "project" || candidate.kind === "task_list" ? "collection" : "resource";
+  return {
+    source_project_id: sourceProjectId,
+    kind: candidate.kind,
+    scope,
+    target_id: candidate.target_id,
+    parent_id: candidate.parent_id,
+    revision: candidate.revision,
+    digest: digestProjectRegistrationValue({
+      source_project_id: sourceProjectId,
+      kind: candidate.kind,
+      scope,
+      target_id: candidate.target_id,
+      parent_id: candidate.parent_id,
+      revision: candidate.revision
+    })
+  };
+}
 
 class PackageOwnedTodosProjectRegistrationAuthority {
   backend;
@@ -35692,6 +36183,10 @@ class PackageOwnedTodosProjectRegistrationAuthority {
       immutable_receipts: true,
       exact_terminal_lookup: true,
       exact_readback: true,
+      bind_existing_adoption: true,
+      prior_registration_adoption_validation: true,
+      project_resource_enumeration: true,
+      project_resource_page_limit: PROJECT_RESOURCE_PAGE_LIMIT,
       conditional_inverse: true,
       ambiguous_outcome_reconciliation: true
     };
@@ -35752,7 +36247,7 @@ class PackageOwnedTodosProjectRegistrationAuthority {
       if (!accepted2) {
         throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_CONFLICT", "duplicate receipt points to a missing accepted receipt");
       }
-      if (accepted2.normalized_call_digest !== callDigest) {
+      if (!acceptedCallMatches(request, accepted2, callDigest)) {
         return this.terminalFor(transaction, request, callDigest, "operation_step_semantics_changed", { targetId: accepted2.target_id });
       }
       return this.duplicateFor(transaction, request, callDigest, accepted2);
@@ -35766,7 +36261,7 @@ class PackageOwnedTodosProjectRegistrationAuthority {
     });
     if (!accepted)
       return null;
-    if (accepted.normalized_call_digest === callDigest) {
+    if (acceptedCallMatches(request, accepted, callDigest)) {
       return this.duplicateFor(transaction, request, callDigest, accepted);
     }
     return this.terminalFor(transaction, request, callDigest, "operation_step_semantics_changed", { targetId: accepted.target_id });
@@ -35777,6 +36272,12 @@ class PackageOwnedTodosProjectRegistrationAuthority {
       const slug2 = taskListSlug(request.project_slug);
       const conflict2 = await transaction.findProjectConflict(path, slug2);
       if (conflict2) {
+        if (request.bind_existing === true && conflict2.path === path && conflict2.task_list_id === slug2) {
+          return {
+            record: boundExistingProjectRecord(conflict2),
+            created_by_operation: false
+          };
+        }
         return this.terminalFor(transaction, request, normalizedCallDigest(request), "target_already_exists", { targetId: conflict2.id });
       }
       await this.fault("before_object_write", request);
@@ -35788,7 +36289,10 @@ class PackageOwnedTodosProjectRegistrationAuthority {
         task_prefix: deterministicTaskPrefix(request.project_slug)
       });
       await this.fault("after_object_write", request);
-      return projectRecord(project);
+      return {
+        record: projectRecord(project),
+        created_by_operation: true
+      };
     }
     const todosProjectId = String(request.desired["todos_project_id"]);
     const sourceBinding = await transaction.getBinding(authorityScope(this.capabilityValue), "project", request.project_id);
@@ -35802,6 +36306,12 @@ class PackageOwnedTodosProjectRegistrationAuthority {
     const slug = taskListSlug(request.project_slug);
     const conflict = await transaction.findTaskListConflict(todosProjectId, slug);
     if (conflict) {
+      if (request.bind_existing === true && conflict.project_id === todosProjectId && conflict.slug === slug) {
+        return {
+          record: boundExistingTaskListRecord(conflict),
+          created_by_operation: false
+        };
+      }
       return this.terminalFor(transaction, request, normalizedCallDigest(request), "target_already_exists", { targetId: conflict.id });
     }
     await this.fault("before_object_write", request);
@@ -35818,7 +36328,10 @@ class PackageOwnedTodosProjectRegistrationAuthority {
     if (taskList.project_id !== todosProjectId) {
       throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_CONFLICT", "task-list create did not preserve the exact full Todos project id");
     }
-    return taskListRecord(taskList);
+    return {
+      record: taskListRecord(taskList),
+      created_by_operation: true
+    };
   }
   async create(request) {
     const startedAt = Date.now();
@@ -35840,9 +36353,9 @@ class PackageOwnedTodosProjectRegistrationAuthority {
         const claimed = await transaction.claimBinding(bindingFor(request, callDigest, timestamp3, this.capabilityValue));
         if (!claimed) {
           const binding = await transaction.getBinding(authorityScope(this.capabilityValue), request.resource_kind, request.target_selector);
-          if (binding?.state === "accepted" && binding.normalized_call_digest === callDigest && binding.accepted_receipt_id) {
+          if (binding?.state === "accepted" && binding.accepted_receipt_id) {
             const accepted2 = await transaction.getReceiptById(binding.accepted_receipt_id);
-            if (accepted2) {
+            if (accepted2 && binding.normalized_call_digest === accepted2.normalized_call_digest && acceptedCallMatches(request, accepted2, callDigest)) {
               return this.duplicateFor(transaction, request, callDigest, accepted2);
             }
           }
@@ -35853,15 +36366,15 @@ class PackageOwnedTodosProjectRegistrationAuthority {
           await transaction.setBindingTerminal(authorityScope(this.capabilityValue), request.resource_kind, request.target_selector, this.now());
           return recordOrTerminal;
         }
-        const accepted = makeAcceptedReceipt(request, callDigest, this.capabilityValue, recordOrTerminal, this.now());
+        const accepted = makeAcceptedReceipt(request, callDigest, this.capabilityValue, recordOrTerminal.record, this.now(), recordOrTerminal.created_by_operation);
         await this.fault("before_receipt_write", request);
         const stored = await insertDeterministicReceipt(transaction, accepted);
         await this.fault("after_receipt_write", request);
         await transaction.setBindingAccepted(authorityScope(this.capabilityValue), request.resource_kind, request.target_selector, {
-          target_id: recordOrTerminal.target_id,
+          target_id: recordOrTerminal.record.target_id,
           accepted_receipt_id: stored.receipt_id,
-          result_revision: recordOrTerminal.revision,
-          result_digest: recordOrTerminal.digest,
+          result_revision: recordOrTerminal.record.revision,
+          result_digest: recordOrTerminal.record.digest,
           updated_at: this.now()
         });
         return stored;
@@ -35909,7 +36422,7 @@ class PackageOwnedTodosProjectRegistrationAuthority {
         direction: request.direction
       });
       if (accepted) {
-        return accepted.normalized_call_digest === callDigest ? this.duplicateFor(transaction, request, callDigest, accepted) : this.terminalFor(transaction, request, callDigest, "operation_step_semantics_changed", { targetId: accepted.target_id });
+        return acceptedCallMatches(request, accepted, callDigest) ? this.duplicateFor(transaction, request, callDigest, accepted) : this.terminalFor(transaction, request, callDigest, "operation_step_semantics_changed", { targetId: accepted.target_id });
       }
       const timestamp3 = this.now();
       const claimed = await transaction.claimBinding(bindingFor(request, callDigest, timestamp3, this.capabilityValue));
@@ -35989,6 +36502,164 @@ class PackageOwnedTodosProjectRegistrationAuthority {
     }
     return withResponseControl({ receipt: publicReceipt(receipt) }, request, startedAt);
   }
+  async listProjectResources(request) {
+    const sourceProjectId = requireString(request.source_project_id, "source_project_id", { min: 16, max: 128, pattern: WORKSPACE_ID_PATTERN });
+    if (!Number.isSafeInteger(request.limit) || request.limit <= 0 || request.limit > PROJECT_RESOURCE_PAGE_LIMIT) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_BOUNDS", `limit must be an integer from 1 to ${PROJECT_RESOURCE_PAGE_LIMIT}`);
+    }
+    if (request.include_anchors !== undefined && typeof request.include_anchors !== "boolean") {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_INVALID_INPUT", "include_anchors must be boolean when supplied");
+    }
+    const includeAnchors = request.include_anchors === true;
+    const projectBinding = await this.backend.getBinding(authorityScope(this.capabilityValue), "project", sourceProjectId);
+    if (!projectBinding || projectBinding.state !== "accepted" || !projectBinding.target_id) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "no accepted Todos project binding exists for this exact Projects workspace id", { source_project_id: sourceProjectId });
+    }
+    const taskListBinding = await this.backend.getBinding(authorityScope(this.capabilityValue), "task_list", `${projectBinding.target_id}:default`);
+    if (!taskListBinding || taskListBinding.state !== "accepted" || !taskListBinding.target_id) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "no accepted canonical task-list binding exists for this exact Todos project id", {
+        source_project_id: sourceProjectId,
+        todos_project_id: projectBinding.target_id
+      });
+    }
+    const cursor = decodeProjectResourceCursor(request.cursor, {
+      source_project_id: sourceProjectId,
+      include_anchors: includeAnchors
+    });
+    const collectionInput = {
+      todos_project_id: projectBinding.target_id,
+      task_list_id: taskListBinding.target_id,
+      include_anchors: includeAnchors
+    };
+    const collectionRevision = await this.backend.getProjectResourceCollectionRevision(collectionInput);
+    if (cursor && cursor.collection_revision !== collectionRevision) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_COLLECTION_CHANGED", "project-resource collection changed during pagination; restart from the first page", {
+        source_project_id: sourceProjectId,
+        expected_collection_revision: cursor.collection_revision,
+        current_collection_revision: collectionRevision
+      });
+    }
+    const candidates = await this.backend.listProjectResourceCandidates({
+      ...collectionInput,
+      after: cursor ? { kind_rank: cursor.kind_rank, target_id: cursor.target_id } : null,
+      limit: request.limit + 1
+    });
+    const verifiedCollectionRevision = await this.backend.getProjectResourceCollectionRevision(collectionInput);
+    if (verifiedCollectionRevision !== collectionRevision) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_COLLECTION_CHANGED", "project-resource collection changed while producing a page; restart from the first page", {
+        source_project_id: sourceProjectId,
+        expected_collection_revision: collectionRevision,
+        current_collection_revision: verifiedCollectionRevision
+      });
+    }
+    const hasMore = candidates.length > request.limit;
+    const pageCandidates = candidates.slice(0, request.limit);
+    const resources = pageCandidates.map((candidate) => projectResourceFromCandidate(sourceProjectId, candidate));
+    const last = pageCandidates.at(-1);
+    return {
+      authority: "todos",
+      route: this.capabilityValue.route,
+      package_version: this.capabilityValue.package_version,
+      authority_id: this.capabilityValue.authority_id,
+      tenant_id: this.capabilityValue.tenant_id,
+      corpus_id: this.capabilityValue.corpus_id,
+      source_project_id: sourceProjectId,
+      todos_project_id: projectBinding.target_id,
+      task_list_id: taskListBinding.target_id,
+      include_anchors: includeAnchors,
+      collection_revision: collectionRevision,
+      limit: request.limit,
+      count: resources.length,
+      resources,
+      has_more: hasMore,
+      next_cursor: hasMore && last ? encodeProjectResourceCursor({
+        source_project_id: sourceProjectId,
+        include_anchors: includeAnchors,
+        collection_revision: collectionRevision,
+        kind_rank: last.kind_rank,
+        target_id: last.target_id
+      }) : null,
+      complete: !hasMore,
+      truncated: false
+    };
+  }
+  async validatePriorRegistrationAdoption(sourceRequest, sourceReceipt, currentRecord) {
+    const startedAt = Date.now();
+    if (!sourceRequest || typeof sourceRequest !== "object" || Array.isArray(sourceRequest) || !sourceReceipt || typeof sourceReceipt !== "object" || Array.isArray(sourceReceipt) || !currentRecord || typeof currentRecord !== "object" || Array.isArray(currentRecord)) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "source request, source receipt, and current record must be present objects");
+    }
+    requireString(sourceRequest.package_version, "package_version", {
+      max: 128,
+      pattern: PACKAGE_VERSION_PATTERN
+    });
+    assertForwardRequest(sourceRequest, {
+      ...this.capabilityValue,
+      package_version: sourceRequest.package_version
+    });
+    const validation = await this.backend.transaction(async (transaction) => {
+      const storedSource = await transaction.getReceiptById(sourceReceipt.receipt_id);
+      if (!storedSource || !canonicalValuesEqual(publicReceipt(storedSource), sourceReceipt) || storedSource.outcome !== "accepted" && storedSource.outcome !== "duplicate_of_accepted") {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "source receipt is not an exact immutable accepted or duplicate receipt", { receipt_id: sourceReceipt.receipt_id });
+      }
+      const accepted = storedSource.outcome === "accepted" ? storedSource : storedSource.duplicate_of_receipt_id ? await transaction.getReceiptById(storedSource.duplicate_of_receipt_id) : null;
+      if (!accepted || accepted.outcome !== "accepted" || !accepted.target_id || !accepted.result_revision || !accepted.result_digest) {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "source receipt does not resolve to one complete accepted receipt", { receipt_id: sourceReceipt.receipt_id });
+      }
+      const receiptLineageMatches = (receipt) => receipt.authority === "todos" && receipt.route === sourceRequest.authority_route && receipt.package_version === sourceRequest.package_version && receipt.authority_id === sourceRequest.authority_id && receipt.tenant_id === sourceRequest.tenant_id && receipt.corpus_id === sourceRequest.corpus_id && receipt.operation_id === sourceRequest.operation_id && receipt.step_id === sourceRequest.step_id && receipt.resource_kind === sourceRequest.resource_kind && receipt.direction === "forward" && receipt.target_selector === sourceRequest.target_selector && receipt.idempotency_key === sourceRequest.idempotency_key && receipt.request_digest === sourceRequest.request_digest && receipt.precondition_digest === sourceRequest.precondition_digest && acceptedCallMatches(sourceRequest, receipt);
+      if (!receiptLineageMatches(storedSource) || !receiptLineageMatches(accepted) || storedSource.outcome === "duplicate_of_accepted" && (storedSource.duplicate_of_receipt_id !== accepted.receipt_id || storedSource.target_id !== accepted.target_id || storedSource.result_revision !== accepted.result_revision || storedSource.result_digest !== accepted.result_digest)) {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "receipt authority, operation, request, precondition, or normalized-call lineage changed");
+      }
+      const binding = await transaction.getBinding(authorityScope(this.capabilityValue), sourceRequest.resource_kind, sourceRequest.target_selector);
+      if (!binding || binding.state !== "accepted" || binding.operation_id !== sourceRequest.operation_id || binding.step_id !== sourceRequest.step_id || binding.direction !== "forward" || binding.idempotency_key !== sourceRequest.idempotency_key || binding.request_digest !== sourceRequest.request_digest || binding.precondition_digest !== sourceRequest.precondition_digest || binding.normalized_call_digest !== accepted.normalized_call_digest || binding.target_id !== accepted.target_id || binding.accepted_receipt_id !== accepted.receipt_id || binding.result_revision !== accepted.result_revision || binding.result_digest !== accepted.result_digest) {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "accepted binding does not match the exact accepted receipt and source lineage");
+      }
+      const current = sourceRequest.resource_kind === "project" ? await transaction.getProject(accepted.target_id) : await transaction.getTaskList(accepted.target_id);
+      if (!current || !canonicalValuesEqual(current, currentRecord) || current.id !== accepted.target_id || current.created_at !== accepted.result_revision) {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "current record does not match the accepted target incarnation", { target_id: accepted.target_id });
+      }
+      let stableMatch = false;
+      if (sourceRequest.resource_kind === "task_list") {
+        stableMatch = taskListRegistrationDigest({
+          ...current,
+          updated_at: accepted.result_revision
+        }) === accepted.result_digest;
+      } else {
+        const project = current;
+        if (!Number.isSafeInteger(project.task_counter) || project.task_counter < 0) {
+          throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "current project task counter is not a valid monotonic registration field");
+        }
+        for (let priorTaskCounter = 0;priorTaskCounter <= project.task_counter; priorTaskCounter += 1) {
+          if (Date.now() - startedAt > sourceRequest.time_budget_ms) {
+            throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_TIME_BUDGET_EXCEEDED", "prior registration adoption validation exceeded its time budget");
+          }
+          if (projectRegistrationDigest({
+            ...project,
+            task_counter: priorTaskCounter,
+            updated_at: accepted.result_revision
+          }) === accepted.result_digest) {
+            stableMatch = true;
+            break;
+          }
+        }
+      }
+      if (!stableMatch) {
+        throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", "stable project-registration fields changed after the accepted receipt", { target_id: accepted.target_id });
+      }
+      return {
+        valid: true,
+        resource_kind: sourceRequest.resource_kind,
+        target_id: accepted.target_id,
+        source_receipt_id: storedSource.receipt_id,
+        accepted_receipt_id: accepted.receipt_id,
+        source_outcome: storedSource.outcome,
+        created_at: current.created_at,
+        current_revision: current.updated_at,
+        accepted_result_digest: accepted.result_digest
+      };
+    });
+    assertWithinBounds(validation, sourceRequest, startedAt);
+    return validation;
+  }
   async storedAcceptedReceipt(request, supplied) {
     const stored = await this.backend.getReceiptById(supplied.receipt_id);
     if (!stored || stored.outcome !== "accepted" || !stored.created_by_operation || canonicalProjectRegistrationJson(publicReceipt(stored)) !== canonicalProjectRegistrationJson(supplied)) {
@@ -36160,6 +36831,65 @@ function createPostgresTodosProjectRegistrationAuthority(client, options = {}) {
     cursorTableName
   }), authorityOptions);
 }
+// src/project-registration/adoption-validation.ts
+var VALIDATION_KEYS = [
+  "valid",
+  "resource_kind",
+  "target_id",
+  "source_receipt_id",
+  "accepted_receipt_id",
+  "source_outcome",
+  "created_at",
+  "current_revision",
+  "accepted_result_digest"
+];
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasExactKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+}
+function adoptionRejected(message) {
+  throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", `TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED: ${message}`);
+}
+function assertTodosPriorRegistrationAdoptionValidationEnvelope(value, input) {
+  if (!isRecord2(input) || !hasExactKeys(input, [
+    "source_request",
+    "source_receipt",
+    "current_record"
+  ])) {
+    adoptionRejected("prior-adoption validation input is incomplete");
+  }
+  const request = input["source_request"];
+  const receipt = input["source_receipt"];
+  const current = input["current_record"];
+  if (!isRecord2(request) || !isRecord2(receipt) || !isRecord2(current)) {
+    adoptionRejected("prior-adoption validation input records are incomplete");
+  }
+  const resourceKind = request["resource_kind"];
+  const sourceOutcome = receipt["outcome"];
+  const acceptedReceiptId = sourceOutcome === "accepted" ? receipt["receipt_id"] : sourceOutcome === "duplicate_of_accepted" ? receipt["duplicate_of_receipt_id"] : null;
+  if (resourceKind !== "project" && resourceKind !== "task_list" || request["direction"] !== "forward" || sourceOutcome !== "accepted" && sourceOutcome !== "duplicate_of_accepted" || !isNonEmptyString(acceptedReceiptId) || !isNonEmptyString(receipt["receipt_id"]) || !isNonEmptyString(receipt["target_id"]) || !isNonEmptyString(receipt["result_revision"]) || !isNonEmptyString(receipt["result_digest"]) || !isNonEmptyString(current["id"]) || !isNonEmptyString(current["created_at"]) || !isNonEmptyString(current["updated_at"]) || receipt["authority"] !== "todos" || receipt["route"] !== request["authority_route"] || receipt["package_version"] !== request["package_version"] || receipt["authority_id"] !== request["authority_id"] || receipt["tenant_id"] !== request["tenant_id"] || receipt["corpus_id"] !== request["corpus_id"] || receipt["operation_id"] !== request["operation_id"] || receipt["step_id"] !== request["step_id"] || receipt["resource_kind"] !== resourceKind || receipt["direction"] !== "forward" || receipt["idempotency_key"] !== request["idempotency_key"] || receipt["request_digest"] !== request["request_digest"] || receipt["precondition_digest"] !== request["precondition_digest"] || receipt["accepted_receipt_id"] !== null || receipt["target_id"] !== current["id"] || receipt["result_revision"] !== current["created_at"]) {
+    adoptionRejected("prior-adoption validation input does not carry one complete accepted receipt and current target incarnation");
+  }
+  if (sourceOutcome === "accepted" && receipt["duplicate_of_receipt_id"] !== null || sourceOutcome === "duplicate_of_accepted" && receipt["duplicate_of_receipt_id"] !== acceptedReceiptId) {
+    adoptionRejected("prior-adoption validation source receipt lineage is incomplete");
+  }
+  if (!isRecord2(value) || !hasExactKeys(value, ["validation"]) || !isRecord2(value["validation"]) || !hasExactKeys(value["validation"], VALIDATION_KEYS)) {
+    adoptionRejected("prior-adoption validation response envelope is incomplete");
+  }
+  const validation = value["validation"];
+  if (validation["valid"] !== true || validation["resource_kind"] !== resourceKind || validation["target_id"] !== current["id"] || validation["source_receipt_id"] !== receipt["receipt_id"] || validation["accepted_receipt_id"] !== acceptedReceiptId || validation["source_outcome"] !== sourceOutcome || validation["created_at"] !== current["created_at"] || validation["current_revision"] !== current["updated_at"] || validation["accepted_result_digest"] !== receipt["result_digest"]) {
+    adoptionRejected("prior-adoption validation response does not prove the exact accepted receipt and current target");
+  }
+  return validation;
+}
+
 // src/project-registration/http.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };
 function json(body, status = 200) {
@@ -36206,6 +36936,20 @@ async function handleTodosProjectRegistrationHttpRequest(req, url, authority, ba
     if ((action === "" || action === "capability") && method === "GET") {
       return json({ capability: await authority.capability() });
     }
+    if (action === "resources" && method === "GET") {
+      const sourceProjectId = url.searchParams.get("source_project_id");
+      const limit = Number(url.searchParams.get("limit") ?? "100");
+      const includeAnchorsRaw = url.searchParams.get("include_anchors");
+      const includeAnchors = includeAnchorsRaw === null ? false : includeAnchorsRaw === "true" ? true : includeAnchorsRaw === "false" ? false : includeAnchorsRaw;
+      return json({
+        page: await authority.listProjectResources({
+          source_project_id: sourceProjectId,
+          limit,
+          include_anchors: includeAnchors,
+          cursor: url.searchParams.get("cursor") ?? undefined
+        })
+      });
+    }
     if (method !== "POST")
       return json({ error: "method not allowed" }, 405);
     const body = await readJson(req);
@@ -36228,6 +36972,12 @@ async function handleTodosProjectRegistrationHttpRequest(req, url, authority, ba
         record: await authority.readExact(body)
       });
     }
+    if (action === "validate-prior-adoption") {
+      const input = body;
+      return json({
+        validation: await authority.validatePriorRegistrationAdoption(input.source_request, input.source_receipt, input.current_record)
+      });
+    }
     if (action === "compensate") {
       return json({
         receipt: await authority.compensate(body)
@@ -36302,6 +37052,28 @@ class TodosProjectRegistrationHttpClient {
   async lookupReceipt(request) {
     return this.request("/receipts/lookup", { method: "POST", body: JSON.stringify(request) });
   }
+  async listProjectResources(request) {
+    const query = new URLSearchParams({
+      source_project_id: request.source_project_id,
+      limit: String(request.limit),
+      include_anchors: String(request.include_anchors === true),
+      ...request.cursor ? { cursor: request.cursor } : {}
+    });
+    const body = await this.request(`/resources?${query.toString()}`);
+    return body.page;
+  }
+  async validatePriorRegistrationAdoption(sourceRequest, sourceReceipt, currentRecord) {
+    const input = {
+      source_request: withoutTarget(sourceRequest),
+      source_receipt: sourceReceipt,
+      current_record: currentRecord
+    };
+    const body = await this.request("/validate-prior-adoption", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return assertTodosPriorRegistrationAdoptionValidationEnvelope(body, input);
+  }
   async compensate(request) {
     const body = await this.request("/compensate", { method: "POST", body: JSON.stringify(withoutTarget(request)) });
     return body.receipt;
@@ -40295,7 +41067,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(capability2) {
   return capability2 !== null && typeof capability2 === "object" && capability2["idempotent_outbox_delivery"] === true;
 }
@@ -40325,6 +41099,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 uuid2 = 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, field2) => exports_external.record(exports_external.string().max(200), scalar).superRefine((value, context) => {
@@ -40367,7 +41143,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: uuid2,
   task_list_id: uuid2.optional(),
   if_binding_version: exports_external.number().int().min(0).optional(),
@@ -40383,7 +41161,10 @@ var schema = exports_external.object({
 }).strict();
 var compensationSchema = exports_external.object({
   receipt_id: uuid2,
-  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({
@@ -40468,10 +41249,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_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -40485,11 +41287,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_PATTERN2.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_PATTERN2.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
@@ -40597,9 +41401,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,
@@ -40610,9 +41420,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,
@@ -40633,6 +41447,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
@@ -40643,6 +41478,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) {
@@ -40659,6 +41502,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
@@ -40668,6 +41529,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") {
@@ -40681,9 +41548,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,
@@ -40695,12 +41568,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,
@@ -40714,6 +41603,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),
@@ -40725,10 +41622,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,
@@ -40741,6 +41665,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()`
   ];
 }
@@ -40752,7 +41680,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 {
@@ -40792,33 +41789,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");
           }
         }
       }
@@ -40874,9 +41887,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
@@ -40892,9 +41910,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 entry2 of input.outbox) {
         this.db.query(`INSERT INTO todos_task_manifest_outbox (
           id, apply_receipt_id, topic, payload, payload_digest, status, created_at
@@ -40902,18 +41921,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(receiptId2) {
     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, receiptId2);
-    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, receiptId2);
+    if (!terminal)
       throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_RECEIPT_NOT_FOUND", `Apply receipt not found: ${receiptId2}`);
-    return parseApplyResult(row.result_json, false);
+    return parseApplyResult(terminal.result_json, false);
   }
   async lookupBindingByPlanId(planId) {
     const rows = this.db.query(`
@@ -40923,6 +41961,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,
@@ -40930,6 +41969,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
@@ -40992,6 +42032,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
@@ -41002,10 +42048,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 }))
       ];
@@ -41045,8 +42097,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 task3 of manifest.tasks) {
@@ -41123,9 +42177,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, now4);
+        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, now4);
       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, now4, this.tenantId, receipt.operation_id, input.if_binding_version);
       if (updated.changes !== 1) {
@@ -41159,6 +42214,39 @@ function safeIdentifier2(value, field2) {
 function parseJson2(value) {
   return typeof value === "string" ? JSON.parse(value) : value;
 }
+function parseApplyResult2(value, duplicate) {
+  const parsed = parseJson2(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 timestamp3(value) {
   return value instanceof Date ? value.toISOString() : new Date(String(value)).toISOString();
 }
@@ -41166,6 +42254,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 receiptFromRow3(row) {
   return {
     receipt_id: String(row["receipt_id"]),
@@ -41174,9 +42297,14 @@ function receiptFromRow3(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: timestamp3(row["created_at"])
@@ -41294,46 +42422,89 @@ class PostgresTodosTaskManifestBackend {
       now4
     ]);
   }
+  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 { ...parseJson2(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] ? parseJson2(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 task3 of manifest.tasks) {
@@ -41403,9 +42574,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
@@ -41422,14 +42598,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
@@ -41448,14 +42628,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,
@@ -41468,9 +42652,12 @@ class PostgresTodosTaskManifestBackend {
   async readExact(receiptId2) {
     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, receiptId2]);
-    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, receiptId2]);
+    if (!terminal.rows[0])
       throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_RECEIPT_NOT_FOUND", `Apply receipt not found: ${receiptId2}`);
-    return { ...parseJson2(result.rows[0]["result_json"]), duplicate: false };
+    return parseApplyResult2(terminal.rows[0]["result_json"], false);
   }
   async lookupBindingByPlanId(planId) {
     await this.ensureSchema();
@@ -41481,6 +42668,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,
@@ -41488,6 +42676,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
@@ -41574,6 +42763,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 = receiptFromRow3(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
@@ -41588,12 +42781,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 = parseJson2(applyRow["result_json"]);
+      const applyResult = parseApplyResult2(applyRow["result_json"], false);
       const manifest = parseJson2(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 }))
       ];
@@ -41641,9 +42840,15 @@ class PostgresTodosTaskManifestBackend {
       }
       const appliedAt = receiptFromRow3(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] ? parseJson2(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 task3 of manifest.tasks)
         expectedPayloads.set(applyResult.graph.task_ids[task3.key], {
@@ -41743,14 +42948,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,
@@ -41810,36 +43018,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, now4) {
   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((task3) => [
     task3.key,
-    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "task", task3.key)
+    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "task", task3.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((task3) => (task3.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "comment", task3.key, String(index)))),
-    verification_ids: manifest.tasks.flatMap((task3) => (task3.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "verification", task3.key, String(index)))),
+    comment_ids: manifest.tasks.flatMap((task3) => (task3.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "comment", task3.key, String(index)))),
+    verification_ids: manifest.tasks.flatMap((task3) => (task3.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "verification", task3.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 })
@@ -41849,11 +43104,14 @@ function normalize(input, now4) {
   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: now4
+    now: now4,
+    plan_slug_provenance: TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE
   };
 }
 function sanitizeManifest(manifest) {
@@ -41911,6 +43169,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,
@@ -41940,7 +43202,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(receiptId2) {
     if (!receiptId2 || receiptId2.length > 200) {
@@ -41973,18 +43239,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()
@@ -42166,7 +43462,7 @@ function createTodosTaskManifestHttpClient(options) {
   return new TodosTaskManifestHttpClient(options);
 }
 // src/ai-tools.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 // src/cli/cloud-router.ts
 import { resolveStorageClient } from "@hasna/contracts/client/storage";
 import { normalizeStorageMode } from "@hasna/contracts/mode";
@@ -43474,7 +44770,7 @@ function deriveTodosAiUpdateTaskApprovalIdentity(input) {
     expected_version: input.expected_version,
     patch
   });
-  const payloadDigest = createHash15("sha256").update(canonical).digest("hex");
+  const payloadDigest = createHash16("sha256").update(canonical).digest("hex");
   return {
     ref: `todos-ai:update_task:${payloadDigest}`,
     payload_digest: payloadDigest
@@ -43629,9 +44925,9 @@ function normalizeUpdateTaskInput(input) {
   if (!Object.hasOwn(record, "expected_version")) {
     throw new Error("expected_version is required");
   }
-  const idempotencyKey = boundedRequiredString(record, "idempotency_key", TODOS_AI_UPDATE_TASK_LIMITS.max_idempotency_key_bytes);
-  const idempotencyBytes = ENCODER.encode(idempotencyKey).byteLength;
-  if (idempotencyBytes < TODOS_AI_UPDATE_TASK_LIMITS.min_idempotency_key_bytes || !/^[A-Za-z0-9._:-]+$/.test(idempotencyKey)) {
+  const idempotencyKey2 = boundedRequiredString(record, "idempotency_key", TODOS_AI_UPDATE_TASK_LIMITS.max_idempotency_key_bytes);
+  const idempotencyBytes = ENCODER.encode(idempotencyKey2).byteLength;
+  if (idempotencyBytes < TODOS_AI_UPDATE_TASK_LIMITS.min_idempotency_key_bytes || !/^[A-Za-z0-9._:-]+$/.test(idempotencyKey2)) {
     throw new Error("idempotency_key must be a bounded stable identifier");
   }
   const patchValue = record["patch"];
@@ -43650,7 +44946,7 @@ function normalizeUpdateTaskInput(input) {
     expected_version: expectedVersion,
     patch,
     changed_fields: changedFields,
-    idempotency_key: idempotencyKey,
+    idempotency_key: idempotencyKey2,
     payload_digest: identity.payload_digest,
     approval_ref: identity.ref
   };
@@ -44331,7 +45627,7 @@ init_task_lifecycle();
 init_task_crud();
 init_redaction();
 import { Database as Database3 } from "bun:sqlite";
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
 import { basename as basename2, dirname as dirname6, join as join9, resolve as resolve10 } from "path";
 
@@ -44614,8 +45910,8 @@ function normalizePath3(input) {
   return resolve10(input);
 }
 function sourceStoreId(sourceDbPath) {
-  const digest = createHash16("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
-  return `sqlite:${digest}`;
+  const digest2 = createHash17("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  return `sqlite:${digest2}`;
 }
 function inferSourceRepoPath(sourceDbPath) {
   const normalized = normalizePath3(sourceDbPath);
@@ -46576,7 +47872,7 @@ init_comments();
 
 // src/db/api-keys.ts
 init_database();
-import { createHash as createHash17, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash18, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -46590,7 +47886,7 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key2) {
-  return createHash17("sha256").update(key2).digest("hex");
+  return createHash18("sha256").update(key2).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
@@ -50491,7 +51787,7 @@ init_database();
 init_tasks();
 import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
 import { basename as basename5 } from "path";
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 init_secret_redaction();
 var INBOX_INTAKE_SCHEMA = "todos.inbox_intake.v1";
 var INTAKE_SOURCE_TYPES = [
@@ -50504,7 +51800,7 @@ var INTAKE_SOURCE_TYPES = [
 ];
 var INTAKE_TRIAGE_STATUSES = ["preview", "triaged", "duplicate", "created"];
 function fingerprint2(text) {
-  return createHash18("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash19("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadRawContent(input) {
   if (input.github_url) {
@@ -55964,7 +57260,7 @@ init_database();
 init_tasks();
 init_redaction();
 init_sync_utils();
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { existsSync as existsSync22, readFileSync as readFileSync20, statSync as statSync9 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
 import { dirname as dirname15, join as join18, resolve as resolve17 } from "path";
@@ -55986,7 +57282,7 @@ var CONFIG_FILES = [
   "dashboard/vite.config.ts"
 ];
 function sha2566(value) {
-  return createHash19("sha256").update(value).digest("hex");
+  return createHash20("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
   const path = join18(root, relativePath);
@@ -56101,8 +57397,8 @@ function defaultSnapshotDir() {
   return join18(dirname15(resolve17(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
-  const digest = sha2566(JSON.stringify(snapshot)).slice(0, 24);
-  return { id: `env_${digest}`, ...snapshot };
+  const digest2 = sha2566(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest2}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
   const root = resolve17(input.root || process.cwd());
@@ -56238,7 +57534,7 @@ function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
 init_database();
 init_projects();
 init_plans();
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "fs";
 import { dirname as dirname16, join as join19 } from "path";
 var DECISION_RECORD_SCHEMA = "todos.decision_record.v1";
@@ -56294,7 +57590,7 @@ function rowToDecisionRecord(row) {
 }
 function stableSnapshotHash(payload) {
   const { captured_at: _capturedAt, ...rest } = payload;
-  return createHash20("sha256").update(JSON.stringify(rest)).digest("hex");
+  return createHash21("sha256").update(JSON.stringify(rest)).digest("hex");
 }
 function createDecisionRecord(input, db) {
   const d = db || getDatabase();
@@ -60787,7 +62083,7 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
 init_tasks();
 init_task_files();
 import { existsSync as existsSync27, readFileSync as readFileSync24, statSync as statSync10 } from "fs";
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import { relative as relative6, resolve as resolve18, join as join25 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
@@ -60852,7 +62148,7 @@ var SKIP_DIRS2 = new Set([
   ".parcel-cache"
 ]);
 function stableHash(value) {
-  return createHash21("sha256").update(value).digest("hex");
+  return createHash22("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -61750,7 +63046,7 @@ function renderWorkflowStatesMarkdown(states = listWorkflowStates()) {
 }
 // src/lib/agent-replay-simulator.ts
 init_redaction();
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { readFileSync as readFileSync25 } from "fs";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -61772,7 +63068,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key2) => [key2, stable2(value[key2])]));
 }
 function fingerprint3(value) {
-  return createHash22("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash23("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject(input))
@@ -62011,7 +63307,7 @@ function renderAgentReplaySimulationMarkdown(simulation) {
 }
 // src/lib/local-extensions.ts
 init_config2();
-import { createHash as createHash23, createVerify } from "crypto";
+import { createHash as createHash24, createVerify } from "crypto";
 import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync26, statSync as statSync11 } from "fs";
 import { basename as basename6, join as join26, resolve as resolve19 } from "path";
 init_redaction();
@@ -62099,7 +63395,7 @@ function parseJson3(path) {
   return JSON.parse(readFileSync26(path, "utf8"));
 }
 function sha2567(bytes) {
-  return `sha256:${createHash23("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash24("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -64714,6 +66010,8 @@ export {
   testTerminalNotificationRule,
   testLocalEventHook,
   tasksFromTemplate,
+  taskManifestRequestDigest,
+  taskManifestCompensationRequestDigest,
   taskFromTemplate,
   tagToPriority,
   syncWithAgents,
@@ -65448,6 +66746,9 @@ export {
   detectInboxSourceType,
   detectCyclesFromEdges,
   describeTerminalNotificationRule,
+  deriveTodosTaskManifestIdempotencyKey,
+  deriveTodosTaskManifestCompensationPreconditionDigest,
+  deriveTodosTaskManifestApplyPreconditionDigest,
   deriveTodosProjectRegistrationIdempotencyKey,
   deriveTodosAiUpdateTaskApprovalIdentity,
   deriveInboxTitle,
@@ -65692,6 +66993,8 @@ export {
   TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
   TODOS_TASK_MANIFEST_SCHEMA_VERSION,
   TODOS_TASK_MANIFEST_ROUTE,
+  TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE,
+  TODOS_TASK_MANIFEST_CALLER_ROUTE,
   TODOS_TASK_MANIFEST_BOUNDS,
   TODOS_STORAGE_TABLES,
   TODOS_STORAGE_FALLBACK_ENV,