@hasna/todos 0.15.29 → 0.15.32

package/dist/server/index.js

@@ -70,7 +70,7 @@ var package_default;
 var init_package = __esm(() => {
   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",
@@ -2373,6 +2373,46 @@ var init_integrity = __esm(() => {
   };
 });
 
+// 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/storage/audit-history-import.ts
 function auditHistoryRowsAreFieldIdentical(left, right) {
   return AUDIT_HISTORY_FIELDS.every((field) => {
@@ -2469,8 +2509,8 @@ function createPostgresTodosStorageAdapter(options) {
       resolveRef: (ref) => store.resolveTaskRef(ref),
       list: (filter = {}) => store.listTasks(filter),
       count: (filter = {}) => store.countTasks(filter),
-      update: (id, input) => updateTask(id, input, store),
-      delete: (id, context) => store.delete("tasks", id, context),
+      update: (id, input, context) => updateTask(id, input, store, context),
+      delete: (id, context) => store.deleteTaskHierarchy(id, context),
       start: (id, agentId) => startTask(id, agentId, store),
       complete: (id, agentId, options2) => completeTask(id, agentId, options2, store),
       fail: (id, agentId, reason, options2) => failTask(id, agentId, reason, options2, store),
@@ -3003,22 +3043,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
@@ -3039,7 +3127,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,
@@ -3052,8 +3146,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,
@@ -3063,9 +3159,26 @@ class PostgresJsonRecordStore {
       numberValue2(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 });
     }
@@ -3073,6 +3186,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);
@@ -3398,6 +3513,80 @@ class PostgresJsonRecordStore {
       version: numberValue2(existing["version"])
     }, context);
   }
+  async deleteTaskHierarchy(id, context = {}) {
+    await this.ensureSchema();
+    return this.withTaskParentIntegrityTransaction(async (client) => {
+      const timestamp = 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,
+        timestamp,
+        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;
@@ -3818,9 +4007,8 @@ class PostgresJsonRecordStore {
 }
 async function createTask(input, store, context) {
   const timestamp = new Date().toISOString();
-  if (input.parent_id && !await store.get("tasks", input.parent_id)) {
-    throw new TaskNotFoundError(input.parent_id);
-  }
+  const taskId = randomUUID();
+  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) {
@@ -3829,7 +4017,7 @@ async function createTask(input, store, context) {
   const effectiveProjectId = linkedPlan?.project_id ?? requestedProjectId;
   const shortId = effectiveProjectId ? await nextTaskShortId(effectiveProjectId, store, context) : null;
   const task = {
-    id: randomUUID(),
+    id: taskId,
     short_id: shortId,
     project_id: effectiveProjectId,
     parent_id: input.parent_id ?? null,
@@ -3885,15 +4073,16 @@ async function createTask(input, store, context) {
     synced_at: null,
     archived_at: null
   };
-  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task, task.plan_id ? [task.plan_id] : [], input.project_id !== undefined || context?.projectId !== undefined, context);
+  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task, task.plan_id ? [task.plan_id] : [], input.project_id !== undefined || context?.projectId !== undefined, context, input.parent_id ? { operation: "create", expectedVersion: 0, parentId: input.parent_id } : undefined);
   await logTaskChange(storedTask.id, "created", "status", null, storedTask.status, storedTask.assigned_by ?? storedTask.agent_id, store, context);
   return storedTask;
 }
-async function updateTask(id, input, store) {
+async function updateTask(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) {
@@ -3918,10 +4107,19 @@ async function updateTask(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(task, [existing.plan_id, effectivePlanId].filter((planId) => Boolean(planId)), input.project_id !== undefined);
+  const storedTask = await store.upsertTaskWithPlanMembershipGuard(task, [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 logTaskChange(id, "update", "parent_id", existing.parent_id, input.parent_id, existing.assigned_to ?? existing.agent_id, store, context);
+  }
+  return storedTask;
 }
 async function startTask(id, agentId, store) {
   const task = await requireRecord("tasks", id, store);
@@ -3985,7 +4183,11 @@ async function patchTask(task, patch, store) {
     version: task.version + 1,
     updated_at: new Date().toISOString()
   };
-  return store.upsertTaskWithPlanMembershipGuard(updated, [task.plan_id, updated.plan_id].filter((planId) => Boolean(planId)), Object.prototype.hasOwnProperty.call(patch, "project_id"));
+  return store.upsertTaskWithPlanMembershipGuard(updated, [task.plan_id, updated.plan_id].filter((planId) => Boolean(planId)), Object.prototype.hasOwnProperty.call(patch, "project_id"), {}, {
+    operation: "update",
+    expectedVersion: task.version,
+    parentId: updated.parent_id
+  });
 }
 function sameCloudLockHolder(stored, incoming) {
   if (!stored || !incoming)
@@ -4688,6 +4890,7 @@ var init_postgres_adapter = __esm(() => {
   init_postgres_sync();
   init_integrity();
   init_redaction();
+  init_task_parent_integrity();
   init_audit_history_import();
   init_canonical();
   TASK_ORDER_BY = `ORDER BY ${TASK_ORDER_TIEBREAK}`;
@@ -7078,6 +7281,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] ? parsePayload(result.rows[0].payload) : null;
   }
@@ -7088,6 +7292,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] ? parsePayload(result.rows[0].payload) : null;
   }
@@ -7098,10 +7303,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] ? parsePayload(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] ? parsePayload(result.rows[0].payload) : null;
   }
   async lockCompensationWrites() {
     await this.client.query(`LOCK TABLE ${this.tableName} IN SHARE ROW EXCLUSIVE MODE`);
@@ -7181,6 +7400,96 @@ 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;
+  }
 }
 var init_postgres2 = __esm(() => {
   init_postgres_adapter();
@@ -15304,6 +15613,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,
@@ -15682,6 +15992,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) {
@@ -15735,6 +16046,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);
@@ -15850,6 +16165,8 @@ function updateTaskStored(id, input, db) {
     logTaskChange2(id, "update", "priority", task.priority, input.priority, agentId, d);
   if (input.title !== undefined && input.title !== task.title)
     logTaskChange2(id, "update", "title", task.title, input.title, agentId, d);
+  if (input.parent_id !== undefined && input.parent_id !== task.parent_id)
+    logTaskChange2(id, "update", "parent_id", task.parent_id, input.parent_id, agentId, d);
   if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to)
     logTaskChange2(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
   if (input.working_dir !== undefined && input.working_dir !== task.working_dir)
@@ -15907,7 +16224,8 @@ function updateTask2(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);
@@ -15943,6 +16261,7 @@ var init_task_crud = __esm(() => {
   init_checklists();
   init_storage_tombstones();
   init_prewrite_secrets();
+  init_task_parent_integrity();
 });
 
 // src/db/task-status.ts
@@ -21129,35 +21448,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)}`;
 }
@@ -21177,6 +21529,29 @@ function assertCapabilityRequest(request, capability) {
   }
 }
 function normalizedCallDigest(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,
+    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,
@@ -21198,6 +21573,11 @@ function normalizedCallDigest(request) {
     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, capability) {
   assertBounds(request);
   assertResourceKind(request.resource_kind);
@@ -21239,6 +21619,9 @@ function assertCommonRequest(request, capability) {
   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,
@@ -21260,7 +21643,7 @@ function assertForwardRequest(request, capability) {
   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", {
@@ -21339,7 +21722,7 @@ function receiptBase(request, callDigest, capability) {
     normalized_call_digest: callDigest
   };
 }
-function makeAcceptedReceipt(request, callDigest, capability, record, createdAt) {
+function makeAcceptedReceipt(request, callDigest, capability, record, createdAt, createdByOperation = true) {
   return makeReceipt({
     ...receiptBase(request, callDigest, capability),
     outcome: "accepted",
@@ -21349,7 +21732,7 @@ function makeAcceptedReceipt(request, callDigest, capability, 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
   }, createdAt);
 }
 function makeDuplicateReceipt(request, callDigest, capability, accepted, createdAt) {
@@ -21411,6 +21794,53 @@ function bindingFor(request, callDigest, timestamp2, capability) {
     updated_at: timestamp2
   };
 }
+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;
@@ -21432,6 +21862,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
     };
@@ -21492,7 +21926,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);
@@ -21506,7 +21940,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 });
@@ -21517,6 +21951,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);
@@ -21528,7 +21968,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);
@@ -21542,6 +21985,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);
@@ -21558,7 +22007,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();
@@ -21580,9 +22032,9 @@ class PackageOwnedTodosProjectRegistrationAuthority {
         const claimed = await transaction.claimBinding(bindingFor(request, callDigest, timestamp2, 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);
             }
           }
@@ -21593,15 +22045,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;
@@ -21649,7 +22101,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 timestamp2 = this.now();
       const claimed = await transaction.claimBinding(bindingFor(request, callDigest, timestamp2, this.capabilityValue));
@@ -21729,6 +22181,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)) {
@@ -21897,7 +22507,7 @@ function createPostgresTodosProjectRegistrationAuthority(client, options = {}) {
     cursorTableName
   }), authorityOptions);
 }
-var UUID_PATTERN, WORKSPACE_ID_PATTERN, OPERATION_PATTERN, STEP_PATTERN, AUTHORITY_ROUTE_PATTERN, PACKAGE_VERSION_PATTERN, SHA256_PATTERN, IDEMPOTENCY_PATTERN, WriteBoundaryError;
+var UUID_PATTERN, WORKSPACE_ID_PATTERN, OPERATION_PATTERN, STEP_PATTERN, AUTHORITY_ROUTE_PATTERN, PACKAGE_VERSION_PATTERN, SHA256_PATTERN, IDEMPOTENCY_PATTERN, PROJECT_RESOURCE_PAGE_LIMIT = 500, PROJECT_RESOURCE_CURSOR_VERSION = 1, WriteBoundaryError;
 var init_authority = __esm(() => {
   init_package_version();
   init_postgres2();
@@ -21922,6 +22532,11 @@ var init_authority = __esm(() => {
   };
 });
 
+// src/project-registration/adoption-validation.ts
+var init_adoption_validation = __esm(() => {
+  init_types3();
+});
+
 // src/project-registration/http.ts
 function json(body, status = 200) {
   return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
@@ -21967,6 +22582,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);
@@ -21989,6 +22618,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)
@@ -22021,6 +22656,7 @@ async function handleTodosProjectRegistrationHttpRequest(req, url, authority, ba
 var JSON_HEADERS;
 var init_http = __esm(() => {
   init_types3();
+  init_adoption_validation();
   JSON_HEADERS = { "Content-Type": "application/json" };
 });
 
@@ -22028,6 +22664,7 @@ var init_http = __esm(() => {
 var init_project_registration = __esm(() => {
   init_authority();
   init_http();
+  init_adoption_validation();
   init_postgres2();
   init_sqlite();
   init_types3();
@@ -26000,7 +26637,7 @@ var init_zod = __esm(() => {
 });
 
 // src/task-manifest/types.ts
-var TODOS_TASK_MANIFEST_ROUTE = "todos.task-manifest.v1", TODOS_TASK_MANIFEST_SCHEMA_VERSION = 1, TodosTaskManifestError;
+var TODOS_TASK_MANIFEST_ROUTE = "todos.task-manifest.v1", TODOS_TASK_MANIFEST_CALLER_ROUTE = "accounts.task-manifest.v1", TODOS_TASK_MANIFEST_SCHEMA_VERSION = 1, TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE = "deterministic-v1", TodosTaskManifestError;
 var init_types5 = __esm(() => {
   TodosTaskManifestError = class TodosTaskManifestError extends Error {
     code;
@@ -26087,7 +26724,7 @@ function parseTodosTaskManifestBindingLookup(input) {
   }
   return parsed.data;
 }
-var TODOS_TASK_MANIFEST_BOUNDS, key, identifier, uuid2, scalar, boundedScalarRecord = (limit, field) => exports_external.record(exports_external.string().max(200), scalar).superRefine((value, context) => {
+var TODOS_TASK_MANIFEST_BOUNDS, key, identifier, digest, idempotencyKey, uuid2, scalar, boundedScalarRecord = (limit, field) => exports_external.record(exports_external.string().max(200), scalar).superRefine((value, context) => {
   if (Object.keys(value).length > limit) {
     context.addIssue({ code: exports_external.ZodIssueCode.custom, message: `${field} exceeds ${limit} fields` });
   }
@@ -26109,6 +26746,8 @@ var init_schema2 = __esm(() => {
   };
   key = exports_external.string().min(1).max(96).regex(/^[a-z][a-z0-9_-]*$/);
   identifier = exports_external.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+  digest = exports_external.string().length(64).regex(/^[0-9a-f]{64}$/);
+  idempotencyKey = exports_external.string().length(52).regex(/^tmk_[0-9a-f]{48}$/);
   uuid2 = exports_external.string().uuid();
   scalar = exports_external.union([exports_external.string().max(4096), exports_external.number().finite(), exports_external.boolean(), exports_external.null()]);
   comment = exports_external.object({
@@ -26146,7 +26785,9 @@ var init_schema2 = __esm(() => {
   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(),
@@ -26162,7 +26803,10 @@ var init_schema2 = __esm(() => {
   }).strict();
   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();
   bindingLookupSchema = exports_external.object({
@@ -26180,6 +26824,7 @@ function taskManifestPlanSlug(manifest, planId) {
   const base = normalizeSlug(manifest.plan.key) || normalizeSlug(manifest.plan.name) || "plan";
   return `${base}-${planId}`;
 }
+var TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE = "deterministic-v1";
 var init_plan_slug = () => {};
 
 // src/task-manifest/backend.ts
@@ -26193,11 +26838,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
@@ -26250,9 +26897,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,
@@ -26264,12 +26917,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,
@@ -26283,6 +26952,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),
@@ -26294,10 +26971,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,
@@ -26310,6 +27014,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()`
   ];
 }
@@ -26334,6 +27042,39 @@ function safeIdentifier2(value, field) {
 function parseJson(value) {
   return typeof value === "string" ? JSON.parse(value) : value;
 }
+function parseApplyResult(value, duplicate) {
+  const parsed = parseJson(value);
+  return {
+    ...parsed,
+    duplicate,
+    receipt: {
+      ...parsed.receipt,
+      step_id: parsed.receipt.step_id ?? "legacy-apply",
+      precondition_digest: parsed.receipt.precondition_digest ?? "0".repeat(64),
+      outcome: parsed.receipt.outcome ?? "accepted",
+      reason: parsed.receipt.reason ?? null,
+      duplicate_of_receipt_id: parsed.receipt.duplicate_of_receipt_id ?? null
+    }
+  };
+}
+function validatePostgresPlanSlug(manifest, planId, slug, provenance) {
+  if (provenance === TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE) {
+    const expected = taskManifestPlanSlug(manifest, planId);
+    if (slug !== expected) {
+      throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: plan slug changed since apply");
+    }
+    return expected;
+  }
+  if (provenance !== null && provenance !== undefined) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: unknown plan slug provenance");
+  }
+  if (slug === null || slug === undefined)
+    return null;
+  if (slug !== null && slug !== undefined) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: legacy PostgreSQL plan slug must be NULL");
+  }
+  return null;
+}
 function timestamp2(value) {
   return value instanceof Date ? value.toISOString() : new Date(String(value)).toISOString();
 }
