@hasna/todos 0.15.29 → 0.15.32

package/dist/project-registration.js

@@ -1015,6 +1015,46 @@ var init_stale_lock_handoff = __esm(() => {
   CANONICAL_LOCK_VERSION_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 });
 
+// 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/project-registration/schema.ts
 function sqliteTodosProjectRegistrationSchemaSql() {
   return `
@@ -9440,6 +9480,7 @@ function createTaskStored(input, d) {
   let id = uuid();
   for (let attempt = 0;attempt < 3; attempt++) {
     try {
+      assertTaskParentIntegrity(id, input.parent_id, (candidateId) => getTask(candidateId, d));
       d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, sla_minutes, confidence, retry_count, max_retries, retry_after, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, created_by, assigned_from_project, task_type, machine_id)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         id,
@@ -9818,6 +9859,7 @@ function updateTaskStored(id, input, db) {
     throw new VersionConflictError(id, input.version, task.version);
   }
   input = sanitizeUpdateTaskInput(input);
+  assertTaskParentIntegrity(id, input.parent_id, (candidateId) => getTask(candidateId, d));
   const effectivePlanId = input.plan_id !== undefined ? input.plan_id : task.plan_id;
   const linkedProjectId = linkedPlanProjectId(effectivePlanId, d);
   if (linkedProjectId) {
@@ -9871,6 +9913,10 @@ function updateTaskStored(id, input, db) {
     sets.push("project_id = ?");
     params.push(input.project_id);
   }
+  if (input.parent_id !== undefined) {
+    sets.push("parent_id = ?");
+    params.push(input.parent_id);
+  }
   if (input.assigned_to !== undefined) {
     sets.push("assigned_to = ?");
     params.push(input.assigned_to);
@@ -9986,6 +10032,8 @@ function updateTaskStored(id, input, db) {
     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)
@@ -10043,7 +10091,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);
@@ -10079,6 +10128,7 @@ var init_task_crud = __esm(() => {
   init_checklists();
   init_storage_tombstones();
   init_prewrite_secrets();
+  init_task_parent_integrity();
 });
 
 // src/db/task-status.ts
@@ -12669,11 +12719,11 @@ var init_tasks = __esm(() => {
 });
 
 // src/project-registration/authority.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.15.29",
+  version: "0.15.32",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -13526,6 +13576,7 @@ function measureIntegrityRows(spec, sets) {
 
 // src/storage/postgres-adapter.ts
 init_redaction();
+init_task_parent_integrity();
 
 // src/storage/audit-history-import.ts
 var AUDIT_HISTORY_DIVERGENT_REPLAY = "AUDIT_HISTORY_DIVERGENT_REPLAY";
@@ -13597,8 +13648,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),
@@ -14131,22 +14182,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
@@ -14167,7 +14266,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,
@@ -14180,8 +14285,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,
@@ -14191,9 +14298,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 });
     }
@@ -14201,6 +14325,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);
@@ -14526,6 +14652,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;
@@ -14946,9 +15146,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) {
@@ -14957,7 +15156,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,
@@ -15013,15 +15212,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) {
@@ -15046,10 +15246,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);
@@ -15113,7 +15322,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
+  });
 }
 var CLOUD_LOCK_EXPIRY_MINUTES = 30;
 function sameCloudLockHolder(stored, incoming) {
@@ -16103,6 +16316,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;
   }
@@ -16113,6 +16327,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;
   }
@@ -16123,10 +16338,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`);
@@ -16206,11 +16435,102 @@ class PostgresTodosProjectRegistrationBackend {
   async getTaskList(id) {
     return (await this.direct()).getTaskList(id);
   }
+  async getProjectResourceCollectionRevision(input) {
+    await this.ensureSchema();
+    const result = await this.client.query(`
+      WITH resources(kind_rank, target_id, revision) AS (
+        SELECT 0, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'projects'
+          AND deleted_at IS NULL AND object_id = $2
+        UNION ALL
+        SELECT 1, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'task_lists'
+          AND deleted_at IS NULL AND object_id = $3
+          AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 2, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'plans'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 3, object_id, COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'tasks'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+      )
+      SELECT 'md5:' || md5(COALESCE(string_agg(
+        kind_rank::text || chr(31) || target_id || chr(31) || revision,
+        chr(30) ORDER BY kind_rank ASC, target_id ASC
+      ), '')) AS revision
+      FROM resources
+    `, [
+      this.service,
+      input.todos_project_id,
+      input.task_list_id,
+      input.include_anchors
+    ]);
+    const revision = result.rows[0]?.revision;
+    if (!revision) {
+      throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "could not derive the hosted project-resource collection revision");
+    }
+    return revision;
+  }
+  async listProjectResourceCandidates(input) {
+    await this.ensureSchema();
+    const afterRank = input.after?.kind_rank ?? -1;
+    const afterId = input.after?.target_id ?? "";
+    const result = await this.client.query(`
+      WITH resources(kind, kind_rank, target_id, parent_id, revision) AS (
+        SELECT 'project'::text, 0, object_id, NULL::text,
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'projects'
+          AND deleted_at IS NULL AND object_id = $2
+        UNION ALL
+        SELECT 'task_list'::text, 1, object_id, payload->>'project_id',
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE service = $1 AND object_type = 'task_lists'
+          AND deleted_at IS NULL AND object_id = $3
+          AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 'plan'::text, 2, object_id, payload->>'project_id',
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'plans'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+        UNION ALL
+        SELECT 'task'::text, 3, object_id,
+          COALESCE(payload->>'plan_id', payload->>'project_id'),
+          COALESCE(payload->>'updated_at', updated_at::text)
+        FROM ${this.tableName}
+        WHERE $4::boolean AND service = $1 AND object_type = 'tasks'
+          AND deleted_at IS NULL AND payload->>'project_id' = $2
+      )
+      SELECT kind, kind_rank, target_id, parent_id, revision
+      FROM resources
+      WHERE kind_rank > $5 OR (kind_rank = $5 AND target_id > $6)
+      ORDER BY kind_rank ASC, target_id ASC
+      LIMIT $7
+    `, [
+      this.service,
+      input.todos_project_id,
+      input.task_list_id,
+      input.include_anchors,
+      afterRank,
+      afterId,
+      input.limit
+    ]);
+    return result.rows;
+  }
 }
 
 // src/project-registration/sqlite.ts
 init_database();
 init_storage_tombstones();
