@hasna/todos 0.15.7 → 0.15.9

package/dist/server/index.js

@@ -70,7 +70,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.7",
+    version: "0.15.9",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -9943,6 +9943,80 @@ var init_database = __esm(() => {
   ALLOWED_TABLES = new Set(["tasks", "projects", "agents", "plans", "task_lists", "task_templates", "project_knowledge_records", "project_risks", "local_retrospectives"]);
 });
 
+// src/db/storage-tombstones.ts
+function recordStorageTombstone(input, db) {
+  const d = db ?? getDatabase();
+  const deletedAt = input.deleted_at ?? now();
+  const machineId = input.source_machine_id ?? currentStorageMachineId(d);
+  d.run(`INSERT INTO storage_tombstones (
+       id, object_type, object_id, deleted_at, updated_at, source_machine_id, payload, version
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(object_type, object_id) DO UPDATE SET
+       deleted_at = excluded.deleted_at,
+       updated_at = excluded.updated_at,
+       source_machine_id = excluded.source_machine_id,
+       payload = excluded.payload,
+       version = excluded.version
+     WHERE storage_tombstones.updated_at IS NULL OR storage_tombstones.updated_at <= excluded.updated_at`, [
+    uuid(),
+    input.object_type,
+    input.object_id,
+    deletedAt,
+    deletedAt,
+    machineId,
+    input.payload ? JSON.stringify(input.payload) : null,
+    input.version ?? null
+  ]);
+  return getStorageTombstone(input.object_type, input.object_id, d);
+}
+function getStorageTombstone(objectType, objectId, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM storage_tombstones WHERE object_type = ? AND object_id = ?").get(objectType, objectId);
+  return row ? rowToStorageTombstone(row) : null;
+}
+function listStorageTombstones(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM storage_tombstones ORDER BY updated_at ASC, object_type ASC, object_id ASC").all().map(rowToStorageTombstone);
+}
+function shouldApplyStorageTombstone(tombstone, existingUpdatedAt) {
+  const tombstoneClock = Date.parse(tombstone.updated_at || tombstone.deleted_at);
+  if (!existingUpdatedAt)
+    return true;
+  const existingClock = Date.parse(existingUpdatedAt);
+  if (Number.isNaN(tombstoneClock))
+    return true;
+  if (Number.isNaN(existingClock))
+    return true;
+  return tombstoneClock >= existingClock;
+}
+function rowToStorageTombstone(row) {
+  return {
+    ...row,
+    payload: parsePayload2(row.payload)
+  };
+}
+function parsePayload2(value) {
+  if (!value)
+    return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function currentStorageMachineId(db) {
+  try {
+    return getMachineId(db);
+  } catch {
+    return null;
+  }
+}
+var init_storage_tombstones = __esm(() => {
+  init_database();
+  init_machines();
+});
+
 // src/lib/search.ts
 var exports_search = {};
 __export(exports_search, {
@@ -10102,80 +10176,6 @@ var init_search = __esm(() => {
   init_database();
 });
 
-// src/db/storage-tombstones.ts
-function recordStorageTombstone(input, db) {
-  const d = db ?? getDatabase();
-  const deletedAt = input.deleted_at ?? now();
-  const machineId = input.source_machine_id ?? currentStorageMachineId(d);
-  d.run(`INSERT INTO storage_tombstones (
-       id, object_type, object_id, deleted_at, updated_at, source_machine_id, payload, version
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(object_type, object_id) DO UPDATE SET
-       deleted_at = excluded.deleted_at,
-       updated_at = excluded.updated_at,
-       source_machine_id = excluded.source_machine_id,
-       payload = excluded.payload,
-       version = excluded.version
-     WHERE storage_tombstones.updated_at IS NULL OR storage_tombstones.updated_at <= excluded.updated_at`, [
-    uuid(),
-    input.object_type,
-    input.object_id,
-    deletedAt,
-    deletedAt,
-    machineId,
-    input.payload ? JSON.stringify(input.payload) : null,
-    input.version ?? null
-  ]);
-  return getStorageTombstone(input.object_type, input.object_id, d);
-}
-function getStorageTombstone(objectType, objectId, db) {
-  const d = db ?? getDatabase();
-  const row = d.query("SELECT * FROM storage_tombstones WHERE object_type = ? AND object_id = ?").get(objectType, objectId);
-  return row ? rowToStorageTombstone(row) : null;
-}
-function listStorageTombstones(db) {
-  const d = db ?? getDatabase();
-  return d.query("SELECT * FROM storage_tombstones ORDER BY updated_at ASC, object_type ASC, object_id ASC").all().map(rowToStorageTombstone);
-}
-function shouldApplyStorageTombstone(tombstone, existingUpdatedAt) {
-  const tombstoneClock = Date.parse(tombstone.updated_at || tombstone.deleted_at);
-  if (!existingUpdatedAt)
-    return true;
-  const existingClock = Date.parse(existingUpdatedAt);
-  if (Number.isNaN(tombstoneClock))
-    return true;
-  if (Number.isNaN(existingClock))
-    return true;
-  return tombstoneClock >= existingClock;
-}
-function rowToStorageTombstone(row) {
-  return {
-    ...row,
-    payload: parsePayload2(row.payload)
-  };
-}
-function parsePayload2(value) {
-  if (!value)
-    return null;
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function currentStorageMachineId(db) {
-  try {
-    return getMachineId(db);
-  } catch {
-    return null;
-  }
-}
-var init_storage_tombstones = __esm(() => {
-  init_database();
-  init_machines();
-});
-
 // src/db/slug-claims.ts
 function taskListSlugScopeKey(projectId) {
   return projectId ? `project:${projectId}` : "standalone:";
@@ -11906,6 +11906,40 @@ function deleteTaskList(id, db) {
     return d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
   })();
 }
+function deleteTaskListIfUnchangedAndUnused(id, expected, db) {
+  const d = db || getDatabase();
+  return d.transaction(() => {
+    const current = getTaskList(id, d);
+    if (!current) {
+      return { status: "not_found", task_dependents: 0, plan_dependents: 0 };
+    }
+    const changed = current.project_id !== expected.project_id || current.slug !== expected.slug || current.name !== expected.name || current.description !== expected.description || current.updated_at !== expected.updated_at || JSON.stringify(current.metadata) !== JSON.stringify(expected.metadata);
+    if (changed) {
+      return { status: "changed", task_dependents: 0, plan_dependents: 0 };
+    }
+    const taskDependents = Number(d.query("SELECT COUNT(*) AS count FROM tasks WHERE task_list_id = ?").get(id).count);
+    const planDependents = Number(d.query("SELECT COUNT(*) AS count FROM plans WHERE task_list_id = ?").get(id).count);
+    if (taskDependents > 0 || planDependents > 0) {
+      return {
+        status: "has_dependents",
+        task_dependents: taskDependents,
+        plan_dependents: planDependents
+      };
+    }
+    recordStorageTombstone({
+      object_type: "task_lists",
+      object_id: id,
+      payload: current
+    }, d);
+    releaseCanonicalSlugClaims("task_list", id, d);
+    const deleted = d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
+    return {
+      status: deleted ? "deleted" : "not_found",
+      task_dependents: 0,
+      plan_dependents: 0
+    };
+  })();
+}
 function ensureTaskList(name, slug, projectId, db) {
   const d = db || getDatabase();
   const existing = getTaskListBySlug(slug, projectId, d);
@@ -18829,7 +18863,8 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       getBySlug: (slug, projectId) => getTaskListBySlug(slug, projectId, database()),
       list: (projectId) => listTaskLists(projectId, database()),
       update: (id, input) => updateTaskList2(id, input, database()),
-      delete: (id) => deleteTaskList(id, database())
+      delete: (id) => deleteTaskList(id, database()),
+      deleteIfUnchangedAndUnused: (id, expected) => deleteTaskListIfUnchangedAndUnused(id, expected, database())
     },
     templates: {
       create: (input) => createTemplate2(input, database()),
@@ -18894,8 +18929,592 @@ var init_local_sqlite = __esm(() => {
 });
 
 // src/project-registration/sqlite.ts
-var sqliteTransactionTails, PROJECT_REFERENCE_COLUMNS, TASK_LIST_REFERENCE_COLUMNS;
+function sameSqliteValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function taskListFromRow(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function selectProject(db, id) {
+  return db.query("SELECT * FROM projects WHERE id = ? LIMIT 1").get(id);
+}
+function selectTaskList(db, id) {
+  const row = db.query("SELECT * FROM task_lists WHERE id = ? LIMIT 1").get(id);
+  return row ? taskListFromRow(row) : null;
+}
+function selectProjectConflict(db, path, taskListSlug) {
+  return db.query(`
+    SELECT * FROM projects
+    WHERE path = ? OR task_list_id = ?
+    ORDER BY created_at ASC, id ASC
+    LIMIT 1
+  `).get(path, taskListSlug);
+}
+function selectTaskListConflict(db, projectId, slug) {
+  const row = db.query(`
+    SELECT * FROM task_lists
+    WHERE project_id = ? AND slug = ?
+    LIMIT 1
+  `).get(projectId, slug);
+  return row ? taskListFromRow(row) : null;
+}
+function quoteSqliteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function hasSqliteDependents(db, resourceKind, targetId) {
+  const targetTable = resourceKind === "project" ? "projects" : "task_lists";
+  const semanticColumns = resourceKind === "project" ? PROJECT_REFERENCE_COLUMNS : TASK_LIST_REFERENCE_COLUMNS;
+  const tables = db.query(`
+    SELECT name FROM sqlite_schema
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all();
+  for (const { name: tableName } of tables) {
+    const quotedTable = quoteSqliteIdentifier(tableName);
+    const columns = db.query(`PRAGMA table_info(${quotedTable})`).all();
+    const foreignKeys = db.query(`PRAGMA foreign_key_list(${quotedTable})`).all();
+    const referenceColumns = columns.map((column) => column.name).filter((columnName) => semanticColumns.has(columnName) || foreignKeys.some((foreignKey) => foreignKey.from === columnName && foreignKey.table === targetTable));
+    for (const columnName of referenceColumns) {
+      const row = db.query(`
+        SELECT 1 AS found
+        FROM ${quotedTable}
+        WHERE ${quoteSqliteIdentifier(columnName)} = ?
+        LIMIT 1
+      `).get(targetId);
+      if (row)
+        return true;
+    }
+  }
+  return false;
+}
+function receiptFromRow2(row) {
+  return {
+    ...row,
+    authority: "todos",
+    created_by_operation: Number(row["created_by_operation"]) === 1
+  };
+}
+function bindingFromRow2(row) {
+  return row;
+}
+
+class SqliteTodosProjectRegistrationTransaction {
+  db;
+  storage;
+  constructor(db) {
+    this.db = db;
+    this.storage = createLocalSqliteTodosStorageAdapter({ db });
+  }
+  async lockStep(_identity) {}
+  async getReceiptForLookup(identity) {
+    const row = this.db.query(`
+      SELECT * FROM todos_project_registration_receipts
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND operation_id = ? AND step_id = ? AND resource_kind = ?
+        AND direction = ? AND idempotency_key = ? AND target_selector = ?
+      ORDER BY CASE outcome
+        WHEN 'terminal_nonacceptance' THEN 0
+        WHEN 'duplicate_of_accepted' THEN 1
+        ELSE 2
+      END, created_at DESC, receipt_id DESC
+      LIMIT 1
+    `).get(identity.authority_id, identity.tenant_id, identity.corpus_id, identity.operation_id, identity.step_id, identity.resource_kind, identity.direction, identity.idempotency_key, identity.target_selector);
+    return row ? receiptFromRow2(row) : null;
+  }
+  async getReceiptById(receiptId) {
+    const row = this.db.query("SELECT * FROM todos_project_registration_receipts WHERE receipt_id = ? LIMIT 1").get(receiptId);
+    return row ? receiptFromRow2(row) : null;
+  }
+  async getAcceptedReceiptForStep(identity) {
+    const row = this.db.query(`
+      SELECT * FROM todos_project_registration_receipts
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND operation_id = ? AND step_id = ? AND resource_kind = ?
+        AND direction = ? AND outcome = 'accepted'
+      ORDER BY created_at ASC, receipt_id ASC
+      LIMIT 1
+    `).get(identity.authority_id, identity.tenant_id, identity.corpus_id, identity.operation_id, identity.step_id, identity.resource_kind, identity.direction);
+    return row ? receiptFromRow2(row) : null;
+  }
+  async insertReceipt(receipt) {
+    const result = this.db.query(`
+      INSERT OR IGNORE INTO todos_project_registration_receipts (
+        receipt_id, authority, route, package_version, authority_id, tenant_id,
+        corpus_id, operation_id, step_id, resource_kind, direction,
+        target_selector, idempotency_key, request_digest, precondition_digest,
+        normalized_call_digest, outcome, reason, target_id, result_revision,
+        result_digest, duplicate_of_receipt_id, accepted_receipt_id,
+        created_by_operation, created_at
+      ) VALUES (
+        ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?
+      )
+    `).run(receipt.receipt_id, receipt.authority, receipt.route, receipt.package_version, receipt.authority_id, receipt.tenant_id, receipt.corpus_id, receipt.operation_id, receipt.step_id, receipt.resource_kind, receipt.direction, receipt.target_selector, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.normalized_call_digest, receipt.outcome, receipt.reason, receipt.target_id, receipt.result_revision, receipt.result_digest, receipt.duplicate_of_receipt_id, receipt.accepted_receipt_id, receipt.created_by_operation ? 1 : 0, receipt.created_at);
+    return result.changes === 1;
+  }
+  async getBinding(scope, resourceKind, targetSelector) {
+    const row = this.db.query(`
+      SELECT * FROM todos_project_registration_bindings
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND resource_kind = ? AND target_selector = ?
+      LIMIT 1
+    `).get(scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+    return row ? bindingFromRow2(row) : null;
+  }
+  async claimBinding(binding) {
+    const result = this.db.query(`
+      INSERT OR IGNORE INTO todos_project_registration_bindings (
+        authority_id, tenant_id, corpus_id, resource_kind, target_selector,
+        operation_id, step_id, direction, idempotency_key, request_digest,
+        precondition_digest, normalized_call_digest, state, target_id,
+        accepted_receipt_id, result_revision, result_digest, removed_receipt_id,
+        created_at, updated_at
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    `).run(binding.authority_id, binding.tenant_id, binding.corpus_id, binding.resource_kind, binding.target_selector, binding.operation_id, binding.step_id, binding.direction, binding.idempotency_key, binding.request_digest, binding.precondition_digest, binding.normalized_call_digest, binding.state, binding.target_id, binding.accepted_receipt_id, binding.result_revision, binding.result_digest, binding.removed_receipt_id, binding.created_at, binding.updated_at);
+    return result.changes === 1;
+  }
+  async setBindingAccepted(scope, resourceKind, targetSelector, update) {
+    const result = this.db.query(`
+      UPDATE todos_project_registration_bindings
+      SET state = 'accepted', target_id = ?, accepted_receipt_id = ?,
+        result_revision = ?, result_digest = ?, updated_at = ?
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND resource_kind = ? AND target_selector = ? AND state = 'pending'
+    `).run(update.target_id, update.accepted_receipt_id, update.result_revision, update.result_digest, update.updated_at, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+    if (result.changes !== 1) {
+      throw new Error("Todos project registration binding was not pending at acceptance");
+    }
+  }
+  async setBindingTerminal(scope, resourceKind, targetSelector, updatedAt) {
+    this.db.query(`
+      UPDATE todos_project_registration_bindings
+      SET state = 'terminal_nonacceptance', updated_at = ?
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND resource_kind = ? AND target_selector = ? AND state = 'pending'
+    `).run(updatedAt, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+  }
+  async setBindingRemoved(scope, resourceKind, targetSelector, removedReceiptId, updatedAt) {
+    const result = this.db.query(`
+      UPDATE todos_project_registration_bindings
+      SET state = 'removed', removed_receipt_id = ?, updated_at = ?
+      WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+        AND resource_kind = ? AND target_selector = ? AND state = 'accepted'
+    `).run(removedReceiptId, updatedAt, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+    if (result.changes !== 1) {
+      throw new Error("Todos project registration binding was not accepted at removal");
+    }
+  }
+  async findProjectConflict(path, taskListSlug) {
+    const row = this.db.query(`
+      SELECT * FROM projects
+      WHERE path = ? OR task_list_id = ?
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1
+    `).get(path, taskListSlug);
+    return row ?? null;
+  }
+  async findTaskListConflict(projectId, slug) {
+    return await this.storage.taskLists.getBySlug(slug, projectId);
+  }
+  async createProject(input) {
+    return await this.storage.projects.create(input);
+  }
+  async createTaskList(input) {
+    return await this.storage.taskLists.create(input);
+  }
+  async getProject(id) {
+    return await this.storage.projects.get(id);
+  }
+  async getTaskList(id) {
+    return await this.storage.taskLists.get(id);
+  }
+  async lockCompensationWrites() {}
+  async hasDependents(resourceKind, targetId) {
+    return hasSqliteDependents(this.db, resourceKind, targetId);
+  }
+  async deleteProject(id) {
+    return await this.storage.projects.delete(id);
+  }
+  async deleteTaskList(id) {
+    return await this.storage.taskLists.delete(id);
+  }
+}
+
+class StagedSqliteTodosProjectRegistrationTransaction {
+  db;
+  direct;
+  validators = [];
+  mutations = [];
+  receipts = new Map;
+  bindings = new Map;
+  projects = new Map;
+  taskLists = new Map;
+  constructor(db) {
+    this.db = db;
+    this.direct = new SqliteTodosProjectRegistrationTransaction(db);
+  }
+  commit() {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const validate of this.validators) {
+        if (!validate()) {
+          throw new SqliteRegistrationOptimisticConflict("Todos project registration input changed before SQLite commit");
+        }
+      }
+      for (const mutate of this.mutations)
+        mutate();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  async lockStep(_identity) {}
+  async getReceiptForLookup(identity) {
+    const staged = [...this.receipts.values()].filter((receipt) => receipt.authority_id === identity.authority_id && receipt.tenant_id === identity.tenant_id && receipt.corpus_id === identity.corpus_id && receipt.operation_id === identity.operation_id && receipt.step_id === identity.step_id && receipt.resource_kind === identity.resource_kind && receipt.direction === identity.direction && receipt.idempotency_key === identity.idempotency_key && receipt.target_selector === identity.target_selector);
+    const stored = await this.direct.getReceiptForLookup(identity);
+    if (stored)
+      staged.push(stored);
+    const outcomeRank = (receipt) => receipt.outcome === "terminal_nonacceptance" ? 0 : receipt.outcome === "duplicate_of_accepted" ? 1 : 2;
+    return staged.sort((left, right) => outcomeRank(left) - outcomeRank(right) || right.created_at.localeCompare(left.created_at) || right.receipt_id.localeCompare(left.receipt_id))[0] ?? null;
+  }
+  async getReceiptById(receiptId) {
+    return this.receipts.get(receiptId) ?? this.direct.getReceiptById(receiptId);
+  }
+  async getAcceptedReceiptForStep(identity) {
+    const staged = [...this.receipts.values()].filter((receipt) => receipt.authority_id === identity.authority_id && receipt.tenant_id === identity.tenant_id && receipt.corpus_id === identity.corpus_id && receipt.operation_id === identity.operation_id && receipt.step_id === identity.step_id && receipt.resource_kind === identity.resource_kind && receipt.direction === identity.direction && receipt.outcome === "accepted");
+    const stored = await this.direct.getAcceptedReceiptForStep(identity);
+    if (stored)
+      staged.push(stored);
+    return staged.sort((left, right) => left.created_at.localeCompare(right.created_at) || left.receipt_id.localeCompare(right.receipt_id))[0] ?? null;
+  }
+  async insertReceipt(receipt) {
+    if (this.receipts.has(receipt.receipt_id))
+      return false;
+    if (await this.direct.getReceiptById(receipt.receipt_id))
+      return false;
+    const planned = { ...receipt };
+    this.receipts.set(planned.receipt_id, planned);
+    this.mutations.push(() => {
+      try {
+        const result = this.db.query(`
+          INSERT OR IGNORE INTO todos_project_registration_receipts (
+            receipt_id, authority, route, package_version, authority_id, tenant_id,
+            corpus_id, operation_id, step_id, resource_kind, direction,
+            target_selector, idempotency_key, request_digest, precondition_digest,
+            normalized_call_digest, outcome, reason, target_id, result_revision,
+            result_digest, duplicate_of_receipt_id, accepted_receipt_id,
+            created_by_operation, created_at
+          ) VALUES (
+            ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?
+          )
+        `).run(planned.receipt_id, planned.authority, planned.route, planned.package_version, planned.authority_id, planned.tenant_id, planned.corpus_id, planned.operation_id, planned.step_id, planned.resource_kind, planned.direction, planned.target_selector, planned.idempotency_key, planned.request_digest, planned.precondition_digest, planned.normalized_call_digest, planned.outcome, planned.reason, planned.target_id, planned.result_revision, planned.result_digest, planned.duplicate_of_receipt_id, planned.accepted_receipt_id, planned.created_by_operation ? 1 : 0, planned.created_at);
+        if (result.changes !== 1) {
+          throw new SqliteRegistrationOptimisticConflict("Todos project registration receipt changed before SQLite commit");
+        }
+      } catch (error) {
+        if (error instanceof SqliteRegistrationOptimisticConflict)
+          throw error;
+        throw new SqliteRegistrationOptimisticConflict("Todos project registration receipt conflicted at SQLite commit", { cause: error });
+      }
+    });
+    return true;
+  }
+  async getBinding(scope, resourceKind, targetSelector) {
+    const key = this.bindingKey(scope, resourceKind, targetSelector);
+    return this.bindings.get(key) ?? this.direct.getBinding(scope, resourceKind, targetSelector);
+  }
+  async claimBinding(binding) {
+    const key = this.bindingKey(binding, binding.resource_kind, binding.target_selector);
+    if (this.bindings.has(key))
+      return false;
+    if (await this.direct.getBinding(binding, binding.resource_kind, binding.target_selector)) {
+      return false;
+    }
+    const planned = { ...binding };
+    this.bindings.set(key, planned);
+    this.mutations.push(() => {
+      try {
+        const result = this.db.query(`
+          INSERT OR IGNORE INTO todos_project_registration_bindings (
+            authority_id, tenant_id, corpus_id, resource_kind, target_selector,
+            operation_id, step_id, direction, idempotency_key, request_digest,
+            precondition_digest, normalized_call_digest, state, target_id,
+            accepted_receipt_id, result_revision, result_digest, removed_receipt_id,
+            created_at, updated_at
+          ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        `).run(planned.authority_id, planned.tenant_id, planned.corpus_id, planned.resource_kind, planned.target_selector, planned.operation_id, planned.step_id, planned.direction, planned.idempotency_key, planned.request_digest, planned.precondition_digest, planned.normalized_call_digest, planned.state, planned.target_id, planned.accepted_receipt_id, planned.result_revision, planned.result_digest, planned.removed_receipt_id, planned.created_at, planned.updated_at);
+        if (result.changes !== 1) {
+          throw new SqliteRegistrationOptimisticConflict("Todos project registration binding changed before SQLite commit");
+        }
+      } catch (error) {
+        if (error instanceof SqliteRegistrationOptimisticConflict)
+          throw error;
+        throw new SqliteRegistrationOptimisticConflict("Todos project registration binding conflicted at SQLite commit", { cause: error });
+      }
+    });
+    return true;
+  }
+  async setBindingAccepted(scope, resourceKind, targetSelector, update) {
+    const binding = await this.requireBinding(scope, resourceKind, targetSelector, "pending");
+    this.bindings.set(this.bindingKey(scope, resourceKind, targetSelector), {
+      ...binding,
+      state: "accepted",
+      target_id: update.target_id,
+      accepted_receipt_id: update.accepted_receipt_id,
+      result_revision: update.result_revision,
+      result_digest: update.result_digest,
+      updated_at: update.updated_at
+    });
+    this.mutations.push(() => {
+      const result = this.db.query(`
+        UPDATE todos_project_registration_bindings
+        SET state = 'accepted', target_id = ?, accepted_receipt_id = ?,
+          result_revision = ?, result_digest = ?, updated_at = ?
+        WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+          AND resource_kind = ? AND target_selector = ? AND state = 'pending'
+      `).run(update.target_id, update.accepted_receipt_id, update.result_revision, update.result_digest, update.updated_at, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+      if (result.changes !== 1) {
+        throw new SqliteRegistrationOptimisticConflict("Todos project registration binding was no longer pending at SQLite commit");
+      }
+    });
+  }
+  async setBindingTerminal(scope, resourceKind, targetSelector, updatedAt) {
+    const binding = await this.requireBinding(scope, resourceKind, targetSelector, "pending");
+    this.bindings.set(this.bindingKey(scope, resourceKind, targetSelector), {
+      ...binding,
+      state: "terminal_nonacceptance",
+      updated_at: updatedAt
+    });
+    this.mutations.push(() => {
+      const result = this.db.query(`
+        UPDATE todos_project_registration_bindings
+        SET state = 'terminal_nonacceptance', updated_at = ?
+        WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+          AND resource_kind = ? AND target_selector = ? AND state = 'pending'
+      `).run(updatedAt, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+      if (result.changes !== 1) {
+        throw new SqliteRegistrationOptimisticConflict("Todos project registration binding was no longer pending at SQLite commit");
+      }
+    });
+  }
+  async setBindingRemoved(scope, resourceKind, targetSelector, removedReceiptId, updatedAt) {
+    const binding = await this.requireBinding(scope, resourceKind, targetSelector, "accepted");
+    this.bindings.set(this.bindingKey(scope, resourceKind, targetSelector), {
+      ...binding,
+      state: "removed",
+      removed_receipt_id: removedReceiptId,
+      updated_at: updatedAt
+    });
+    this.mutations.push(() => {
+      const result = this.db.query(`
+        UPDATE todos_project_registration_bindings
+        SET state = 'removed', removed_receipt_id = ?, updated_at = ?
+        WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+          AND resource_kind = ? AND target_selector = ? AND state = 'accepted'
+      `).run(removedReceiptId, updatedAt, scope.authority_id, scope.tenant_id, scope.corpus_id, resourceKind, targetSelector);
+      if (result.changes !== 1) {
+        throw new SqliteRegistrationOptimisticConflict("Todos project registration binding was no longer accepted at SQLite commit");
+      }
+    });
+  }
+  async findProjectConflict(path, taskListSlug) {
+    const planned = [...this.projects.values()].find((project) => project?.path === path || project?.task_list_id === taskListSlug);
+    if (planned)
+      return planned;
+    const observed = selectProjectConflict(this.db, path, taskListSlug);
+    this.validators.push(() => sameSqliteValue(selectProjectConflict(this.db, path, taskListSlug), observed));
+    return observed;
+  }
+  async findTaskListConflict(projectId, slug) {
+    const planned = [...this.taskLists.values()].find((taskList) => taskList?.project_id === projectId && taskList.slug === slug);
+    if (planned)
+      return planned;
+    const observed = selectTaskListConflict(this.db, projectId, slug);
+    this.validators.push(() => sameSqliteValue(selectTaskListConflict(this.db, projectId, slug), observed));
+    return observed;
+  }
+  async createProject(input) {
+    const derivedSlug = normalizeSlug(input.name);
+    const taskListId = input.task_list_id === undefined ? `todos-${derivedSlug}` : normalizeSlug(input.task_list_id);
+    if (!derivedSlug || !taskListId) {
+      throw new Error("Project name and task-list slug must be non-empty");
+    }
+    const project = {
+      id: uuid(),
+      name: input.name,
+      path: input.path,
+      description: input.description || null,
+      task_list_id: taskListId,
+      task_prefix: input.task_prefix ?? this.availableProjectPrefix(input.name),
+      task_counter: 0,
+      created_at: now(),
+      updated_at: now(),
+      machine_id: currentStorageMachineId(this.db)
+    };
+    project.updated_at = project.created_at;
+    this.projects.set(project.id, project);
+    this.mutations.push(() => {
+      try {
+        const result = this.db.run(`INSERT INTO projects (
+             id, name, path, description, task_list_id, task_prefix,
+             task_counter, created_at, updated_at, machine_id
+           ) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [
+          project.id,
+          project.name,
+          project.path,
+          project.description,
+          project.task_list_id,
+          project.task_prefix,
+          project.created_at,
+          project.updated_at,
+          project.machine_id ?? null
+        ]);
+        if (result.changes < 1) {
+          throw new SqliteRegistrationOptimisticConflict("Todos project changed before SQLite registration commit");
+        }
+      } catch (error) {
+        if (error instanceof SqliteRegistrationOptimisticConflict)
+          throw error;
+        throw new SqliteRegistrationOptimisticConflict("Todos project conflicted at SQLite registration commit", { cause: error });
+      }
+    });
+    return project;
+  }
+  async createTaskList(input) {
+    const slug = normalizeSlug(input.slug === undefined ? input.name : input.slug);
+    if (!slug)
+      throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
+    const taskList = {
+      id: uuid(),
+      project_id: input.project_id || null,
+      slug,
+      name: input.name,
+      description: input.description || null,
+      metadata: input.metadata ?? {},
+      created_at: now(),
+      updated_at: now(),
+      machine_id: currentStorageMachineId(this.db)
+    };
+    taskList.updated_at = taskList.created_at;
+    this.taskLists.set(taskList.id, taskList);
+    this.mutations.push(() => {
+      try {
+        const result = this.db.run(`INSERT INTO task_lists (
+             id, project_id, slug, name, description, metadata,
+             created_at, updated_at, machine_id
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+          taskList.id,
+          taskList.project_id,
+          taskList.slug,
+          taskList.name,
+          taskList.description,
+          JSON.stringify(taskList.metadata),
+          taskList.created_at,
+          taskList.updated_at,
+          taskList.machine_id ?? null
+        ]);
+        if (result.changes < 1) {
+          throw new SqliteRegistrationOptimisticConflict("Todos task list changed before SQLite registration commit");
+        }
+      } catch (error) {
+        if (error instanceof SqliteRegistrationOptimisticConflict)
+          throw error;
+        throw new SqliteRegistrationOptimisticConflict("Todos task list conflicted at SQLite registration commit", { cause: error });
+      }
+    });
+    return taskList;
+  }
+  async getProject(id) {
+    if (this.projects.has(id))
+      return this.projects.get(id) ?? null;
+    const observed = selectProject(this.db, id);
+    this.validators.push(() => sameSqliteValue(selectProject(this.db, id), observed));
+    return observed;
+  }
+  async getTaskList(id) {
+    if (this.taskLists.has(id))
+      return this.taskLists.get(id) ?? null;
+    const observed = selectTaskList(this.db, id);
+    this.validators.push(() => sameSqliteValue(selectTaskList(this.db, id), observed));
+    return observed;
+  }
+  async lockCompensationWrites() {}
+  async hasDependents(resourceKind, targetId) {
+    const observed = hasSqliteDependents(this.db, resourceKind, targetId);
+    this.validators.push(() => hasSqliteDependents(this.db, resourceKind, targetId) === observed);
+    return observed;
+  }
+  async deleteProject(id) {
+    const project = await this.getProject(id);
+    if (!project)
+      return false;
+    this.projects.set(id, null);
+    this.mutations.push(() => {
+      recordStorageTombstone({
+        object_type: "projects",
+        object_id: id,
+        payload: project
+      }, this.db);
+      if (this.db.run("DELETE FROM projects WHERE id = ?", [id]).changes < 1) {
+        throw new SqliteRegistrationOptimisticConflict("Todos project changed before SQLite compensation commit");
+      }
+    });
+    return true;
+  }
+  async deleteTaskList(id) {
+    const taskList = await this.getTaskList(id);
+    if (!taskList)
+      return false;
+    this.taskLists.set(id, null);
+    this.mutations.push(() => {
+      recordStorageTombstone({
+        object_type: "task_lists",
+        object_id: id,
+        payload: taskList
+      }, this.db);
+      if (this.db.run("DELETE FROM task_lists WHERE id = ?", [id]).changes < 1) {
+        throw new SqliteRegistrationOptimisticConflict("Todos task list changed before SQLite compensation commit");
+      }
+    });
+    return true;
+  }
+  bindingKey(scope, resourceKind, targetSelector) {
+    return JSON.stringify([
+      scope.authority_id,
+      scope.tenant_id,
+      scope.corpus_id,
+      resourceKind,
+      targetSelector
+    ]);
+  }
+  async requireBinding(scope, resourceKind, targetSelector, state) {
+    const binding = await this.getBinding(scope, resourceKind, targetSelector);
+    if (!binding || binding.state !== state) {
+      throw new Error(`Todos project registration binding was not ${state}`);
+    }
+    return binding;
+  }
+  availableProjectPrefix(name) {
+    const words = name.replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/);
+    const prefix = words.length >= 3 ? words.slice(0, 3).map((word) => word[0].toUpperCase()).join("") : words.length === 2 ? (words[0].slice(0, 2) + words[1][0]).toUpperCase() : words[0].slice(0, 3).toUpperCase();
+    let candidate = prefix;
+    let suffix = 1;
+    while (this.db.query("SELECT id FROM projects WHERE task_prefix = ? LIMIT 1").get(candidate) || [...this.projects.values()].some((project) => project?.task_prefix === candidate)) {
+      suffix += 1;
+      candidate = `${prefix}${suffix}`;
+    }
+    return candidate;
+  }
+}
+var sqliteTransactionTails, PROJECT_REFERENCE_COLUMNS, TASK_LIST_REFERENCE_COLUMNS, SqliteRegistrationOptimisticConflict;
 var init_sqlite = __esm(() => {
+  init_database();
+  init_storage_tombstones();
   init_local_sqlite();
   sqliteTransactionTails = new WeakMap;
   PROJECT_REFERENCE_COLUMNS = new Set([
@@ -18905,6 +19524,12 @@ var init_sqlite = __esm(() => {
     "external_project_id"
   ]);
   TASK_LIST_REFERENCE_COLUMNS = new Set(["task_list_id"]);
+  SqliteRegistrationOptimisticConflict = class SqliteRegistrationOptimisticConflict extends Error {
+    constructor(message, options = {}) {
+      super(message, options);
+      this.name = "SqliteRegistrationOptimisticConflict";
+    }
+  };
 });
 
 // src/project-registration/authority.ts
@@ -22248,6 +22873,9 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         Task: taskSchema,
         Project: projectSchema,
         TaskList: taskListSchema,
+        ProjectTaskListEnsureReceipt: projectTaskListEnsureReceiptSchema,
+        ProjectTaskListEnsureResult: projectTaskListEnsureResultSchema,
+        ProjectTaskListRollbackResult: projectTaskListRollbackResultSchema,
         TaskComment: taskCommentSchema,
         Plan: planSchema,
         Template: templateSchema,
@@ -22325,6 +22953,29 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             name: { type: "string", minLength: 1 }
           }
         },
+        ProjectTaskListEnsureApplyInput: {
+          type: "object",
+          additionalProperties: false,
+          required: ["expected_project_revision"],
+          properties: {
+            expected_project_revision: { type: "string", minLength: 1 },
+            idempotency_key: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128,
+              pattern: "^[A-Za-z0-9._:-]+$"
+            }
+          }
+        },
+        ProjectTaskListRollbackInput: {
+          type: "object",
+          additionalProperties: false,
+          required: ["receipt_id", "expected_task_list_revision"],
+          properties: {
+            receipt_id: { type: "string", minLength: 1 },
+            expected_task_list_revision: { type: "string", minLength: 1 }
+          }
+        },
         ErrorResponse: {
           type: "object",
           required: ["error"],
@@ -23427,6 +24078,51 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { deleted: { type: "boolean" }, id: { type: "string" } } } } } } }
         }
       },
+      "/v1/projects/{id}/task-list/ensure": {
+        get: {
+          operationId: "planProjectTaskListEnsure",
+          summary: "Plan a non-mutating repair of a project's declared task list",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListEnsureResult" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        },
+        post: {
+          operationId: "ensureProjectTaskList",
+          summary: "Idempotently create an existing project's declared task list",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListEnsureApplyInput" } } }
+          },
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListEnsureResult" } } } },
+            "201": { content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListEnsureResult" } } } },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
+      "/v1/projects/{id}/task-list/rollback": {
+        post: {
+          operationId: "rollbackProjectTaskListEnsure",
+          summary: "Conditionally remove an unchanged task list created by an accepted ensure receipt",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListRollbackInput" } } }
+          },
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/ProjectTaskListRollbackResult" } } } },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
       "/v1/projects/{id}/rename": {
         post: {
           operationId: "renameProject",
@@ -23708,7 +24404,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     }
   };
 }
-var taskSchema, projectSchema, taskListSchema, taskCommentSchema, planSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
+var taskSchema, projectSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, planSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
 var init_openapi = __esm(() => {
   init_package_version();
   init_types();
@@ -23756,6 +24452,80 @@ var init_openapi = __esm(() => {
       updated_at: { type: "string" }
     }
   };
+  projectTaskListEnsureReceiptSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "schema_version",
+      "receipt_id",
+      "idempotency_key",
+      "project_id",
+      "task_list_id",
+      "slug",
+      "created_by_operation",
+      "result_revision",
+      "result_digest",
+      "rollback_supported",
+      "created_at"
+    ],
+    properties: {
+      schema_version: { type: "string", enum: ["todos.project-task-list-ensure.v1"] },
+      receipt_id: { type: "string" },
+      idempotency_key: { type: "string" },
+      project_id: { type: "string" },
+      task_list_id: { type: "string" },
+      slug: { type: "string" },
+      created_by_operation: { type: "boolean" },
+      result_revision: { type: "string" },
+      result_digest: { type: "string" },
+      rollback_supported: { type: "boolean" },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
+  projectTaskListEnsureResultSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["mode", "action", "project", "task_list", "receipt"],
+    properties: {
+      mode: { type: "string", enum: ["plan", "apply"] },
+      action: { type: "string", enum: ["would_create", "created", "already_present"] },
+      project: { $ref: "#/components/schemas/Project" },
+      task_list: {
+        oneOf: [
+          { $ref: "#/components/schemas/TaskList" },
+          { type: "null" }
+        ]
+      },
+      receipt: {
+        oneOf: [
+          { $ref: "#/components/schemas/ProjectTaskListEnsureReceipt" },
+          { type: "null" }
+        ]
+      }
+    }
+  };
+  projectTaskListRollbackResultSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "schema_version",
+      "action",
+      "project_id",
+      "task_list_id",
+      "accepted_receipt_id",
+      "rollback_receipt_id",
+      "removed_at"
+    ],
+    properties: {
+      schema_version: { type: "string", enum: ["todos.project-task-list-ensure.v1"] },
+      action: { type: "string", enum: ["removed"] },
+      project_id: { type: "string" },
+      task_list_id: { type: "string" },
+      accepted_receipt_id: { type: "string" },
+      rollback_receipt_id: { type: "string" },
+      removed_at: { type: "string", format: "date-time" }
+    }
+  };
   taskCommentSchema = {
     type: "object",
     required: ["id", "task_id", "agent_id", "session_id", "content", "type", "progress_pct", "created_at"],
@@ -23989,6 +24759,261 @@ function decodeCommentCursor(value) {
 }
 var MAX_COMMENT_CURSOR_LENGTH = 1024;
 
+// src/lib/project-task-list-ensure.ts
+import { createHash as createHash7 } from "crypto";
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+}
+function digest(value) {
+  return createHash7("sha256").update(canonicalJson(value)).digest("hex");
+}
+function deriveIdempotencyKey(projectId, slug) {
+  return `ptlk_${digest({ project_id: projectId, slug }).slice(0, 48)}`;
+}
+function normalizeIdempotencyKey(value, projectId, slug) {
+  const key = value?.trim() || deriveIdempotencyKey(projectId, slug);
+  if (key.length < 8 || key.length > 128 || !/^[A-Za-z0-9._:-]+$/.test(key)) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_IDEMPOTENCY_KEY_INVALID", "idempotency_key must be 8-128 ASCII letters, digits, dots, underscores, colons, or hyphens");
+  }
+  return key;
+}
+function receiptId2(projectId, slug, idempotencyKey) {
+  return `ptlr_${digest({ project_id: projectId, slug, idempotency_key: idempotencyKey }).slice(0, 48)}`;
+}
+function semanticListDigest(list) {
+  const metadata = { ...list.metadata ?? {} };
+  delete metadata[RECEIPT_METADATA_KEY];
+  return digest({
+    project_id: list.project_id,
+    slug: list.slug,
+    name: list.name,
+    description: list.description,
+    metadata
+  });
+}
+function storedMarker(list) {
+  const value = list.metadata?.[RECEIPT_METADATA_KEY];
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const marker = value;
+  if (marker.schema_version !== PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION || typeof marker.receipt_id !== "string" || typeof marker.idempotency_key !== "string" || typeof marker.project_id !== "string" || typeof marker.slug !== "string" || typeof marker.result_digest !== "string" || typeof marker.created_at !== "string")
+    return null;
+  return marker;
+}
+function receiptFor(store, project, list, idempotencyKey) {
+  const marker = storedMarker(list);
+  const owned = marker?.project_id === project.id && marker.slug === list.slug;
+  if (owned && marker.idempotency_key !== idempotencyKey) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_IDEMPOTENCY_CONFLICT", "The operation-owned task list was created under a different idempotency key", {
+      project_id: project.id,
+      task_list_id: list.id,
+      receipt_id: marker.receipt_id
+    });
+  }
+  return {
+    schema_version: PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION,
+    receipt_id: owned ? marker.receipt_id : `ptlr_existing_${digest({ project_id: project.id, task_list_id: list.id }).slice(0, 39)}`,
+    idempotency_key: owned ? marker.idempotency_key : idempotencyKey,
+    project_id: project.id,
+    task_list_id: list.id,
+    slug: list.slug,
+    created_by_operation: owned,
+    result_revision: list.updated_at,
+    result_digest: owned ? marker.result_digest : semanticListDigest(list),
+    rollback_supported: Boolean(owned && semanticListDigest(list) === marker.result_digest && store.taskLists.deleteIfUnchangedAndUnused),
+    created_at: owned ? marker.created_at : list.created_at
+  };
+}
+async function exactProjectState(store, projectId) {
+  const project = await store.projects.get(projectId);
+  if (!project) {
+    throw new ProjectTaskListEnsureError("PROJECT_NOT_FOUND", `Project not found: ${projectId}`, { project_id: projectId });
+  }
+  const slug = project.task_list_id?.trim();
+  if (!slug) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_NOT_DECLARED", "Project does not declare a canonical task_list_id slug", { project_id: project.id });
+  }
+  const all = await store.taskLists.list();
+  const scopedMatches = all.filter((list) => list.project_id === project.id && list.slug === slug);
+  if (scopedMatches.length > 1) {
+    throw new ProjectTaskListEnsureError("TASK_LIST_SCOPE_COLLISION", "More than one task list matches the project's exact id and declared slug", { project_id: project.id, slug, task_list_ids: scopedMatches.map((list) => list.id) });
+  }
+  const globalMatches = all.filter((list) => list.project_id === null && list.slug === slug);
+  if (globalMatches.length > 0 && scopedMatches.length === 0) {
+    throw new ProjectTaskListEnsureError("TASK_LIST_SCOPE_COLLISION", "A legacy global task list already owns the declared slug; refusing to create a second locator", { project_id: project.id, slug, task_list_ids: globalMatches.map((list) => list.id) });
+  }
+  return { project, scoped: scopedMatches[0] ?? null, globalCollision: globalMatches[0] ?? null };
+}
+async function planProjectTaskListEnsure(store, projectId) {
+  const { project, scoped } = await exactProjectState(store, projectId);
+  return {
+    mode: "plan",
+    action: scoped ? "already_present" : "would_create",
+    project,
+    task_list: scoped,
+    receipt: null
+  };
+}
+async function applyProjectTaskListEnsure(store, projectId, options) {
+  const state = await exactProjectState(store, projectId);
+  const { project } = state;
+  if (project.updated_at !== options.expected_project_revision) {
+    throw new ProjectTaskListEnsureError("PROJECT_REVISION_CONFLICT", "Project changed after the ensure plan; fetch a fresh plan before applying", {
+      project_id: project.id,
+      expected_project_revision: options.expected_project_revision,
+      current_project_revision: project.updated_at
+    });
+  }
+  const slug = project.task_list_id;
+  const idempotencyKey = normalizeIdempotencyKey(options.idempotency_key, project.id, slug);
+  if (state.scoped) {
+    return {
+      mode: "apply",
+      action: "already_present",
+      project,
+      task_list: state.scoped,
+      receipt: receiptFor(store, project, state.scoped, idempotencyKey)
+    };
+  }
+  const marker = {
+    schema_version: PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION,
+    receipt_id: receiptId2(project.id, slug, idempotencyKey),
+    idempotency_key: idempotencyKey,
+    project_id: project.id,
+    slug,
+    result_digest: semanticListDigest({
+      project_id: project.id,
+      slug,
+      name: project.name,
+      description: null,
+      metadata: {}
+    }),
+    created_at: new Date().toISOString()
+  };
+  let list;
+  try {
+    list = await store.taskLists.create({
+      name: project.name,
+      slug,
+      project_id: project.id,
+      metadata: { [RECEIPT_METADATA_KEY]: marker }
+    });
+  } catch (error) {
+    if (!(error instanceof ResourceConflictError))
+      throw error;
+    const raced = await exactProjectState(store, projectId);
+    if (!raced.scoped)
+      throw error;
+    if (raced.project.updated_at !== options.expected_project_revision || raced.project.task_list_id !== slug) {
+      throw new ProjectTaskListEnsureError("PROJECT_REVISION_CONFLICT", "Project changed while the task list was being created; fetch a fresh plan before retrying", {
+        project_id: raced.project.id,
+        expected_project_revision: options.expected_project_revision,
+        current_project_revision: raced.project.updated_at
+      });
+    }
+    return {
+      mode: "apply",
+      action: "already_present",
+      project: raced.project,
+      task_list: raced.scoped,
+      receipt: receiptFor(store, raced.project, raced.scoped, idempotencyKey)
+    };
+  }
+  const projectReadback = await store.projects.get(project.id);
+  if (!projectReadback || projectReadback.updated_at !== options.expected_project_revision || projectReadback.task_list_id !== slug) {
+    let compensated = false;
+    const unchanged = await store.taskLists.get(list.id);
+    const unchangedMarker = unchanged ? storedMarker(unchanged) : null;
+    if (unchanged && unchangedMarker?.receipt_id === marker.receipt_id && semanticListDigest(unchanged) === marker.result_digest && store.taskLists.deleteIfUnchangedAndUnused) {
+      const deletion = await store.taskLists.deleteIfUnchangedAndUnused(list.id, {
+        project_id: unchanged.project_id,
+        slug: unchanged.slug,
+        name: unchanged.name,
+        description: unchanged.description,
+        metadata: unchanged.metadata,
+        updated_at: unchanged.updated_at
+      });
+      compensated = deletion.status === "deleted";
+    }
+    throw new ProjectTaskListEnsureError("PROJECT_REVISION_CONFLICT", compensated ? "Project changed while the task list was being created; the new list was rolled back" : "Project changed while the task list was being created; the new list was retained because safe conditional rollback could not be proven", { project_id: project.id, task_list_id: list.id, compensated });
+  }
+  const readback = await store.taskLists.get(list.id);
+  if (!readback || readback.project_id !== project.id || readback.slug !== slug) {
+    throw new ProjectTaskListEnsureError("TASK_LIST_SCOPE_COLLISION", "Task-list create did not preserve the exact project id and declared slug", { project_id: project.id, task_list_id: list.id, slug });
+  }
+  return {
+    mode: "apply",
+    action: "created",
+    project: projectReadback,
+    task_list: readback,
+    receipt: receiptFor(store, projectReadback, readback, idempotencyKey)
+  };
+}
+async function rollbackProjectTaskListEnsure(store, projectId, options) {
+  const conditionalDelete = store.taskLists.deleteIfUnchangedAndUnused;
+  if (!conditionalDelete) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_ROLLBACK_CONFLICT", "This storage backend cannot guarantee atomic conditional rollback; refusing to delete", { project_id: projectId, receipt_id: options.receipt_id });
+  }
+  const project = await store.projects.get(projectId);
+  if (!project) {
+    throw new ProjectTaskListEnsureError("PROJECT_NOT_FOUND", `Project not found: ${projectId}`);
+  }
+  const candidates = (await store.taskLists.list(project.id)).filter((list2) => storedMarker(list2)?.receipt_id === options.receipt_id);
+  if (candidates.length !== 1) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_RECEIPT_NOT_FOUND", "No exact operation-owned task list matches this rollback receipt", { project_id: project.id, receipt_id: options.receipt_id });
+  }
+  const list = candidates[0];
+  const marker = storedMarker(list);
+  if (marker.project_id !== project.id || marker.slug !== list.slug || list.project_id !== project.id || list.updated_at !== options.expected_task_list_revision || semanticListDigest(list) !== marker.result_digest) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_ROLLBACK_CONFLICT", "The operation-owned task list drifted; refusing conditional rollback", { project_id: project.id, task_list_id: list.id, receipt_id: options.receipt_id });
+  }
+  const deletion = await conditionalDelete.call(store.taskLists, list.id, {
+    project_id: list.project_id,
+    slug: list.slug,
+    name: list.name,
+    description: list.description,
+    metadata: list.metadata,
+    updated_at: list.updated_at
+  });
+  if (deletion.status === "has_dependents") {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_ROLLBACK_HAS_DEPENDENTS", "The operation-owned task list has dependents; refusing conditional rollback", {
+      task_list_id: list.id,
+      task_dependents: deletion.task_dependents,
+      plan_dependents: deletion.plan_dependents
+    });
+  }
+  if (deletion.status !== "deleted" || await store.taskLists.get(list.id)) {
+    throw new ProjectTaskListEnsureError("PROJECT_TASK_LIST_ROLLBACK_CONFLICT", "Conditional rollback did not remove the exact task list", { task_list_id: list.id });
+  }
+  return {
+    schema_version: PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION,
+    action: "removed",
+    project_id: project.id,
+    task_list_id: list.id,
+    accepted_receipt_id: options.receipt_id,
+    rollback_receipt_id: `ptlr_inverse_${digest({ accepted_receipt_id: options.receipt_id }).slice(0, 38)}`,
+    removed_at: new Date().toISOString()
+  };
+}
+var PROJECT_TASK_LIST_ENSURE_SCHEMA_VERSION = "todos.project-task-list-ensure.v1", RECEIPT_METADATA_KEY = "todos_project_task_list_ensure", ProjectTaskListEnsureError;
+var init_project_task_list_ensure = __esm(() => {
+  init_types();
+  ProjectTaskListEnsureError = class ProjectTaskListEnsureError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+      super(message);
+      this.code = code;
+      this.details = details;
+      this.name = "ProjectTaskListEnsureError";
+    }
+  };
+});
+
 // src/server/v1.ts
 var exports_v1 = {};
 __export(exports_v1, {
@@ -24776,6 +25801,52 @@ async function handleV1Request(req, url, dependencies = {}) {
         }
         return error(405, `method ${method} not allowed on /v1/projects`);
       }
+      if (action === "task-list" && subId === "ensure") {
+        if (method === "GET") {
+          return json4(await planProjectTaskListEnsure(store, id));
+        }
+        if (method !== "POST") {
+          return error(405, `method ${method} not allowed on /v1/projects/:id/task-list/ensure`);
+        }
+        const body = await readJson3(req);
+        if (!body)
+          return error(400, "invalid JSON body");
+        const unknown = Object.keys(body).find((key) => !["expected_project_revision", "idempotency_key"].includes(key));
+        if (unknown)
+          return error(400, `unknown task-list ensure field: ${unknown}`);
+        if (typeof body.expected_project_revision !== "string" || !body.expected_project_revision.trim()) {
+          return error(400, "expected_project_revision must be a non-empty string from a fresh ensure plan");
+        }
+        if (body.idempotency_key !== undefined && typeof body.idempotency_key !== "string") {
+          return error(400, "idempotency_key must be a string");
+        }
+        const result = await applyProjectTaskListEnsure(store, id, {
+          expected_project_revision: body.expected_project_revision,
+          ...typeof body.idempotency_key === "string" ? { idempotency_key: body.idempotency_key } : {}
+        });
+        return json4(result, result.action === "created" ? 201 : 200);
+      }
+      if (action === "task-list" && subId === "rollback") {
+        if (method !== "POST") {
+          return error(405, `method ${method} not allowed on /v1/projects/:id/task-list/rollback`);
+        }
+        const body = await readJson3(req);
+        if (!body)
+          return error(400, "invalid JSON body");
+        const unknown = Object.keys(body).find((key) => !["receipt_id", "expected_task_list_revision"].includes(key));
+        if (unknown)
+          return error(400, `unknown task-list rollback field: ${unknown}`);
+        if (typeof body.receipt_id !== "string" || !body.receipt_id.trim()) {
+          return error(400, "receipt_id must be a non-empty string");
+        }
+        if (typeof body.expected_task_list_revision !== "string" || !body.expected_task_list_revision.trim()) {
+          return error(400, "expected_task_list_revision must be a non-empty string from the accepted receipt");
+        }
+        return json4(await rollbackProjectTaskListEnsure(store, id, {
+          receipt_id: body.receipt_id,
+          expected_task_list_revision: body.expected_task_list_revision
+        }));
+      }
       if (action === "rename") {
         if (method !== "POST")
           return error(405, `method ${method} not allowed on /v1/projects/:id/rename`);
@@ -25114,6 +26185,10 @@ async function handleV1Request(req, url, dependencies = {}) {
     }
     return error(404, `unknown /v1 resource: ${resource ?? "(root)"}`);
   } catch (e) {
+    if (e instanceof ProjectTaskListEnsureError) {
+      const status = e.code === "PROJECT_NOT_FOUND" || e.code === "PROJECT_TASK_LIST_RECEIPT_NOT_FOUND" ? 404 : e.code === "PROJECT_TASK_LIST_IDEMPOTENCY_KEY_INVALID" ? 400 : 409;
+      return error(status, e.message, { code: e.code, conflict: status === 409, ...e.details });
+    }
     if (e instanceof TaskReferenceAmbiguousError) {
       return error(409, e.message, {
         code: TaskReferenceAmbiguousError.code,
@@ -25140,6 +26215,7 @@ var init_v1 = __esm(() => {
   init_pr_groups();
   init_project_registration();
   init_redaction();
+  init_project_task_list_ensure();
   JSON_HEADERS3 = { "Content-Type": "application/json" };
 });
 
@@ -60082,12 +61158,16 @@ function protectRemoteClient(client) {
 function remoteAuthorityBase(client) {
   return client.baseUrl.replace(/\/v1\/?$/, "");
 }
-async function requiredRemoteRoute(client, route, request) {
+async function requiredRemoteRoute(client, route, request, recognized404Codes = []) {
   try {
     return await request();
   } catch (error3) {
     const status = error3 && typeof error3 === "object" ? error3.status : undefined;
     if (status === 404) {
+      const body = error3 && typeof error3 === "object" ? error3.body : undefined;
+      const code = body && typeof body === "object" && !Array.isArray(body) ? body.code : undefined;
+      if (typeof code === "string" && recognized404Codes.includes(code))
+        throw error3;
       throw new Error(`REMOTE_API_INCOMPATIBLE: configured Todos authority ${remoteAuthorityBase(client)} does not expose ${route}; ` + "deploy the @hasna/todos /v1 server contract before retrying; local SQLite fallback is disabled", { cause: error3 });
     }
     throw error3;
@@ -62790,12 +63870,12 @@ var init_local_notifications = __esm(() => {
 });
 
 // src/lib/local-encryption.ts
-import { createCipheriv, createDecipheriv, createHash as createHash7, randomBytes as randomBytes3, scryptSync, timingSafeEqual as timingSafeEqual4 } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash8, randomBytes as randomBytes3, scryptSync, timingSafeEqual as timingSafeEqual4 } from "crypto";
 function now3() {
   return new Date().toISOString();
 }
 function sha2563(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function normalizeProfileName(value) {
   const name = (value || DEFAULT_ENCRYPTION_PROFILE).trim();
@@ -64933,7 +66013,7 @@ var init_capacity_forecasts = __esm(() => {
 });
 
 // src/lib/audit-ledger.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function canonicalize2(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
@@ -64943,7 +66023,7 @@ function canonicalize2(value) {
   return `{${Object.keys(object4).sort().map((key) => `${JSON.stringify(key)}:${canonicalize2(object4[key])}`).join(",")}}`;
 }
 function hash(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function parsePayload3(value) {
   if (!value)
@@ -98044,7 +99124,7 @@ var init_local_bridge = __esm(() => {
 });
 
 // src/lib/local-backups.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7, resolve as resolve13 } from "path";
 import { mkdirSync as mkdirSync6 } from "fs";
@@ -98057,7 +99137,7 @@ function stableJson2(value) {
   return `{${Object.keys(record3).sort().map((key) => `${JSON.stringify(key)}:${stableJson2(record3[key])}`).join(",")}}`;
 }
 function sha2564(value) {
-  return createHash9("sha256").update(stableJson2(value)).digest("hex");
+  return createHash10("sha256").update(stableJson2(value)).digest("hex");
 }
 function sqliteIntegrity(db) {
   let quick = "unknown";
@@ -98707,7 +99787,7 @@ var init_onboarding_fixtures = __esm(() => {
 });
 
 // src/lib/local-snapshots.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 function source(version2) {
   return {
     packageName: "@hasna/todos",
@@ -98731,7 +99811,7 @@ function stable(value) {
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stable(item)]));
 }
 function sha2565(value) {
-  return createHash10("sha256").update(JSON.stringify(stable(value))).digest("hex");
+  return createHash11("sha256").update(JSON.stringify(stable(value))).digest("hex");
 }
 function latestTimestamp2(items, fallback) {
   const timestamps = [];
@@ -99297,7 +100377,7 @@ var init_retrospectives = __esm(() => {
 });
 
 // src/lib/agent-replay-simulator.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -99318,7 +100398,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable2(value[key])]));
 }
 function fingerprint2(value) {
-  return createHash11("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash12("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject2(input))
@@ -99605,7 +100685,7 @@ __export(exports_local_extensions, {
   getLocalExtension: () => getLocalExtension,
   discoverLocalExtensions: () => discoverLocalExtensions
 });
-import { createHash as createHash12, createVerify } from "crypto";
+import { createHash as createHash13, createVerify } from "crypto";
 import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
 import { basename as basename5, join as join12, resolve as resolve14 } from "path";
 function isObject3(value) {
@@ -99691,7 +100771,7 @@ function parseJson(path) {
   return JSON.parse(readFileSync9(path, "utf8"));
 }
 function sha2566(bytes) {
-  return `sha256:${createHash12("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash13("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -100166,7 +101246,7 @@ function issueToTask(issue2, opts) {
 var init_github = () => {};
 
 // src/db/inbox.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function parseMetadata3(value) {
   if (!value)
     return {};
@@ -100186,7 +101266,7 @@ function compactWhitespace(value) {
 function fingerprintInboxInput(input) {
   const sourceType = input.source_type || detectInboxSourceType(input.body, input.source_url);
   const normalized = compactWhitespace(sanitizePreWriteText(input.body, "inbox.fingerprint")).slice(0, 8000);
-  return createHash13("sha256").update(`${sourceType}
+  return createHash14("sha256").update(`${sourceType}
 ${input.source_url || ""}
 ${normalized}`).digest("hex");
 }
@@ -104386,10 +105466,10 @@ __export(exports_extract, {
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
 import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { relative as relative5, resolve as resolve15, join as join13 } from "path";
 function stableHash(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -106113,13 +107193,13 @@ __export(exports_environment_snapshots, {
   compareEnvironmentSnapshotFiles: () => compareEnvironmentSnapshotFiles,
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
 import { dirname as dirname8, join as join15, resolve as resolve16 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 function sha2567(value) {
-  return createHash15("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
   const path = join15(root, relativePath);
@@ -106234,8 +107314,8 @@ function defaultSnapshotDir() {
   return join15(dirname8(resolve16(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
-  const digest = sha2567(JSON.stringify(snapshot)).slice(0, 24);
-  return { id: `env_${digest}`, ...snapshot };
+  const digest2 = sha2567(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest2}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
   const root = resolve16(input.root || process.cwd());