@@ -26341,6 +27082,41 @@ function fault(faults, point) {
   if (faults.points.has(point))
     throw new Error(`Injected task-manifest fault at ${point}`);
 }
+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 receiptFromRow3(row) {
   return {
     receipt_id: String(row["receipt_id"]),
@@ -26349,9 +27125,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: timestamp2(row["created_at"])
@@ -26469,46 +27250,89 @@ class PostgresTodosTaskManifestBackend {
       now3
     ]);
   }
+  async persistTerminal(tx, input, reason) {
+    const result = terminalApplyResult(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] ? parseApplyResult(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 parseApplyResult(terminal.rows[0]["result_json"], true);
+      }
       const existing = await tx.query("SELECT * FROM todos_task_manifest_bindings WHERE tenant_id = $1 AND operation_id = $2 LIMIT 1 FOR UPDATE", [this.tenantId, manifest.operation_id]);
       if (existing.rows[0]) {
         const binding = existing.rows[0];
-        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest) {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Operation is already bound to a different request");
+        if (binding["idempotency_key"] !== manifest.idempotency_key || binding["request_digest"] !== input.request_digest || binding["step_id"] !== manifest.step_id || binding["precondition_digest"] !== manifest.precondition_digest) {
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
         }
         if (binding["state"] !== "applied") {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_GRAPH_CONFLICT", "Operation was already compensated");
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_GRAPH_CONFLICT");
         }
-        return { ...parseJson(binding["result_json"]), duplicate: true };
+        return parseApplyResult(binding["result_json"], true);
       }
       const reused = await tx.query("SELECT operation_id FROM todos_task_manifest_bindings WHERE tenant_id = $1 AND idempotency_key = $2 LIMIT 1", [this.tenantId, manifest.idempotency_key]);
       if (reused.rows[0])
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT", "Idempotency key is already used");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_CONFLICT");
+      if (manifest.idempotency_key !== input.expected_idempotency_key) {
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_IDEMPOTENCY_MISMATCH");
+      }
       if (manifest.if_binding_version !== undefined && manifest.if_binding_version !== 0) {
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_CAS_CONFLICT", "New manifest binding version must be 0");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_CAS_CONFLICT");
       }
       const project = await tx.query(`SELECT 1 AS found FROM ${this.tableName}
         WHERE service = $1 AND object_type = 'projects' AND object_id = $2 AND deleted_at IS NULL LIMIT 1`, [this.service, manifest.project_id]);
       if (!project.rows[0])