+import { createHash as createHash6 } from "crypto";
 
 // src/storage/local-sqlite.ts
 init_types();
@@ -18518,6 +18838,64 @@ class SqliteTodosProjectRegistrationBackend {
   getTaskList(id) {
     return this.direct.getTaskList(id);
   }
+  async getProjectResourceCollectionRevision(input) {
+    const digest = createHash6("sha256");
+    const rows = this.db.query(`
+      WITH resources(kind_rank, target_id, revision) AS (
+        SELECT 0, id, updated_at
+        FROM projects
+        WHERE id = ?
+        UNION ALL
+        SELECT 1, id, updated_at
+        FROM task_lists
+        WHERE id = ? AND project_id = ?
+        UNION ALL
+        SELECT 2, id, updated_at
+        FROM plans
+        WHERE ? = 1 AND project_id = ?
+        UNION ALL
+        SELECT 3, id, updated_at
+        FROM tasks
+        WHERE ? = 1 AND project_id = ?
+      )
+      SELECT kind_rank, target_id, revision
+      FROM resources
+      ORDER BY kind_rank ASC, target_id ASC
+    `).iterate(input.todos_project_id, input.task_list_id, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id);
+    for (const row of rows) {
+      digest.update(`${row.kind_rank}\x00${row.target_id}\x00${row.revision}
+`);
+    }
+    return `sha256:${digest.digest("hex")}`;
+  }
+  async listProjectResourceCandidates(input) {
+    const afterRank = input.after?.kind_rank ?? -1;
+    const afterId = input.after?.target_id ?? "";
+    return this.db.query(`
+      WITH resources(kind, kind_rank, target_id, parent_id, revision) AS (
+        SELECT 'project', 0, id, NULL, updated_at
+        FROM projects
+        WHERE id = ?
+        UNION ALL
+        SELECT 'task_list', 1, id, project_id, updated_at
+        FROM task_lists
+        WHERE id = ? AND project_id = ?
+        UNION ALL
+        SELECT 'plan', 2, id, project_id, updated_at
+        FROM plans
+        WHERE ? = 1 AND project_id = ?
+        UNION ALL
+        SELECT 'task', 3, id, COALESCE(plan_id, project_id), updated_at
+        FROM tasks
+        WHERE ? = 1 AND project_id = ?
+      )
+      SELECT kind, kind_rank, target_id, parent_id, revision
+      FROM resources
+      WHERE kind_rank > ? OR (kind_rank = ? AND target_id > ?)
+      ORDER BY kind_rank ASC, target_id ASC
+      LIMIT ?
+    `).all(input.todos_project_id, input.task_list_id, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, input.include_anchors ? 1 : 0, input.todos_project_id, afterRank, afterRank, afterId, input.limit);
+  }
 }
 
 // src/project-registration/authority.ts
