@hasna/todos 0.15.28 → 0.15.32

package/dist/server/openapi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AA2fA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwpDnE"}
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/server/openapi.ts"],"names":[],"mappings":"AAi3BA,wBAAgB,sBAAsB,CAAC,OAAO,SAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6jEnE"}

package/dist/server/v1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v1.d.ts","sourceRoot":"","sources":["../../src/server/v1.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAuB,oBAAoB,EAAmD,MAAM,0BAA0B,CAAC;AAC3I,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,oCAAoC,EACpC,sBAAsB,EACtB,6BAA6B,EAC7B,gBAAgB,EACjB,MAAM,YAAY,CAAC;AA0BpB,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,OAAO,gBAAgB,CAAC;IACtC,YAAY,CAAC,EAAE,OAAO,iBAAiB,CAAC;IACxC,iBAAiB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IAClD,gBAAgB,CAAC,EAAE,OAAO,qBAAqB,CAAC;IAChD,+BAA+B,CAAC,EAAE,OAAO,oCAAoC,CAAC;IAC9E,wBAAwB,CAAC,EAAE,OAAO,6BAA6B,CAAC;CACjE;AA4XD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,oBAAoB,CAiB1E;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAapE;AA4ED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,GAAG,EACR,YAAY,GAAE,qBAA0B,GACvC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAutC1B"}
+{"version":3,"file":"v1.d.ts","sourceRoot":"","sources":["../../src/server/v1.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAuB,oBAAoB,EAAmD,MAAM,0BAA0B,CAAC;AAC3I,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,oCAAoC,EACpC,sBAAsB,EACtB,6BAA6B,EAC7B,gBAAgB,EACjB,MAAM,YAAY,CAAC;AA0BpB,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,OAAO,gBAAgB,CAAC;IACtC,YAAY,CAAC,EAAE,OAAO,iBAAiB,CAAC;IACxC,iBAAiB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IAClD,gBAAgB,CAAC,EAAE,OAAO,qBAAqB,CAAC;IAChD,+BAA+B,CAAC,EAAE,OAAO,oCAAoC,CAAC;IAC9E,wBAAwB,CAAC,EAAE,OAAO,6BAA6B,CAAC;CACjE;AAmYD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,oBAAoB,CAiB1E;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAapE;AA4ED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,GAAG,EACR,YAAY,GAAE,qBAA0B,GACvC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAiuC1B"}

package/dist/storage/postgres-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-adapter.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-adapter.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAcV,mBAAmB,EAYpB,MAAM,iBAAiB,CAAC;AAczB,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AA2B5B,MAAM,WAAW,wCAAwC;IACvD,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAuBD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,mBAAmB,CA4JrB"}
+{"version":3,"file":"postgres-adapter.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-adapter.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAcV,mBAAmB,EAYpB,MAAM,iBAAiB,CAAC;AAczB,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AA4B5B,MAAM,WAAW,wCAAwC;IACvD,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAuBD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,mBAAmB,CA4JrB"}

package/dist/storage/postgres-sync.d.ts

@@ -5,6 +5,14 @@ export interface TodosPostgresQueryResult<T = Record<string, unknown>> {
 }
 export interface TodosPostgresQueryClient {
     query<T = Record<string, unknown>>(sql: string, values?: readonly unknown[]): Promise<TodosPostgresQueryResult<T>>;
+    /**
+     * Optional authoritative same-connection transaction callback.
+     *
+     * Query-only clients remain valid for reads and independent writes. Storage
+     * operations whose correctness depends on a lock followed by a fresh
+     * READ-COMMITTED statement fail closed when this callback is unavailable.
+     */
+    transaction?<T>(fn: (client: TodosPostgresQueryClient) => Promise<T>): Promise<T>;
 }
 export interface CreatePostgresTodosSyncStoreOptions {
     service?: string;

package/dist/storage/postgres-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-sync.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-sync.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"postgres-sync.d.ts","sourceRoot":"","sources":["../../src/storage/postgres-sync.ts"],"names":[],"mappings":"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"}

package/dist/storage.js

@@ -520,6 +520,12 @@ function sqliteTodosProjectRegistrationSchemaSql() {
         authority_id, tenant_id, corpus_id, operation_id, step_id,
         resource_kind, direction, idempotency_key
       );
+    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_source_identity
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, route, package_version,
+        operation_id, step_id, resource_kind, direction, idempotency_key,
+        target_selector
+      );
     CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_step
       ON todos_project_registration_receipts (
         authority_id, tenant_id, corpus_id, operation_id, step_id,
@@ -619,6 +625,12 @@ function postgresTodosProjectRegistrationSchemaSql() {
         authority_id, tenant_id, corpus_id, operation_id, step_id,
         resource_kind, direction, idempotency_key
       )`,
+    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_source_identity_idx
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, route, package_version,
+        operation_id, step_id, resource_kind, direction, idempotency_key,
+        target_selector
+      )`,
     `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_step_idx
       ON todos_project_registration_receipts (
         authority_id, tenant_id, corpus_id, operation_id, step_id,
@@ -7905,6 +7917,46 @@ function guardPlanRowsSqlite(planIds, db) {
   }
 }
 
+// src/lib/task-parent-integrity.ts
+function parentCycleError(taskId, parentId) {
+  return new ResourceConflictError("TASK_PARENT_CYCLE", `TASK_PARENT_CYCLE: assigning parent ${parentId} to task ${taskId} would create or retain a parent cycle`);
+}
+function assertTaskParentIntegrity(taskId, parentId, getTask) {
+  if (parentId === undefined || parentId === null)
+    return;
+  const visited = new Set;
+  let cursor = parentId;
+  while (cursor) {
+    if (cursor === taskId || visited.has(cursor)) {
+      throw parentCycleError(taskId, parentId);
+    }
+    visited.add(cursor);
+    const parent = getTask(cursor);
+    if (!parent)
+      throw new TaskNotFoundError(cursor);
+    cursor = parent.parent_id;
+  }
+}
+async function assertTaskParentIntegrityAsync(taskId, parentId, getTask) {
+  if (parentId === undefined || parentId === null)
+    return;
+  const visited = new Set;
+  let cursor = parentId;
+  while (cursor) {
+    if (cursor === taskId || visited.has(cursor)) {
+      throw parentCycleError(taskId, parentId);
+    }
+    visited.add(cursor);
+    const parent = await getTask(cursor);
+    if (!parent)
+      throw new TaskNotFoundError(cursor);
+    cursor = parent.parent_id;
+  }
+}
+var init_task_parent_integrity = __esm(() => {
+  init_types();
+});
+
 // src/lib/creator-identity.ts
 function canonicalAgentRef(value) {
   return value.trim().toLowerCase();
@@ -9428,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,
@@ -9806,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) {
@@ -9859,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);
@@ -9974,6 +10032,8 @@ function updateTaskStored(id, input, db) {
     logTaskChange(id, "update", "priority", task.priority, input.priority, agentId, d);
   if (input.title !== undefined && input.title !== task.title)
     logTaskChange(id, "update", "title", task.title, input.title, agentId, d);
+  if (input.parent_id !== undefined && input.parent_id !== task.parent_id)
+    logTaskChange(id, "update", "parent_id", task.parent_id, input.parent_id, agentId, d);
   if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to)
     logTaskChange(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
   if (input.working_dir !== undefined && input.working_dir !== task.working_dir)
@@ -10031,7 +10091,8 @@ function updateTask(id, input, db) {
   if (!before)
     throw new TaskNotFoundError(id);
   const guardedPlanIds = [before.plan_id, input.plan_id];
-  if (!guardedPlanIds.some(Boolean))
+  const needsSerializedWrite = input.parent_id !== undefined || guardedPlanIds.some(Boolean);
+  if (!needsSerializedWrite)
     return updateTaskStored(id, input, d);
   return d.transaction(() => {
     guardPlanRowsSqlite(guardedPlanIds, d);
@@ -10067,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
@@ -15053,6 +15115,7 @@ function assertSafeIdentifier(value) {
 
 // src/storage/postgres-adapter.ts
 init_redaction();
+init_task_parent_integrity();
 
 // src/task-manifest/canonical.ts
 import { createHash as createHash5 } from "crypto";
@@ -15096,8 +15159,8 @@ function createPostgresTodosStorageAdapter(options) {
       resolveRef: (ref) => store.resolveTaskRef(ref),
       list: (filter = {}) => store.listTasks(filter),
       count: (filter = {}) => store.countTasks(filter),
-      update: (id, input) => updateTask2(id, input, store),
-      delete: (id, context) => store.delete("tasks", id, context),
+      update: (id, input, context) => updateTask2(id, input, store, context),
+      delete: (id, context) => store.deleteTaskHierarchy(id, context),
       start: (id, agentId) => startTask2(id, agentId, store),
       complete: (id, agentId, options2) => completeTask2(id, agentId, options2, store),
       fail: (id, agentId, reason, options2) => failTask2(id, agentId, reason, options2, store),
@@ -15630,22 +15693,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
@@ -15666,7 +15777,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,
@@ -15679,8 +15796,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,
@@ -15690,9 +15809,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 });
     }
@@ -15700,6 +15836,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);
@@ -16025,6 +16163,80 @@ class PostgresJsonRecordStore {
       version: numberValue2(existing["version"])
     }, context);
   }
+  async deleteTaskHierarchy(id, context = {}) {
+    await this.ensureSchema();
+    return this.withTaskParentIntegrityTransaction(async (client) => {
+      const timestamp2 = 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,
+        timestamp2,
+        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;
@@ -16445,9 +16657,8 @@ class PostgresJsonRecordStore {
 }
 async function createTask2(input, store, context) {
   const timestamp2 = new Date().toISOString();
-  if (input.parent_id && !await store.get("tasks", input.parent_id)) {
-    throw new TaskNotFoundError(input.parent_id);
-  }
+  const taskId = randomUUID3();
+  await assertTaskParentIntegrityAsync(taskId, input.parent_id, (id) => store.get("tasks", id));
   const linkedPlan = input.plan_id ? await store.get("plans", input.plan_id) : null;
   const requestedProjectId = input.project_id ?? context?.projectId ?? null;
   if (linkedPlan?.project_id && requestedProjectId && requestedProjectId !== linkedPlan.project_id) {
@@ -16456,7 +16667,7 @@ async function createTask2(input, store, context) {
   const effectiveProjectId = linkedPlan?.project_id ?? requestedProjectId;
   const shortId = effectiveProjectId ? await nextTaskShortId2(effectiveProjectId, store, context) : null;
   const task = {
-    id: randomUUID3(),
+    id: taskId,
     short_id: shortId,
     project_id: effectiveProjectId,
     parent_id: input.parent_id ?? null,
@@ -16512,15 +16723,16 @@ async function createTask2(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 logTaskChange2(storedTask.id, "created", "status", null, storedTask.status, storedTask.assigned_by ?? storedTask.agent_id, store, context);
   return storedTask;
 }
-async function updateTask2(id, input, store) {
+async function updateTask2(id, input, store, context) {
   const existing = await requireRecord("tasks", id, store);
   if (existing.version !== input.version) {
-    throw new Error(`Task ${id} version conflict: expected ${existing.version}, got ${input.version}`);
+    throw new VersionConflictError(id, input.version, existing.version);
   }
+  await assertTaskParentIntegrityAsync(id, input.parent_id, (candidateId) => store.get("tasks", candidateId));
   const effectivePlanId = input.plan_id !== undefined ? input.plan_id : existing.plan_id;
   const linkedPlan = effectivePlanId ? await store.get("plans", effectivePlanId) : null;
   if (linkedPlan?.project_id) {
@@ -16545,10 +16757,19 @@ async function updateTask2(id, input, store) {
     metadata: input.metadata ?? existing.metadata,
     requires_approval: input.requires_approval ?? existing.requires_approval,
     task_list_id: input.task_list_id !== undefined ? input.task_list_id : existing.task_list_id,
+    parent_id: input.parent_id !== undefined ? input.parent_id : existing.parent_id,
     created_by: existing.created_by,
     completed_at: reopened ? null : input.completed_at !== undefined ? input.completed_at : existing.completed_at
   };
-  return store.upsertTaskWithPlanMembershipGuard(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 logTaskChange2(id, "update", "parent_id", existing.parent_id, input.parent_id, existing.assigned_to ?? existing.agent_id, store, context);
+  }
+  return storedTask;
 }
 async function startTask2(id, agentId, store) {
   const task = await requireRecord("tasks", id, store);
@@ -16612,7 +16833,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) {

package/dist/task-manifest/authority.d.ts

@@ -1,5 +1,17 @@
 import type { TodosTaskManifestBackend } from "./backend.js";
-import { type PostgresTodosTaskManifestAuthorityOptions, type SqliteTodosTaskManifestAuthorityOptions, type TodosTaskManifestApplyResult, type TodosTaskManifestAuthority, type TodosTaskManifestAuthorityOptions, type TodosTaskManifestBindingLookupRequest, type TodosTaskManifestBindingLookupResult, type TodosTaskManifestCapability, type TodosTaskManifestCompensateRequest, type TodosTaskManifestCompensationResult, type TodosTaskManifestPostgresClient } from "./types.js";
+import { type PostgresTodosTaskManifestAuthorityOptions, type SqliteTodosTaskManifestAuthorityOptions, type TodosTaskManifestApplyResult, type TodosTaskManifestAuthority, type TodosTaskManifestAuthorityOptions, type TodosTaskManifestBindingLookupRequest, type TodosTaskManifestBindingLookupResult, type TodosTaskManifestCapability, type TodosTaskManifestCompensateRequest, type TodosTaskManifestCompensationResult, type TodosTaskManifestPostgresClient, type TodosTaskManifest, type TodosTaskManifestDirection } from "./types.js";
+export declare function taskManifestRequestDigest(manifest: Omit<TodosTaskManifest, "idempotency_key">): string;
+export declare function taskManifestCompensationRequestDigest(request: Omit<TodosTaskManifestCompensateRequest, "idempotency_key">): string;
+export declare function deriveTodosTaskManifestApplyPreconditionDigest(input: Pick<TodosTaskManifest, "operation_id" | "step_id" | "project_id" | "task_list_id" | "if_binding_version">): string;
+export declare function deriveTodosTaskManifestCompensationPreconditionDigest(input: Pick<TodosTaskManifestCompensateRequest, "operation_id" | "step_id" | "receipt_id" | "if_binding_version">): string;
+export declare function deriveTodosTaskManifestIdempotencyKey(input: {
+    operation_id: string;
+    step_id: string;
+    direction: TodosTaskManifestDirection;
+    target_selector: string;
+    request_digest: string;
+    precondition_digest: string;
+}): string;
 export declare class PackageOwnedTodosTaskManifestAuthority implements TodosTaskManifestAuthority {
     private readonly backend;
     private readonly options;

package/dist/task-manifest/authority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authority.d.ts","sourceRoot":"","sources":["../../src/task-manifest/authority.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAsD,MAAM,cAAc,CAAC;AAUjH,OAAO,EAIL,KAAK,yCAAyC,EAC9C,KAAK,uCAAuC,EAC5C,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,iCAAiC,EACtC,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EACzC,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EACvC,KAAK,mCAAmC,EAExC,KAAK,+BAA+B,EAErC,MAAM,YAAY,CAAC;AAuIpB,qBAAa,sCAAuC,YAAW,0BAA0B;IAIrF,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAGf,OAAO,EAAE,wBAAwB,EACjC,OAAO,GAAE,iCAAsC;IAK5D,UAAU,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAkBxD,OAAO,CAAC,GAAG;YAQG,aAAa;IAUrB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAMlE,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAO7D,aAAa,CACjB,KAAK,EAAE,qCAAqC,GAC3C,OAAO,CAAC,oCAAoC,CAAC;IA6BhD,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9C,UAAU,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,mCAAmC,CAAC;IAkCzG,OAAO,CAAC,OAAO;CAWhB;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,uCAAuC,GAC/C,0BAA0B,CAS5B;AAED,wBAAgB,wCAAwC,CACtD,MAAM,EAAE,+BAA+B,EACvC,OAAO,GAAE,yCAA8C,GACtD,0BAA0B,CAY5B;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"authority.d.ts","sourceRoot":"","sources":["../../src/task-manifest/authority.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAsD,MAAM,cAAc,CAAC;AAUjH,OAAO,EAML,KAAK,yCAAyC,EAC9C,KAAK,uCAAuC,EAC5C,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,iCAAiC,EACtC,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EACzC,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EACvC,KAAK,mCAAmC,EAExC,KAAK,+BAA+B,EAEpC,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAC;AAmBpB,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,GACnD,MAAM,CAGR;AAED,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,IAAI,CAAC,kCAAkC,EAAE,iBAAiB,CAAC,GACnE,MAAM,CAER;AAED,wBAAgB,8CAA8C,CAAC,KAAK,EAAE,IAAI,CACxE,iBAAiB,EACjB,cAAc,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,GAAG,oBAAoB,CAClF,GAAG,MAAM,CAUT;AAED,wBAAgB,qDAAqD,CAAC,KAAK,EAAE,IAAI,CAC/E,kCAAkC,EAClC,cAAc,GAAG,SAAS,GAAG,YAAY,GAAG,oBAAoB,CACjE,GAAG,MAAM,CAST;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,0BAA0B,CAAC;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,MAAM,CAKT;AAmJD,qBAAa,sCAAuC,YAAW,0BAA0B;IAIrF,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAGf,OAAO,EAAE,wBAAwB,EACjC,OAAO,GAAE,iCAAsC;IAK5D,UAAU,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAsBxD,OAAO,CAAC,GAAG;YAQG,aAAa;IAUrB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAclE,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAO7D,aAAa,CACjB,KAAK,EAAE,qCAAqC,GAC3C,OAAO,CAAC,oCAAoC,CAAC;IA6BhD,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9C,UAAU,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,mCAAmC,CAAC;IAkFzG,OAAO,CAAC,OAAO;CAWhB;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,uCAAuC,GAC/C,0BAA0B,CAS5B;AAED,wBAAgB,wCAAwC,CACtD,MAAM,EAAE,+BAA+B,EACvC,OAAO,GAAE,yCAA8C,GACtD,0BAA0B,CAY5B;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC"}

package/dist/task-manifest/backend.d.ts

@@ -2,8 +2,10 @@ import type { TodosTaskManifestApplyResult, TodosTaskManifestBindingLookupResult
 export interface NormalizedTaskManifest {
     manifest: TodosTaskManifest;
     request_digest: string;
+    expected_idempotency_key: string;
     result_digest: string;
     receipt_id: string;
+    terminal_receipt_id: string;
     graph: TodosTaskManifestGraph;
     outbox: Array<{
         id: string;
@@ -12,6 +14,7 @@ export interface NormalizedTaskManifest {
         digest: string;
     }>;
     now: string;
+    plan_slug_provenance: "deterministic-v1";
 }
 export interface PreparedTaskManifestFaults {
     points: ReadonlySet<TodosTaskManifestFaultPoint>;
@@ -30,6 +33,7 @@ export interface TaskManifestBindingLookupRow {
     binding_version: unknown;
     binding_tenant_id: unknown;
     binding_operation_id: unknown;
+    binding_step_id: unknown;
     binding_plan_id: unknown;
     receipt_tenant_id: unknown;
     receipt_authority: unknown;
@@ -37,6 +41,7 @@ export interface TaskManifestBindingLookupRow {
     receipt_schema_version: unknown;
     receipt_kind: unknown;
     receipt_operation_id: unknown;
+    receipt_step_id: unknown;
     receipt_plan_id: unknown;
 }
 export declare function validateTaskManifestBindingLookupRows(rows: TaskManifestBindingLookupRow[], tenantId: string, planId: string): Omit<TodosTaskManifestBindingLookupResult, "authority" | "route" | "schema_version" | "tenant_id">;

package/dist/task-manifest/backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/task-manifest/backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,oCAAoC,EACpC,kCAAkC,EAClC,mCAAmC,EACnC,2BAA2B,EAC3B,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/F,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,WAAW,CAAC,2BAA2B,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IACvC,KAAK,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAChH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IACpE,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CACjD,oCAAoC,EACpC,WAAW,GAAG,OAAO,GAAG,gBAAgB,GAAG,WAAW,CACvD,CAAC,CAAC;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,UAAU,CACR,KAAK,EAAE,kCAAkC,EACzC,OAAO,EAAE,wBAAwB,EACjC,qBAAqB,EAAE,MAAM,EAC7B,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,mCAAmC,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,4BAA4B;IAC3C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,sBAAsB,EAAE,OAAO,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;IACtB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,4BAA4B,EAAE,EACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CACL,oCAAoC,EACpC,WAAW,GAAG,OAAO,GAAG,gBAAgB,GAAG,WAAW,CACvD,CA8CA;AAED,wBAAgB,aAAa,IAAI,yBAAyB,CAEzD"}
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/task-manifest/backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,oCAAoC,EACpC,kCAAkC,EAClC,mCAAmC,EACnC,2BAA2B,EAC3B,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,sBAAsB,CAAC;IAC9B,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/F,GAAG,EAAE,MAAM,CAAC;IACZ,oBAAoB,EAAE,kBAAkB,CAAC;CAC1C;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,WAAW,CAAC,2BAA2B,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IACvC,KAAK,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAChH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IACpE,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CACjD,oCAAoC,EACpC,WAAW,GAAG,OAAO,GAAG,gBAAgB,GAAG,WAAW,CACvD,CAAC,CAAC;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,UAAU,CACR,KAAK,EAAE,kCAAkC,EACzC,OAAO,EAAE,wBAAwB,EACjC,qBAAqB,EAAE,MAAM,EAC7B,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,mCAAmC,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,4BAA4B;IAC3C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,sBAAsB,EAAE,OAAO,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;IACtB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,4BAA4B,EAAE,EACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CACL,oCAAoC,EACpC,WAAW,GAAG,OAAO,GAAG,gBAAgB,GAAG,WAAW,CACvD,CAmDA;AAED,wBAAgB,aAAa,IAAI,yBAAyB,CAEzD"}

package/dist/task-manifest/index.d.ts

@@ -1,10 +1,10 @@
-export { PackageOwnedTodosTaskManifestAuthority, createPostgresTodosTaskManifestAuthority, createSqliteTodosTaskManifestAuthority, parseTodosTaskManifest, } from "./authority.js";
+export { PackageOwnedTodosTaskManifestAuthority, createPostgresTodosTaskManifestAuthority, createSqliteTodosTaskManifestAuthority, deriveTodosTaskManifestApplyPreconditionDigest, deriveTodosTaskManifestCompensationPreconditionDigest, deriveTodosTaskManifestIdempotencyKey, parseTodosTaskManifest, taskManifestCompensationRequestDigest, taskManifestRequestDigest, } from "./authority.js";
 export { PostgresTodosTaskManifestBackend } from "./postgres.js";
 export { SqliteTodosTaskManifestBackend } from "./sqlite.js";
 export { TodosTaskManifestHttpClient, createTodosTaskManifestHttpClient, handleTodosTaskManifestHttpRequest, } from "./http.js";
 export { canonicalDigest as digestTodosTaskManifest, canonicalJson as canonicalTodosTaskManifestJson, deterministicUuid as deterministicTodosTaskManifestId } from "./canonical.js";
 export { TODOS_TASK_MANIFEST_BOUNDS, parseTodosTaskManifestBindingLookup, parseTodosTaskManifestCompensation, } from "./schema.js";
 export { postgresTodosTaskManifestSchemaSql, sqliteTodosTaskManifestSchemaSql } from "./schema-sql.js";
-export { TODOS_TASK_MANIFEST_ROUTE, TODOS_TASK_MANIFEST_SCHEMA_VERSION, TodosTaskManifestError, supportsIdempotentOutboxDelivery, } from "./types.js";
+export { TODOS_TASK_MANIFEST_ROUTE, TODOS_TASK_MANIFEST_CALLER_ROUTE, TODOS_TASK_MANIFEST_PLAN_SLUG_PROVENANCE, TODOS_TASK_MANIFEST_SCHEMA_VERSION, TodosTaskManifestError, supportsIdempotentOutboxDelivery, } from "./types.js";
 export type * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/task-manifest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task-manifest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sCAAsC,EACtC,wCAAwC,EACxC,sCAAsC,EACtC,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gCAAgC,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,kCAAkC,GACnC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,aAAa,IAAI,8BAA8B,EAAE,iBAAiB,IAAI,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AACpL,OAAO,EACL,0BAA0B,EAC1B,mCAAmC,EACnC,kCAAkC,GACnC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kCAAkC,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AACvG,OAAO,EACL,yBAAyB,EACzB,kCAAkC,EAClC,sBAAsB,EACtB,gCAAgC,GACjC,MAAM,YAAY,CAAC;AACpB,mBAAmB,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task-manifest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sCAAsC,EACtC,wCAAwC,EACxC,sCAAsC,EACtC,8CAA8C,EAC9C,qDAAqD,EACrD,qCAAqC,EACrC,sBAAsB,EACtB,qCAAqC,EACrC,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gCAAgC,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,kCAAkC,GACnC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,aAAa,IAAI,8BAA8B,EAAE,iBAAiB,IAAI,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AACpL,OAAO,EACL,0BAA0B,EAC1B,mCAAmC,EACnC,kCAAkC,GACnC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kCAAkC,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AACvG,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,wCAAwC,EACxC,kCAAkC,EAClC,sBAAsB,EACtB,gCAAgC,GACjC,MAAM,YAAY,CAAC;AACpB,mBAAmB,YAAY,CAAC"}

package/dist/task-manifest/plan-slug.d.ts

@@ -1,4 +1,11 @@
 import type { TodosTaskManifest } from "./types.js";
+/**
+ * Internal marker written to authority rows for applies that use the
+ * deterministic plan-slug contract introduced in v0.15.26.
+ *
+ * This stays out of the public manifest and receipt payloads.
+ */
+export declare const TASK_MANIFEST_DETERMINISTIC_SLUG_PROVENANCE: "deterministic-v1";
 /**
  * Deterministic plan slug for task-manifest graph writes.
  *
@@ -8,4 +15,17 @@ import type { TodosTaskManifest } from "./types.js";
  * stable slug up front for exact readback and compensation parity.
  */
 export declare function taskManifestPlanSlug(manifest: Pick<TodosTaskManifest, "plan">, planId: string): string;
+export interface LegacySqlitePlanSlugRow {
+    id: string;
+    project_id: string | null;
+    name: string;
+    slug: string | null;
+    created_at: string;
+}
+/**
+ * Reproduce the collision-safe allocator used by SQLite schema repair for a
+ * legacy task-manifest plan. The caller compares the result with the stored
+ * row and may separately accept the pre-repair NULL state.
+ */
+export declare function sqliteLegacyTaskManifestPlanSlug(rows: readonly LegacySqlitePlanSlugRow[], planId: string, targetBase?: string): string | null;
 //# sourceMappingURL=plan-slug.d.ts.map