-        throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Project does not exist");
+        return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
       if (manifest.task_list_id) {
         const taskList = await tx.query(`SELECT payload FROM ${this.tableName}
           WHERE service = $1 AND object_type = 'task_lists' AND object_id = $2 AND deleted_at IS NULL LIMIT 1`, [this.service, manifest.task_list_id]);
         const payload = taskList.rows[0] ? parseJson(taskList.rows[0]["payload"]) : null;
         if (!payload || payload["project_id"] !== manifest.project_id) {
-          throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_FOREIGN_REFERENCE", "Task list does not belong to the project");
+          return this.persistTerminal(tx, input, "TODOS_TASK_MANIFEST_FOREIGN_REFERENCE");
         }
       }
       const objectIds = [input.graph.plan_id, ...Object.values(input.graph.task_ids), ...input.graph.comment_ids, ...input.graph.verification_ids, ...input.graph.dependency_ids];
       const conflict = await tx.query(`SELECT object_id FROM ${this.tableName}
         WHERE service = $1 AND object_id IN (${placeholders(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);
       fault(faults, "after_plan_write");
       for (const task2 of manifest.tasks) {
@@ -26578,9 +27402,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
@@ -26597,14 +27426,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
@@ -26623,14 +27456,18 @@ class PostgresTodosTaskManifestBackend {
       }
       fault(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,
@@ -26643,9 +27480,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 parseApplyResult(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 { ...parseJson(result.rows[0]["result_json"]), duplicate: false };
+    return parseApplyResult(terminal.rows[0]["result_json"], false);
   }
   async lookupBindingByPlanId(planId) {
     await this.ensureSchema();
@@ -26656,6 +27496,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,
@@ -26663,6 +27504,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
@@ -26749,6 +27591,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
@@ -26763,12 +27609,18 @@ class PostgresTodosTaskManifestBackend {
          LIMIT 1`, [this.tenantId, input.receipt_id]);
       if (delivered.rows[0])
         throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_COMPENSATION_REFUSED", "Compensation refused: delivered outbox row exists");
-      const applyResult = parseJson(applyRow["result_json"]);
+      const applyResult = parseApplyResult(applyRow["result_json"], false);
       const manifest = parseJson(applyRow["manifest_json"]);
+      const manifestRecord = manifest;
+      const applyStepId = typeof manifestRecord["step_id"] === "string" ? String(manifestRecord["step_id"]) : null;
       const expectedEffects = [
         {
           topic: "todos.task-manifest.applied",
-          payload: { operation_id: manifest.operation_id, project_id: manifest.project_id }
+          payload: {
+            operation_id: manifest.operation_id,
+            ...applyStepId ? { step_id: applyStepId } : {},
+            project_id: manifest.project_id
+          }
         },
         ...(manifest.effects ?? []).map((effect2) => ({ topic: effect2.topic, payload: effect2.payload }))
       ];
@@ -26816,9 +27668,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] ? parseJson(planRow.rows[0]["payload"]) : null;
+      const planExpected = planPayload({ manifest, graph: applyResult.graph, now: appliedAt });
+      planExpected.slug = validatePostgresPlanSlug(manifest, applyResult.graph.plan_id, actualPlan?.["slug"], applyRow["slug_provenance"]);
       expectedPayloads.set(applyResult.graph.plan_id, {
         type: "plans",
-        payload: canonicalJson(planPayload({ manifest, graph: applyResult.graph, now: appliedAt }))
+        payload: canonicalJson(planExpected)
       });
       for (const task2 of manifest.tasks)
         expectedPayloads.set(applyResult.graph.task_ids[task2.key], {
@@ -26918,14 +27776,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,
@@ -26982,36 +27843,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, now3) {
   const parsed = parseTodosTaskManifest(input);
   const requestBytes = Buffer.byteLength(canonicalJson(parsed), "utf8");
   if (requestBytes > TODOS_TASK_MANIFEST_BOUNDS.request_bytes) {
     throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_BOUNDS_EXCEEDED", `Task manifest requires ${requestBytes} bytes but the bound is ${TODOS_TASK_MANIFEST_BOUNDS.request_bytes}`, { request_bytes: requestBytes, request_byte_limit: TODOS_TASK_MANIFEST_BOUNDS.request_bytes });
   }
+  const { idempotency_key: _idempotencyKey, ...request } = parsed;
+  const request_digest = taskManifestRequestDigest(request);
   const manifest = sanitizeManifest(parsed);
+  const expectedPreconditionDigest = deriveTodosTaskManifestApplyPreconditionDigest(manifest);
+  if (manifest.precondition_digest !== expectedPreconditionDigest) {
+    throw new TodosTaskManifestError("TODOS_TASK_MANIFEST_DIGEST_MISMATCH", "precondition_digest does not match the exact apply target and binding version", { expected_precondition_digest: expectedPreconditionDigest });
+  }
+  const expectedIdempotencyKey = deriveTodosTaskManifestIdempotencyKey({
+    operation_id: manifest.operation_id,
+    step_id: manifest.step_id,
+    direction: "apply",
+    target_selector: manifest.project_id,
+    request_digest,
+    precondition_digest: manifest.precondition_digest
+  });
   const task_ids = Object.fromEntries(manifest.tasks.map((task2) => [
     task2.key,
-    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "task", task2.key)
+    deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "task", task2.key)
   ]));
   const graph = {
-    plan_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "plan", manifest.plan.key),
+    plan_id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "plan", manifest.plan.key),
     task_ids,
-    comment_ids: manifest.tasks.flatMap((task2) => (task2.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "comment", task2.key, String(index)))),
-    verification_ids: manifest.tasks.flatMap((task2) => (task2.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "verification", task2.key, String(index)))),
+    comment_ids: manifest.tasks.flatMap((task2) => (task2.comments ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "comment", task2.key, String(index)))),
+    verification_ids: manifest.tasks.flatMap((task2) => (task2.verifications ?? []).map((_, index) => deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "verification", task2.key, String(index)))),
     dependency_ids: (manifest.dependencies ?? []).map((edge) => `${task_ids[edge.task]}::${task_ids[edge.depends_on]}`)
   };