@@ -18529,6 +18907,8 @@ var AUTHORITY_ROUTE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/;
 var PACKAGE_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 var IDEMPOTENCY_PATTERN = /^prk_[0-9a-f]{48}$/;
+var PROJECT_RESOURCE_PAGE_LIMIT = 500;
+var PROJECT_RESOURCE_CURSOR_VERSION = 1;
 
 class WriteBoundaryError extends Error {
   point;
@@ -18556,7 +18936,7 @@ function canonicalize3(value) {
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash6("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash7("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -18668,35 +19048,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)}`;
 }
@@ -18734,9 +19147,37 @@ function normalizedCallDigest(request) {
     project_slug: request.project_slug,
     project_name: request.project_name,
     desired: request.desired,
+    bind_existing: request.bind_existing === true,
     accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
   });
 }
+function legacyNormalizedCallDigestBeforeBindExisting(request) {
+  return digestProjectRegistrationValue({
+    authority_route: request.authority_route,
+    package_version: request.package_version,
+    authority_id: request.authority_id,
+    tenant_id: request.tenant_id,
+    corpus_id: request.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    resource_kind: request.resource_kind,
+    direction: request.direction,
+    target_selector: request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    project_id: request.project_id,
+    project_slug: request.project_slug,
+    project_name: request.project_name,
+    desired: request.desired,
+    accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
+  });
+}
+function acceptedCallMatches(request, accepted, callDigest = normalizedCallDigest(request)) {
+  if (accepted.normalized_call_digest === callDigest)
+    return true;
+  return request.bind_existing !== true && accepted.normalized_call_digest === legacyNormalizedCallDigestBeforeBindExisting(request);
+}
 function assertCommonRequest(request, capability) {
   assertBounds(request);
   assertResourceKind(request.resource_kind);
@@ -18778,6 +19219,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,
@@ -18799,7 +19243,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", {
@@ -18878,7 +19322,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",
@@ -18888,7 +19332,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) {
@@ -18950,6 +19394,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;
@@ -18971,6 +19462,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
     };
@@ -19031,7 +19526,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);
@@ -19045,7 +19540,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 });
@@ -19056,6 +19551,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);
@@ -19067,7 +19568,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);
@@ -19081,6 +19585,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);
@@ -19097,7 +19607,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();
@@ -19119,9 +19632,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);
             }
           }
@@ -19132,15 +19645,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;
@@ -19188,7 +19701,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));
@@ -19268,6 +19781,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)) {
@@ -19439,6 +20110,65 @@ function createPostgresTodosProjectRegistrationAuthority(client, options = {}) {
     cursorTableName
   }), authorityOptions);
 }
+// src/project-registration/adoption-validation.ts
+var VALIDATION_KEYS = [
+  "valid",
+  "resource_kind",
+  "target_id",
+  "source_receipt_id",
+  "accepted_receipt_id",
+  "source_outcome",
+  "created_at",
+  "current_revision",
+  "accepted_result_digest"
+];
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasExactKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+}
+function adoptionRejected(message) {
+  throw new TodosProjectRegistrationError("TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED", `TODOS_PROJECT_REGISTRATION_ADOPTION_REJECTED: ${message}`);
+}
+function assertTodosPriorRegistrationAdoptionValidationEnvelope(value, input) {
+  if (!isRecord(input) || !hasExactKeys(input, [
+    "source_request",
+    "source_receipt",
+    "current_record"
+  ])) {
+    adoptionRejected("prior-adoption validation input is incomplete");
+  }
+  const request = input["source_request"];
+  const receipt = input["source_receipt"];
+  const current = input["current_record"];
+  if (!isRecord(request) || !isRecord(receipt) || !isRecord(current)) {
+    adoptionRejected("prior-adoption validation input records are incomplete");
+  }
+  const resourceKind = request["resource_kind"];
+  const sourceOutcome = receipt["outcome"];
+  const acceptedReceiptId = sourceOutcome === "accepted" ? receipt["receipt_id"] : sourceOutcome === "duplicate_of_accepted" ? receipt["duplicate_of_receipt_id"] : null;
+  if (resourceKind !== "project" && resourceKind !== "task_list" || request["direction"] !== "forward" || sourceOutcome !== "accepted" && sourceOutcome !== "duplicate_of_accepted" || !isNonEmptyString(acceptedReceiptId) || !isNonEmptyString(receipt["receipt_id"]) || !isNonEmptyString(receipt["target_id"]) || !isNonEmptyString(receipt["result_revision"]) || !isNonEmptyString(receipt["result_digest"]) || !isNonEmptyString(current["id"]) || !isNonEmptyString(current["created_at"]) || !isNonEmptyString(current["updated_at"]) || receipt["authority"] !== "todos" || receipt["route"] !== request["authority_route"] || receipt["package_version"] !== request["package_version"] || receipt["authority_id"] !== request["authority_id"] || receipt["tenant_id"] !== request["tenant_id"] || receipt["corpus_id"] !== request["corpus_id"] || receipt["operation_id"] !== request["operation_id"] || receipt["step_id"] !== request["step_id"] || receipt["resource_kind"] !== resourceKind || receipt["direction"] !== "forward" || receipt["idempotency_key"] !== request["idempotency_key"] || receipt["request_digest"] !== request["request_digest"] || receipt["precondition_digest"] !== request["precondition_digest"] || receipt["accepted_receipt_id"] !== null || receipt["target_id"] !== current["id"] || receipt["result_revision"] !== current["created_at"]) {
+    adoptionRejected("prior-adoption validation input does not carry one complete accepted receipt and current target incarnation");
+  }
+  if (sourceOutcome === "accepted" && receipt["duplicate_of_receipt_id"] !== null || sourceOutcome === "duplicate_of_accepted" && receipt["duplicate_of_receipt_id"] !== acceptedReceiptId) {
+    adoptionRejected("prior-adoption validation source receipt lineage is incomplete");
+  }
+  if (!isRecord(value) || !hasExactKeys(value, ["validation"]) || !isRecord(value["validation"]) || !hasExactKeys(value["validation"], VALIDATION_KEYS)) {
+    adoptionRejected("prior-adoption validation response envelope is incomplete");
+  }
+  const validation = value["validation"];
+  if (validation["valid"] !== true || validation["resource_kind"] !== resourceKind || validation["target_id"] !== current["id"] || validation["source_receipt_id"] !== receipt["receipt_id"] || validation["accepted_receipt_id"] !== acceptedReceiptId || validation["source_outcome"] !== sourceOutcome || validation["created_at"] !== current["created_at"] || validation["current_revision"] !== current["updated_at"] || validation["accepted_result_digest"] !== receipt["result_digest"]) {
+    adoptionRejected("prior-adoption validation response does not prove the exact accepted receipt and current target");
+  }
+  return validation;
+}
+
 // src/project-registration/http.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };
 function json(body, status = 200) {
@@ -19485,6 +20215,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);
@@ -19507,6 +20251,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)
@@ -19581,6 +20331,28 @@ class TodosProjectRegistrationHttpClient {
   async lookupReceipt(request) {
     return this.request("/receipts/lookup", { method: "POST", body: JSON.stringify(request) });
   }
+  async listProjectResources(request) {
+    const query = new URLSearchParams({
+      source_project_id: request.source_project_id,
+      limit: String(request.limit),
+      include_anchors: String(request.include_anchors === true),
+      ...request.cursor ? { cursor: request.cursor } : {}
+    });
+    const body = await this.request(`/resources?${query.toString()}`);
+    return body.page;
+  }
+  async validatePriorRegistrationAdoption(sourceRequest, sourceReceipt, currentRecord) {
+    const input = {
+      source_request: withoutTarget(sourceRequest),
+      source_receipt: sourceReceipt,
+      current_record: currentRecord
+    };
+    const body = await this.request("/validate-prior-adoption", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return assertTodosPriorRegistrationAdoptionValidationEnvelope(body, input);
+  }
   async compensate(request) {
     const body = await this.request("/compensate", { method: "POST", body: JSON.stringify(withoutTarget(request)) });
     return body.receipt;
@@ -19606,6 +20378,7 @@ export {
   createPostgresTodosProjectRegistrationAuthority,
   createLocalTodosProjectRegistrationAuthority,
   canonicalProjectRegistrationJson,
+  assertTodosPriorRegistrationAdoptionValidationEnvelope,
   TodosProjectRegistrationHttpClient,
   TodosProjectRegistrationError,
   TODOS_PROJECT_REGISTRATION_SCHEMA_VERSION,