-  const request_digest = canonicalDigest(parsed);
   const effectInputs = [
     {
       topic: "todos.task-manifest.applied",
-      payload: { operation_id: manifest.operation_id, project_id: manifest.project_id }
+      payload: { operation_id: manifest.operation_id, step_id: manifest.step_id, project_id: manifest.project_id }
     },
     ...manifest.effects ?? []
   ];
   const outbox = effectInputs.map((effect2, index) => {
     const payload = { ...effect2.payload };
     return {
-      id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, "outbox", String(index)),
+      id: deterministicUuid(TODOS_TASK_MANIFEST_ROUTE, manifest.operation_id, manifest.step_id, "outbox", String(index)),
       topic: effect2.topic,
       payload,
       digest: canonicalDigest({ topic: effect2.topic, payload })
@@ -27021,11 +27929,14 @@ function normalize(input, now3) {
   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: now3
+    now: now3,
+    plan_slug_provenance: TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE
   };
 }
 function sanitizeManifest(manifest) {
@@ -27083,6 +27994,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,
@@ -27112,7 +28027,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) {
@@ -27145,18 +28064,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()
@@ -29661,9 +30610,24 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         TaskManifestBounds: taskManifestBoundsSchema,
         TaskManifestCapability: taskManifestCapabilitySchema,
         TaskManifestCapabilityResponse: taskManifestCapabilityResponseSchema,
+        TaskManifest: taskManifestSchema,
+        TaskManifestReceipt: taskManifestReceiptSchema,
+        TaskManifestApplyResult: taskManifestApplyResultSchema,
+        TaskManifestApplyResponse: taskManifestApplyResponseSchema,
+        TaskManifestCompensateRequest: taskManifestCompensateRequestSchema,
+        TaskManifestCompensationResult: taskManifestCompensationResultSchema,
+        TaskManifestCompensateResponse: taskManifestCompensateResponseSchema,
+        TaskManifestReadExactRequest: taskManifestReadExactRequestSchema,
         TaskManifestBindingLookupRequest: taskManifestBindingLookupRequestSchema,
         TaskManifestBindingLookupResult: taskManifestBindingLookupResultSchema,
         TaskManifestBindingLookupResponse: taskManifestBindingLookupResponseSchema,
+        ProjectRegistrationCapability: projectRegistrationCapabilitySchema,
+        ProjectRegistrationReceipt: projectRegistrationReceiptSchema,
+        ProjectRegistrationRequest: projectRegistrationRequestSchema,
+        ProjectRegistrationLookupRequest: projectRegistrationLookupRequestSchema,
+        PriorRegistrationAdoptionValidation: priorRegistrationAdoptionValidationSchema,
+        ProjectResource: projectResourceSchema,
+        ProjectResourcePage: projectResourcePageSchema,
         TaskList: taskListSchema,
         ProjectTaskListEnsureReceipt: projectTaskListEnsureReceiptSchema,
         ProjectTaskListEnsureResult: projectTaskListEnsureResultSchema,
@@ -29706,6 +30670,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             priority: { type: "string", enum: [...TASK_PRIORITIES] },
             assigned_to: { type: "string" },
             project_id: { type: "string", nullable: true },
+            parent_id: { type: "string", nullable: true },
             plan_id: { type: "string", nullable: true },
             task_list_id: { type: "string", nullable: true },
             version: { type: "number" }
@@ -30660,6 +31625,341 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     },
     security: [{ apiKey: [] }],
     paths: {
+      "/v1/project-registration/capability": {
+        get: {
+          operationId: "getProjectRegistrationCapability",
+          summary: "Read the live package-owned Projects to Todos registration capability",
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["capability"],
+                    properties: {
+                      capability: {
+                        $ref: "#/components/schemas/ProjectRegistrationCapability"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "/v1/project-registration/resources": {
+        get: {
+          operationId: "listProjectRegistrationResources",
+          summary: "List one bounded page of stable Todos identities for an exact Projects workspace id",
+          parameters: [
+            {
+              name: "source_project_id",
+              in: "query",
+              required: true,
+              schema: { type: "string" }
+            },
+            {
+              name: "include_anchors",
+              in: "query",
+              schema: { type: "boolean", default: false }
+            },
+            {
+              name: "limit",
+              in: "query",
+              schema: { type: "integer", minimum: 1, maximum: 500, default: 100 }
+            },
+            {
+              name: "cursor",
+              in: "query",
+              schema: { type: "string" }
+            }
+          ],
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["page"],
+                    properties: {
+                      page: { $ref: "#/components/schemas/ProjectResourcePage" }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/create": {
+        post: {
+          operationId: "createProjectRegistrationResource",
+          summary: "Create or deterministically bind one Projects to Todos resource",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/ProjectRegistrationRequest" }
+              }
+            }
+          },
+          responses: {
+            "201": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["receipt"],
+                    properties: {
+                      receipt: { $ref: "#/components/schemas/ProjectRegistrationReceipt" }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/read-exact": {
+        post: {
+          operationId: "readExactProjectRegistrationResource",
+          summary: "Read one registered project or task list by exact full UUID",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  additionalProperties: false,
+                  required: [
+                    "resource_kind",
+                    "target_id",
+                    "response_byte_limit",
+                    "time_budget_ms"
+                  ],
+                  properties: {
+                    resource_kind: { type: "string", enum: ["project", "task_list"] },
+                    target_id: { type: "string", format: "uuid" },
+                    ...projectRegistrationBoundsProperties
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["record"],
+                    properties: {
+                      record: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["target_id", "revision", "digest"],
+                        properties: {
+                          target_id: { type: "string", format: "uuid" },
+                          revision: { type: "string" },
+                          digest: { type: "string" }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/receipts/lookup": {
+        post: {
+          operationId: "lookupProjectRegistrationReceipt",
+          summary: "Recover one exact immutable terminal registration receipt",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/ProjectRegistrationLookupRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["receipt", "response_control"],
+                    properties: {
+                      receipt: { $ref: "#/components/schemas/ProjectRegistrationReceipt" },
+                      response_control: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: [
+                          "response_byte_limit",
+                          "time_budget_ms",
+                          "response_bytes",
+                          "elapsed_ms",
+                          "complete",
+                          "truncated"
+                        ],
+                        properties: {
+                          ...projectRegistrationBoundsProperties,
+                          response_bytes: { type: "integer", minimum: 0 },
+                          elapsed_ms: { type: "integer", minimum: 0 },
+                          complete: { type: "boolean", enum: [true] },
+                          truncated: { type: "boolean", enum: [false] }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/validate-prior-adoption": {
+        post: {
+          operationId: "validatePriorRegistrationAdoption",
+          summary: "Fail closed unless one prior accepted registration still matches its exact current resource",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  additionalProperties: false,
+                  required: ["source_request", "source_receipt", "current_record"],
+                  properties: {
+                    source_request: { $ref: "#/components/schemas/ProjectRegistrationRequest" },
+                    source_receipt: { $ref: "#/components/schemas/ProjectRegistrationReceipt" },
+                    current_record: {
+                      oneOf: [
+                        { $ref: "#/components/schemas/Project" },
+                        { $ref: "#/components/schemas/TaskList" }
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["validation"],
+                    properties: {
+                      validation: {
+                        $ref: "#/components/schemas/PriorRegistrationAdoptionValidation"
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/compensate": {
+        post: {
+          operationId: "compensateProjectRegistrationResource",
+          summary: "Conditionally remove an unchanged receipt-owned registration resource",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/ProjectRegistrationRequest" }
+              }
+            }
+          },
+          responses: {
+            "201": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["receipt"],
+                    properties: {
+                      receipt: { $ref: "#/components/schemas/ProjectRegistrationReceipt" }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/project-registration/verify-inverse": {
+        post: {
+          operationId: "verifyInverseProjectRegistrationResource",
+          summary: "Verify exact absence after conditional registration compensation",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/ProjectRegistrationRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["verification"],
+                    properties: {
+                      verification: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["target_id", "accepted_receipt_id", "absent", "digest"],
+                        properties: {
+                          target_id: { type: "string", format: "uuid" },
+                          accepted_receipt_id: { type: "string" },
+                          absent: { type: "boolean", enum: [true] },
+                          digest: { type: "string" }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
       "/v1/task-manifest/capability": {
         get: {
           operationId: "getTaskManifestCapability",
@@ -30677,6 +31977,82 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           }
         }
       },
+      "/v1/task-manifest/apply": {
+        post: {
+          operationId: "applyTaskManifest",
+          summary: "Apply one exact task-manifest graph through the Todos authority",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/TaskManifest" }
+              }
+            }
+          },
+          responses: {
+            "201": {
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/TaskManifestApplyResponse" }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "503": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/task-manifest/read-exact": {
+        post: {
+          operationId: "readExactTaskManifest",
+          summary: "Read one exact immutable task-manifest apply receipt",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/TaskManifestReadExactRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/TaskManifestApplyResponse" }
+                }
+              }
+            },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/task-manifest/compensate": {
+        post: {
+          operationId: "compensateTaskManifest",
+          summary: "Compensate one exact untouched task-manifest graph with CAS protection",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/TaskManifestCompensateRequest" }
+              }
+            }
+          },
+          responses: {
+            "201": {
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/TaskManifestCompensateResponse" }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
       "/v1/task-manifest/bindings/lookup": {
         post: {
           operationId: "lookupTaskManifestBinding",
@@ -31537,7 +32913,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     }
   });
 }
-var taskSchema, taskManifestBoundsSchema, taskManifestCapabilitySchema, taskManifestCapabilityResponseSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, staleLockHandoffInputSchema, staleLockHandoffReceiptSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
+var taskSchema, taskManifestBoundsSchema, taskManifestCapabilitySchema, taskManifestCapabilityResponseSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestSchema, taskManifestReceiptSchema, taskManifestApplyResultSchema, taskManifestApplyResponseSchema, taskManifestCompensateRequestSchema, taskManifestCompensationResultSchema, taskManifestCompensateResponseSchema, taskManifestReadExactRequestSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, staleLockHandoffInputSchema, staleLockHandoffReceiptSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema, projectRegistrationBoundsProperties, projectRegistrationReceiptSchema, projectRegistrationCapabilitySchema, projectRegistrationRequestSchema, projectRegistrationLookupRequestSchema, priorRegistrationAdoptionValidationSchema, projectResourceSchema, projectResourcePageSchema;
 var init_openapi = __esm(() => {
   init_package_version();
   init_types();
@@ -31599,6 +32975,10 @@ var init_openapi = __esm(() => {
       "tenant_id",
       "backend",
       "deterministic_ids",
+      "operation_step_identity",
+      "deterministic_idempotency_keys",
+      "terminal_nonacceptance_receipts",
+      "plan_slug_provenance",
       "immutable_receipts",
       "transactional_outbox",
       "idempotent_outbox_delivery",
@@ -31614,6 +32994,10 @@ var init_openapi = __esm(() => {
       tenant_id: { type: "string", minLength: 1, maxLength: 200 },
       backend: { type: "string", enum: ["sqlite", "postgresql", "http"] },
       deterministic_ids: { type: "boolean", enum: [true] },
+      operation_step_identity: { type: "boolean", enum: [true] },
+      deterministic_idempotency_keys: { type: "boolean", enum: [true] },
+      terminal_nonacceptance_receipts: { type: "boolean", enum: [true] },
+      plan_slug_provenance: { type: "string", enum: ["deterministic-v1"] },
       immutable_receipts: { type: "boolean", enum: [true] },
       transactional_outbox: { type: "boolean", enum: [true] },
       idempotent_outbox_delivery: { type: "boolean", enum: [true] },
@@ -31667,6 +33051,8 @@ var init_openapi = __esm(() => {
       "schema_version",
       "tenant_id",
       "plan_id",
+      "operation_id",
+      "step_id",
       "apply_receipt_id",
       "binding_version",
       "state"
@@ -31677,11 +33063,169 @@ var init_openapi = __esm(() => {
       schema_version: { type: "integer", enum: [1] },
       tenant_id: { type: "string" },
       plan_id: { type: "string", format: "uuid" },
+      operation_id: { type: "string", minLength: 1, maxLength: 200 },
+      step_id: { type: "string", minLength: 1, maxLength: 200 },
       apply_receipt_id: { type: "string", format: "uuid" },
       binding_version: { type: "integer", minimum: 1 },
       state: { type: "string", enum: ["applied", "compensated"] }
     }
   };
+  taskManifestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "version",
+      "operation_id",
+      "step_id",
+      "idempotency_key",
+      "precondition_digest",
+      "project_id",
+      "plan",
+      "tasks"
+    ],
+    properties: {
+      version: { type: "integer", enum: [1] },
+      operation_id: { type: "string", minLength: 1, maxLength: 200 },
+      step_id: { type: "string", minLength: 1, maxLength: 200 },
+      idempotency_key: { type: "string", pattern: "^tmk_[0-9a-f]{48}$" },
+      precondition_digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+      project_id: { type: "string", format: "uuid" },
+      task_list_id: { type: "string", format: "uuid" },
+      if_binding_version: { type: "integer", minimum: 0 },
+      plan: {
+        type: "object",
+        additionalProperties: false,
+        required: ["key", "name"],
+        properties: {
+          key: { type: "string", minLength: 1, maxLength: 200 },
+          name: { type: "string", minLength: 1, maxLength: 200 },
+          description: { type: "string" },
+          status: { type: "string", enum: ["active", "completed", "archived"] }
+        }
+      },
+      tasks: {
+        type: "array",
+        minItems: 1,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["key", "title"],
+          properties: {
+            key: { type: "string", minLength: 1, maxLength: 200 },
+            title: { type: "string", minLength: 1, maxLength: 200 },
+            description: { type: "string" },
+            status: { type: "string", enum: ["pending", "in_progress", "completed", "failed", "cancelled"] },
+            priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            assigned_to: { type: "string" },
+            created_by: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            metadata: { type: "object", additionalProperties: true },
+            comments: { type: "array", items: { type: "object", additionalProperties: true } },
+            verifications: { type: "array", items: { type: "object", additionalProperties: true } }
+          }
+        }
+      },
+      dependencies: { type: "array", items: { type: "object", additionalProperties: true } },
+      effects: { type: "array", items: { type: "object", additionalProperties: true } }
+    }
+  };
+  taskManifestReceiptSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "receipt_id",
+      "authority",
+      "route",
+      "schema_version",
+      "kind",
+      "operation_id",
+      "step_id",
+      "idempotency_key",
+      "request_digest",
+      "precondition_digest",
+      "result_digest",
+      "outcome",
+      "reason",
+      "duplicate_of_receipt_id",
+      "binding_version",
+      "apply_receipt_id",
+      "created_at"
+    ],
+    properties: {
+      receipt_id: { type: "string", format: "uuid" },
+      authority: { type: "string", enum: ["todos"] },
+      route: { type: "string", enum: ["todos.task-manifest.v1"] },
+      schema_version: { type: "integer", enum: [1] },
+      kind: { type: "string", enum: ["apply", "compensate"] },
+      operation_id: { type: "string" },
+      step_id: { type: "string" },
+      idempotency_key: { type: "string" },
+      request_digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+      precondition_digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+      result_digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+      outcome: { type: "string", enum: ["accepted", "duplicate_of_accepted", "terminal_nonacceptance"] },
+      reason: { type: "string", nullable: true },
+      duplicate_of_receipt_id: { type: "string", nullable: true },
+      binding_version: { type: "integer", minimum: 0 },
+      apply_receipt_id: { type: "string", nullable: true },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
+  taskManifestApplyResultSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["duplicate", "receipt", "graph", "readback", "outbox_ids", "result_digest"],
+    properties: {
+      duplicate: { type: "boolean" },
+      receipt: { $ref: "#/components/schemas/TaskManifestReceipt" },
+      graph: { type: "object", additionalProperties: true },
+      readback: { type: "object", additionalProperties: true },
+      outbox_ids: { type: "array", items: { type: "string", format: "uuid" } },
+      result_digest: { type: "string", pattern: "^[0-9a-f]{64}$" }
+    }
+  };
+  taskManifestApplyResponseSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["result"],
+    properties: { result: { $ref: "#/components/schemas/TaskManifestApplyResult" } }
+  };
+  taskManifestCompensateRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["receipt_id", "operation_id", "step_id", "idempotency_key", "precondition_digest", "if_binding_version"],
+    properties: {
+      receipt_id: { type: "string", format: "uuid" },
+      operation_id: { type: "string" },
+      step_id: { type: "string" },
+      idempotency_key: { type: "string", pattern: "^tmk_[0-9a-f]{48}$" },
+      precondition_digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+      if_binding_version: { type: "integer", minimum: 1 }
+    }
+  };
+  taskManifestCompensationResultSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["duplicate", "receipt", "absent", "readback"],
+    properties: {
+      duplicate: { type: "boolean" },
+      receipt: { $ref: "#/components/schemas/TaskManifestReceipt" },
+      absent: { type: "boolean", enum: [true] },
+      readback: { type: "object", additionalProperties: true }
+    }
+  };
+  taskManifestCompensateResponseSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["result"],
+    properties: { result: { $ref: "#/components/schemas/TaskManifestCompensationResult" } }
+  };
+  taskManifestReadExactRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["receipt_id"],
+    properties: { receipt_id: { type: "string", format: "uuid" } }
+  };
   taskManifestBindingLookupResponseSchema = {
     type: "object",
     additionalProperties: false,
@@ -32031,6 +33575,292 @@ var init_openapi = __esm(() => {
       metadata: { type: "object", additionalProperties: true }
     }
   };
+  projectRegistrationBoundsProperties = {
+    response_byte_limit: { type: "integer", minimum: 1 },
+    time_budget_ms: { type: "integer", minimum: 1 }
+  };
+  projectRegistrationReceiptSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "receipt_id",
+      "authority",
+      "route",
+      "package_version",
+      "authority_id",
+      "tenant_id",
+      "corpus_id",
+      "operation_id",
+      "step_id",
+      "resource_kind",
+      "direction",
+      "idempotency_key",
+      "request_digest",
+      "precondition_digest",
+      "outcome",
+      "reason",
+      "target_id",
+      "result_revision",
+      "result_digest",
+      "duplicate_of_receipt_id",
+      "accepted_receipt_id",
+      "created_by_operation",
+      "created_at"
+    ],
+    properties: {
+      receipt_id: { type: "string" },
+      authority: { type: "string", enum: ["todos"] },
+      route: { type: "string", enum: ["todos.project-registration.v1"] },
+      package_version: { type: "string" },
+      authority_id: { type: "string" },
+      tenant_id: { type: "string" },
+      corpus_id: { type: "string" },
+      operation_id: { type: "string" },
+      step_id: { type: "string" },
+      resource_kind: { type: "string", enum: ["project", "task_list"] },
+      direction: { type: "string", enum: ["forward", "inverse"] },
+      idempotency_key: { type: "string" },
+      request_digest: { type: "string" },
+      precondition_digest: { type: "string" },
+      outcome: {
+        type: "string",
+        enum: ["accepted", "duplicate_of_accepted", "terminal_nonacceptance"]
+      },
+      reason: { type: "string", nullable: true },
+      target_id: { type: "string", format: "uuid", nullable: true },
+      result_revision: { type: "string", nullable: true },
+      result_digest: { type: "string", nullable: true },
+      duplicate_of_receipt_id: { type: "string", nullable: true },
+      accepted_receipt_id: { type: "string", nullable: true },
+      created_by_operation: { type: "boolean" },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
+  projectRegistrationCapabilitySchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "authority",
+      "route",
+      "package_version",
+      "authority_id",
+      "tenant_id",
+      "corpus_id",
+      "supported_resources",
+      "conditional_create",
+      "immutable_receipts",
+      "exact_terminal_lookup",
+      "exact_readback",
+      "bind_existing_adoption",
+      "prior_registration_adoption_validation",
+      "project_resource_enumeration",
+      "project_resource_page_limit",
+      "conditional_inverse",
+      "ambiguous_outcome_reconciliation"
+    ],
+    properties: {
+      authority: { type: "string", enum: ["todos"] },
+      route: { type: "string", enum: ["todos.project-registration.v1"] },
+      package_version: { type: "string" },
+      authority_id: { type: "string" },
+      tenant_id: { type: "string" },
+      corpus_id: { type: "string" },
+      supported_resources: {
+        type: "array",
+        items: { type: "string", enum: ["project", "task_list"] }
+      },
+      conditional_create: { type: "boolean", enum: [true] },
+      immutable_receipts: { type: "boolean", enum: [true] },
+      exact_terminal_lookup: { type: "boolean", enum: [true] },
+      exact_readback: { type: "boolean", enum: [true] },
+      bind_existing_adoption: { type: "boolean", enum: [true] },
+      prior_registration_adoption_validation: { type: "boolean", enum: [true] },
+      project_resource_enumeration: { type: "boolean", enum: [true] },
+      project_resource_page_limit: { type: "integer", minimum: 1 },
+      conditional_inverse: { type: "boolean", enum: [true] },
+      ambiguous_outcome_reconciliation: { type: "boolean", enum: [true] }
+    }
+  };
+  projectRegistrationRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "operation_id",
+      "step_id",
+      "resource_kind",
+      "direction",
+      "authority_route",
+      "package_version",
+      "authority_id",
+      "tenant_id",
+      "corpus_id",
+      "target_selector",
+      "idempotency_key",
+      "request_digest",
+      "precondition_digest",
+      "project_id",
+      "project_slug",
+      "project_name",
+      "desired",
+      "response_byte_limit",
+      "time_budget_ms"
+    ],
+    properties: {
+      operation_id: { type: "string" },
+      step_id: { type: "string" },
+      resource_kind: { type: "string", enum: ["project", "task_list"] },
+      direction: { type: "string", enum: ["forward", "inverse"] },
+      authority_route: { type: "string" },
+      package_version: { type: "string" },
+      authority_id: { type: "string" },
+      tenant_id: { type: "string" },
+      corpus_id: { type: "string" },
+      target_selector: { type: "string" },
+      idempotency_key: { type: "string" },
+      request_digest: { type: "string" },
+      precondition_digest: { type: "string" },
+      project_id: { type: "string" },
+      project_slug: { type: "string" },
+      project_name: { type: "string" },
+      desired: { type: "object", additionalProperties: true },
+      bind_existing: { type: "boolean" },
+      accepted_receipt: { $ref: "#/components/schemas/ProjectRegistrationReceipt" },
+      ...projectRegistrationBoundsProperties
+    }
+  };
+  projectRegistrationLookupRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "operation_id",
+      "step_id",
+      "resource_kind",
+      "direction",
+      "authority",
+      "authority_route",
+      "package_version",
+      "authority_id",
+      "tenant_id",
+      "corpus_id",
+      "target_selector",
+      "idempotency_key",
+      "max_items",
+      "response_byte_limit",
+      "time_budget_ms"
+    ],
+    properties: {
+      operation_id: { type: "string" },
+      step_id: { type: "string" },
+      resource_kind: { type: "string", enum: ["project", "task_list"] },
+      direction: { type: "string", enum: ["forward", "inverse"] },
+      authority: { type: "string", enum: ["todos"] },
+      authority_route: { type: "string" },
+      package_version: { type: "string" },
+      authority_id: { type: "string" },
+      tenant_id: { type: "string" },
+      corpus_id: { type: "string" },
+      target_selector: { type: "string" },
+      idempotency_key: { type: "string" },
+      target_id: { type: "string", format: "uuid" },
+      max_items: { type: "integer", enum: [1] },
+      ...projectRegistrationBoundsProperties
+    }
+  };
+  priorRegistrationAdoptionValidationSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "valid",
+      "resource_kind",
+      "target_id",
+      "source_receipt_id",
+      "accepted_receipt_id",
+      "source_outcome",
+      "created_at",
+      "current_revision",
+      "accepted_result_digest"
+    ],
+    properties: {
+      valid: { type: "boolean", enum: [true] },
+      resource_kind: { type: "string", enum: ["project", "task_list"] },
+      target_id: { type: "string", format: "uuid" },
+      source_receipt_id: { type: "string" },
+      accepted_receipt_id: { type: "string" },
+      source_outcome: { type: "string", enum: ["accepted", "duplicate_of_accepted"] },
+      created_at: { type: "string", format: "date-time" },
+      current_revision: { type: "string", format: "date-time" },
+      accepted_result_digest: { type: "string" }
+    }
+  };
+  projectResourceSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "source_project_id",
+      "kind",
+      "scope",
+      "target_id",
+      "parent_id",
+      "revision",
+      "digest"
+    ],
+    properties: {
+      source_project_id: { type: "string" },
+      kind: { type: "string", enum: ["project", "task_list", "plan", "task"] },
+      scope: { type: "string", enum: ["collection", "resource"] },
+      target_id: { type: "string", format: "uuid" },
+      parent_id: { type: "string", format: "uuid", nullable: true },
+      revision: { type: "string" },
+      digest: { type: "string" }
+    }
+  };
+  projectResourcePageSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "authority",
+      "route",
+      "package_version",
+      "authority_id",
+      "tenant_id",
+      "corpus_id",
+      "source_project_id",
+      "todos_project_id",
+      "task_list_id",
+      "include_anchors",
+      "collection_revision",
+      "limit",
+      "count",
+      "resources",
+      "has_more",
+      "next_cursor",
+      "complete",
+      "truncated"
+    ],
+    properties: {
+      authority: { type: "string", enum: ["todos"] },
+      route: { type: "string", enum: ["todos.project-registration.v1"] },
+      package_version: { type: "string" },
+      authority_id: { type: "string" },
+      tenant_id: { type: "string" },
+      corpus_id: { type: "string" },
+      source_project_id: { type: "string" },
+      todos_project_id: { type: "string", format: "uuid" },
+      task_list_id: { type: "string", format: "uuid" },
+      include_anchors: { type: "boolean" },
+      collection_revision: { type: "string" },
+      limit: { type: "integer", minimum: 1, maximum: 500 },
+      count: { type: "integer", minimum: 0 },
+      resources: {
+        type: "array",
+        items: { $ref: "#/components/schemas/ProjectResource" }
+      },
+      has_more: { type: "boolean" },
+      next_cursor: { type: "string", nullable: true },
+      complete: { type: "boolean" },
+      truncated: { type: "boolean", enum: [false] }
+    }
+  };
 });
 
 // src/server/pr-groups.ts
@@ -32177,11 +34007,11 @@ function canonicalJson2(value) {
     return `[${value.map(canonicalJson2).join(",")}]`;
   return `{${Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key2, item]) => `${JSON.stringify(key2)}:${canonicalJson2(item)}`).join(",")}}`;
 }
-function digest(value) {
+function digest2(value) {
   return createHash9("sha256").update(canonicalJson2(value)).digest("hex");
 }
 function deriveIdempotencyKey(projectId, slug) {
-  return `ptlk_${digest({ project_id: projectId, slug }).slice(0, 48)}`;
+  return `ptlk_${digest2({ project_id: projectId, slug }).slice(0, 48)}`;
 }
 function normalizeIdempotencyKey(value, projectId, slug) {
   const key2 = value?.trim() || deriveIdempotencyKey(projectId, slug);
@@ -32190,13 +34020,13 @@ function normalizeIdempotencyKey(value, projectId, slug) {
   }
   return key2;
 }
-function receiptId2(projectId, slug, idempotencyKey) {
-  return `ptlr_${digest({ project_id: projectId, slug, idempotency_key: idempotencyKey }).slice(0, 48)}`;
+function receiptId2(projectId, slug, idempotencyKey2) {
+  return `ptlr_${digest2({ project_id: projectId, slug, idempotency_key: idempotencyKey2 }).slice(0, 48)}`;
 }
 function semanticListDigest(list) {
   const metadata = { ...list.metadata ?? {} };
   delete metadata[RECEIPT_METADATA_KEY];
-  return digest({
+  return digest2({
     project_id: list.project_id,
     slug: list.slug,
     name: list.name,
@@ -32213,10 +34043,10 @@ function storedMarker(list) {
     return null;
   return marker;
 }
-function receiptFor(store, project, list, idempotencyKey) {
+function receiptFor(store, project, list, idempotencyKey2) {
   const marker = storedMarker(list);
   const owned = marker?.project_id === project.id && marker.slug === list.slug;
-  if (owned && marker.idempotency_key !== idempotencyKey) {
+  if (owned && marker.idempotency_key !== idempotencyKey2) {
     throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_IDEMPOTENCY_CONFLICT", "The operation-owned task list was created under a different idempotency key", {
       project_id: project.id,
       task_list_id: list.id,
@@ -32225,8 +34055,8 @@ function receiptFor(store, project, list, idempotencyKey) {
   }
   return {
     schema_version: PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION,
-    receipt_id: owned ? marker.receipt_id : `ptlr_existing_${digest({ project_id: project.id, task_list_id: list.id }).slice(0, 39)}`,
-    idempotency_key: owned ? marker.idempotency_key : idempotencyKey,
+    receipt_id: owned ? marker.receipt_id : `ptlr_existing_${digest2({ project_id: project.id, task_list_id: list.id }).slice(0, 39)}`,
+    idempotency_key: owned ? marker.idempotency_key : idempotencyKey2,
     project_id: project.id,
     task_list_id: list.id,
     slug: list.slug,
@@ -32278,20 +34108,20 @@ async function applyProjectTaskListEnsure(store, projectId, options) {
     });
   }
   const slug = project.task_list_id;
-  const idempotencyKey = normalizeIdempotencyKey(options.idempotency_key, project.id, slug);
+  const idempotencyKey2 = normalizeIdempotencyKey(options.idempotency_key, project.id, slug);
   if (state.scoped) {
     return {
       mode: "apply",
       action: "already_present",
       project,
       task_list: state.scoped,
-      receipt: receiptFor(store, project, state.scoped, idempotencyKey)
+      receipt: receiptFor(store, project, state.scoped, idempotencyKey2)
     };
   }
   const marker = {
     schema_version: PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION,
-    receipt_id: receiptId2(project.id, slug, idempotencyKey),
-    idempotency_key: idempotencyKey,
+    receipt_id: receiptId2(project.id, slug, idempotencyKey2),
+    idempotency_key: idempotencyKey2,
     project_id: project.id,
     slug,
     result_digest: semanticListDigest({
@@ -32329,7 +34159,7 @@ async function applyProjectTaskListEnsure(store, projectId, options) {
       action: "already_present",
       project: raced.project,
       task_list: raced.scoped,
-      receipt: receiptFor(store, raced.project, raced.scoped, idempotencyKey)
+      receipt: receiptFor(store, raced.project, raced.scoped, idempotencyKey2)
     };
   }
   const projectReadback = await store.projects.get(project.id);
@@ -32359,7 +34189,7 @@ async function applyProjectTaskListEnsure(store, projectId, options) {
     action: "created",
     project: projectReadback,
     task_list: readback,
-    receipt: receiptFor(store, projectReadback, readback, idempotencyKey)
+    receipt: receiptFor(store, projectReadback, readback, idempotencyKey2)
   };
 }
 async function rollbackProjectTaskListEnsure(store, projectId, options) {
@@ -32404,7 +34234,7 @@ async function rollbackProjectTaskListEnsure(store, projectId, options) {
     project_id: project.id,
     task_list_id: list.id,
     accepted_receipt_id: options.receipt_id,
-    rollback_receipt_id: `ptlr_inverse_${digest({ accepted_receipt_id: options.receipt_id }).slice(0, 38)}`,
+    rollback_receipt_id: `ptlr_inverse_${digest2({ accepted_receipt_id: options.receipt_id }).slice(0, 38)}`,
     removed_at: new Date().toISOString()
   };
 }
@@ -32603,6 +34433,9 @@ function validateTaskPatchVocabulary(value) {
     if (!parsed.ok)
       return { ok: false, message: parsed.message };
   }
+  if (body2.parent_id !== undefined && body2.parent_id !== null && (typeof body2.parent_id !== "string" || !body2.parent_id.trim())) {
+    return { ok: false, message: "parent_id must be a non-empty task id or null" };
+  }
   return { ok: true, patch: body2 };
 }
 function validateProjectPatch(value) {
@@ -33087,8 +34920,8 @@ async function handleV1Request(req, url, dependencies = {}) {
           }
           const created = await store.tasks.create(body2, storageContext);
           const persisted = created?.id ? await store.tasks.get(created.id, storageContext) : null;
-          if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== (body2.parent_id ?? null)) {
-            return error(500, "TASK_CREATE_PERSISTENCE_UNVERIFIED: task create was acknowledged but authoritative readback did not return the same stored task id and parent_id", { code: "TASK_CREATE_PERSISTENCE_UNVERIFIED" });
+          if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== (body2.parent_id ?? null) || (persisted.plan_id ?? null) !== (body2.plan_id ?? null)) {
+            return error(500, "TASK_CREATE_PERSISTENCE_UNVERIFIED: task create was acknowledged but authoritative readback did not return the same stored task id, parent_id, and plan_id", { code: "TASK_CREATE_PERSISTENCE_UNVERIFIED" });
           }
           return json5({ task: persisted }, 201);
         }
@@ -33962,6 +35795,15 @@ async function handleV1Request(req, url, dependencies = {}) {
     if (e instanceof TaskNotFoundError) {
       return error(404, e.message, { code: TaskNotFoundError.code });
     }
+    if (e instanceof VersionConflictError) {
+      return error(409, e.message, {
+        code: VersionConflictError.code,
+        conflict: true,
+        task_id: e.taskId,
+        expected_version: e.expectedVersion,
+        current_version: e.actualVersion
+      });
+    }
     if (e instanceof StaleLockHandoffError) {
       const status2 = e.code === "STALE_LOCK_HANDOFF_INVALID_TASK_ID" || e.code === "STALE_LOCK_HANDOFF_INVALID_INPUT" ? 400 : e.code === "STALE_LOCK_HANDOFF_ACTOR_MISMATCH" ? 403 : 409;
       return error(status2, e.message, {
@@ -52577,16 +54419,16 @@ function createHasnaStorageClient(name, transport) {
       }
     },
     async create(resource, body2, options = {}) {
-      const { idempotencyKey, ...rest } = options;
+      const { idempotencyKey: idempotencyKey2, ...rest } = options;
       return transport.post(resourcePath(resource), body2, {
         ...rest,
-        idempotencyKey: idempotencyKey ?? newIdempotencyKey()
+        idempotencyKey: idempotencyKey2 ?? newIdempotencyKey()
       });
     },
     async update(resource, id, patch, options = {}) {
-      const { method = "PATCH", idempotencyKey, ...rest } = options;
+      const { method = "PATCH", idempotencyKey: idempotencyKey2, ...rest } = options;
       const call = method === "PUT" ? transport.put : transport.patch;
-      return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
+      return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey2 ? { idempotencyKey: idempotencyKey2 } : {} });
     },
     async delete(resource, id, options = {}) {
       try {
@@ -64770,6 +66612,11 @@ var init_http_client = __esm(() => {
   ]);
 });
 
+// src/project-registration/page-validation.ts
+var init_page_validation = __esm(() => {
+  init_types3();
+});
+
 // src/cli/cloud-router.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { resolve as resolvePath } from "path";
@@ -65168,12 +67015,39 @@ async function cloudListTasks(client, filter = {}) {
   union3.sort(compareCloudTaskOrder);
   return union3.slice(start, windowEnd);
 }
+async function cloudResolveTaskRef(client, ref) {
+  const input = ref.trim().toLowerCase();
+  if (!input)
+    throw new Error("Task reference must not be empty");
+  if (UUID_RE.test(input))
+    return input;
+  let task2;
+  try {
+    task2 = await cloudGetTask(client, input);
+  } catch (error3) {
+    const status2 = error3 && typeof error3 === "object" ? error3.status : undefined;
+    if (status2 === 409) {
+      const body2 = error3 && typeof error3 === "object" ? error3.body : undefined;
+      const authorityMessage = body2 && typeof body2 === "object" && !Array.isArray(body2) ? body2.error : undefined;
+      throw new Error(typeof authorityMessage === "string" && authorityMessage.trim() ? authorityMessage : `Task reference is ambiguous: "${ref}"`);
+    }
+    throw error3;
+  }
+  if (task2 && typeof task2.id === "string" && (task2.short_id?.toLowerCase() === input || task2.id.toLowerCase().startsWith(input))) {
+    return task2.id;
+  }
+  if (task2) {
+    throw new Error(`Task not found: ${ref} \u2014 the authority returned a task carrying neither this short id ` + "nor this id prefix, so the reference was not resolved.");
+  }
+  throw new Error(`Task not found: ${ref} \u2014 the authority resolved no task for this short reference. ` + "That is not proof the task is absent: an authority predating server-side " + "short-reference resolution answers EVERY short id and id prefix with the same 404. " + "Retry with the full task UUID to tell the two apart, or deploy the current " + "@hasna/todos /v1 server.");
+}
 async function cloudGetTask(client, id) {
   const raw = await client.get("tasks", id);
   return raw == null ? null : unwrapTask(raw);
 }
 async function cloudCreateTask(client, input, verification2 = {}) {
   const expectedParentId = typeof input["parent_id"] === "string" ? input["parent_id"] : null;
+  const expectedPlanId = typeof input["plan_id"] === "string" ? input["plan_id"] : null;
   const expectedCreatedBy = typeof verification2.expectedCreatedBy === "string" && verification2.expectedCreatedBy.trim() ? verification2.expectedCreatedBy : null;
   if (expectedCreatedBy !== null) {
     await requireTaskCreatorCapability(client);
@@ -65186,9 +67060,9 @@ async function cloudCreateTask(client, input, verification2 = {}) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: configured Todos authority ${remoteAuthorityBase(client)} returned a task create ` + "response without a stored task id; no success row or local SQLite fallback is permitted");
   }
   const persisted = await cloudGetTask(client, created.id);
-  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId || expectedCreatedBy !== null && persisted.created_by !== expectedCreatedBy) {
+  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId || (persisted.plan_id ?? null) !== expectedPlanId || expectedCreatedBy !== null && persisted.created_by !== expectedCreatedBy) {
     const creatorDetail = expectedCreatedBy === null ? "" : ` and explicit created_by=${JSON.stringify(expectedCreatedBy)} ` + `(readback ${JSON.stringify(persisted?.created_by ?? null)})`;
-    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + `stored task id and parent_id${creatorDetail}; no success row or local SQLite fallback is permitted`);
+    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + `stored task id, parent_id, and plan_id ` + `(requested plan_id=${JSON.stringify(expectedPlanId)}, readback=${JSON.stringify(persisted?.plan_id ?? null)})` + `${creatorDetail}; no success row or local SQLite fallback is permitted`);
   }
   return persisted;
 }
@@ -65457,6 +67331,8 @@ var init_cloud_router = __esm(() => {
   init_redaction();
   init_plan_project_link_contract();
   init_http_client();
+  init_adoption_validation();
+  init_page_validation();
   UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   TRANSPORT_TOKENS = {
     sqlite: "sqlite",
@@ -65493,6 +67369,7 @@ function registerTaskCrudTools(server, ctx) {
     compact["version"] = task2.version;
     compact["created_at"] = task2.created_at;
     compact["task_list_id"] = task2.task_list_id;
+    compact["parent_id"] = task2.parent_id;
     return compactJson(compact);
   }
   function versionFor(taskId, version2) {
@@ -65762,6 +67639,7 @@ ${task2.description}` : null
       priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
       assigned_to: exports_external.string().nullable().optional().describe("Agent ID or name, null to unassign"),
       project_id: exports_external.string().nullable().optional(),
+      parent_id: exports_external.string().nullable().optional().describe("Existing parent task ID/reference, null to detach"),
       task_list_id: exports_external.string().nullable().optional(),
       depends_on: exports_external.array(exports_external.string()).optional().describe("Full replacement array of dependency IDs"),
       tags: exports_external.array(exports_external.string()).optional(),
@@ -65793,6 +67671,9 @@ ${task2.description}` : null
           if (typeof patch.project_id === "string" && patch.project_id) {
             patch.project_id = await cloudResolveProjectRef(cloud, patch.project_id);
           }
+          if (typeof patch.parent_id === "string" && patch.parent_id) {
+            patch.parent_id = await cloudResolveTaskRef(cloud, patch.parent_id);
+          }
           if (typeof patch.task_list_id === "string" && patch.task_list_id) {
             let scope = typeof patch.project_id === "string" ? patch.project_id : undefined;
             if (!scope) {
@@ -65801,9 +67682,22 @@ ${task2.description}` : null
             }
             patch.task_list_id = await cloudResolveTaskListRef(cloud, patch.task_list_id, scope);
           }
+          if (patch.parent_id !== undefined && version3 === undefined) {
+            const current = await cloudGetTask(cloud, task_id2);
+            if (!current)
+              throw new TaskNotFoundError(task_id2);
+            patch.version = current.version;
+          }
           if (version3 !== undefined)
             patch.version = version3;
-          const updated = await cloudUpdateTask(cloud, task_id2, patch);
+          let updated = await cloudUpdateTask(cloud, task_id2, patch);
+          if (patch.parent_id !== undefined) {
+            const persisted = await cloudGetTask(cloud, task_id2);
+            if (!persisted || (persisted.parent_id ?? null) !== patch.parent_id) {
+              throw new Error(`TASK_REPARENT_PERSISTENCE_UNVERIFIED: parent_id expected ${patch.parent_id ?? "null"}, ` + `received ${persisted?.parent_id ?? "missing task"}`);
+            }
+            updated = persisted;
+          }
           return { content: [{ type: "text", text: mutationTaskResponse(updated) }] };
         }
         const resolvedId = resolveId(params.task_id);
@@ -65815,6 +67709,8 @@ ${task2.description}` : null
           resolved.assigned_to = resolveAssignee(resolved.assigned_to);
         if (resolved.project_id && typeof resolved.project_id === "string")
           resolved.project_id = resolveId(resolved.project_id, "projects");
+        if (resolved.parent_id && typeof resolved.parent_id === "string")
+          resolved.parent_id = resolveId(resolved.parent_id);
         if (resolved.task_list_id && typeof resolved.task_list_id === "string")
           resolved.task_list_id = resolveId(resolved.task_list_id, "task_lists");
         if (resolved.depends_on && Array.isArray(resolved.depends_on))
@@ -99497,7 +101393,7 @@ function registerTaskMetaTools(server, ctx) {
           create_task: "create_task \u2014 Create a new task. Params: title (required), description, status, priority, project_id, task_list_id, assigned_to, depends_on, short_id (null to disable), tags, estimate (minutes), confidence (0.0-1.0), deadline (ISO), retry_count",
           list_tasks: "list_tasks \u2014 List tasks with filters. Params: status, priority, project_id, task_list_id, assigned_to, tags[], created_after, created_before, limit, offset",
           get_task: "get_task \u2014 Get compact task details by default. Params: task_id, detail=compact|full, max_description_chars, include_metadata",
-          update_task: "update_task \u2014 Update task fields (optimistic locking). Params: task_id (required), title, description, status, priority, assigned_to (null to unassign), project_id, task_list_id, depends_on[], tags[], estimate, actual_minutes, confidence, approved_by, completed_at, deadline, retry_count, version",
+          update_task: "update_task \u2014 Update task fields (optimistic locking). Params: task_id (required), title, description, status, priority, assigned_to (null to unassign), project_id, parent_id (null to detach), task_list_id, depends_on[], tags[], estimate, actual_minutes, confidence, approved_by, completed_at, deadline, retry_count, version",
           delete_task: "delete_task \u2014 Delete a task. Params: task_id, force (skip child check)",
           start_task: "start_task \u2014 Mark task in_progress. Params: task_id, version",
           complete_task: "complete_task \u2014 Mark task completed. Params: task_id, confidence, completed_at, version",
@@ -111312,8 +113208,8 @@ function defaultSnapshotDir() {
   return join15(dirname8(resolve16(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
-  const digest2 = sha2567(JSON.stringify(snapshot)).slice(0, 24);
-  return { id: `env_${digest2}`, ...snapshot };
+  const digest3 = sha2567(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest3}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
   const root = resolve16(input.root || process.cwd());