@hasna/todos 0.15.7 → 0.15.9

package/dist/cli/index.js

@@ -2123,7 +2123,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",
@@ -5273,12 +5273,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 (error) {
     const status = error && typeof error === "object" ? error.status : undefined;
     if (status === 404) {
+      const body = error && typeof error === "object" ? error.body : undefined;
+      const code = body && typeof body === "object" && !Array.isArray(body) ? body.code : undefined;
+      if (typeof code === "string" && recognized404Codes.includes(code))
+        throw error;
       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: error });
     }
     throw error;
@@ -5693,6 +5697,15 @@ async function cloudDeleteProject(client, id) {
   }
   return true;
 }
+async function cloudPlanProjectTaskListEnsure(client, projectId) {
+  return requiredRemoteRoute(client, "/v1/projects/:id/task-list/ensure", () => client.transport.get(`/projects/${encodeURIComponent(projectId)}/task-list/ensure`), ["PROJECT_NOT_FOUND"]);
+}
+async function cloudApplyProjectTaskListEnsure(client, projectId, input) {
+  return requiredRemoteRoute(client, "/v1/projects/:id/task-list/ensure", () => client.transport.post(`/projects/${encodeURIComponent(projectId)}/task-list/ensure`, input), ["PROJECT_NOT_FOUND"]);
+}
+async function cloudRollbackProjectTaskListEnsure(client, projectId, input) {
+  return requiredRemoteRoute(client, "/v1/projects/:id/task-list/rollback", () => client.transport.post(`/projects/${encodeURIComponent(projectId)}/task-list/rollback`, input), ["PROJECT_NOT_FOUND", "PROJECT_TASK_LIST_RECEIPT_NOT_FOUND"]);
+}
 async function cloudListPlans(client, projectId) {
   const query = projectId ? { project_id: projectId } : {};
   const res = await requiredRemoteRoute(client, "/v1/plans", () => client.list("plans", { query }));
@@ -13716,6 +13729,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);
@@ -19673,6 +19720,23 @@ function normalizeAgentNameInput(name) {
 import { readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join8 } from "path";
+function describeAssigneeFilter(input, ctx) {
+  const raw = input.trim();
+  const normalized = normalizeAgentNameInput(raw);
+  if (!normalized)
+    return { kind: "ok" };
+  if (ctx.agents.some((a) => a.id.toLowerCase() === normalized))
+    return { kind: "ok" };
+  const byName = ctx.agents.filter((a) => normalizeAgentNameInput(a.name) === normalized);
+  if (byName.length <= 1)
+    return { kind: "ok" };
+  const ids = byName.map((a) => a.id).sort();
+  return {
+    kind: "ambiguous",
+    candidates: byName,
+    message: `'${raw}' names ${byName.length} registered agents (${ids.join(", ")}), so this result is INCOMPLETE \u2014 ` + `rows whose assignee was stored as one of the other ids are missing from it. ` + `Re-run with an agent ID instead to get that agent's full queue.`
+  };
+}
 function defaultSeatRosterPath() {
   return process.env["TODOS_SEAT_ROSTER_PATH"] || join8(homedir3(), ".hasna", "identities", "hasna-seats.roster.json");
 }
@@ -21337,6 +21401,7 @@ function registerTaskCommands(program2) {
     }
     if (assignedFilter !== undefined)
       filter["assigned_to"] = assignedFilter;
+    const rosterPromise = assignedWasTyped && assignedFilter ? loadAssigneeContext(() => cloud ? cloudListAgents(cloud) : listAgents(), true).catch(() => ({ agents: [], seats: new Set, allowSeat: true, degraded: true })) : undefined;
     if (opts.recurring)
       filter["has_recurrence"] = true;
     if (opts.limit !== undefined) {
@@ -21407,15 +21472,22 @@ function registerTaskCommands(program2) {
     }
     if (withholdLimit && requestedLimit !== undefined)
       tasks = tasks.slice(0, requestedLimit);
-    if (assignedWasTyped && assignedFilter && tasks.length === 0) {
+    if (rosterPromise && assignedFilter) {
       try {
-        const roster = await loadAssigneeContext(() => cloud ? cloudListAgents(cloud) : listAgents(), true);
+        const roster = await rosterPromise;
         if (!roster.degraded) {
-          const target = canonicalAgentRef(assignedFilter);
-          const known = roster.agents.some((a) => canonicalAgentRef(a.name) === target || canonicalAgentRef(a.id) === target);
-          if (!known) {
-            console.error(chalk3.yellow(`Warning: no agent named '${assignedFilter}' is registered, so this empty result may be a
+          if (tasks.length === 0) {
+            const target = canonicalAgentRef(assignedFilter);
+            const known = roster.agents.some((a) => canonicalAgentRef(a.name) === target || canonicalAgentRef(a.id) === target);
+            if (!known) {
+              console.error(chalk3.yellow(`Warning: no agent named '${assignedFilter}' is registered, so this empty result may be a
 ` + `         mistyped name rather than an empty queue. Check with 'todos agents'.`));
+            }
+          } else {
+            const notice = describeAssigneeFilter(assignedFilter, { agents: roster.agents });
+            if (notice.kind === "ambiguous") {
+              console.error(chalk3.yellow(`Warning: ${notice.message}`));
+            }
           }
         }
       } catch {}
@@ -22333,6 +22405,7 @@ var init_task_commands = __esm(() => {
   init_claim_guard();
   init_assignee_guard();
   init_assignee_context();
+  init_assignee_validation();
   init_agents();
   init_helpers();
   init_output_redaction();
@@ -25036,267 +25109,1365 @@ var init_sync = __esm(() => {
   init_config();
 });
 
-// src/lib/project-bootstrap.ts
-var exports_project_bootstrap = {};
-__export(exports_project_bootstrap, {
-  discoverProjectWorkspace: () => discoverProjectWorkspace,
-  bootstrapProject: () => bootstrapProject
-});
-import { existsSync as existsSync13, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { basename as basename4, dirname as dirname6, resolve as resolve11 } from "path";
-function safeStat(path) {
-  try {
-    return statSync4(path);
-  } catch {
-    return null;
-  }
-}
-function canonicalPath(input) {
-  const resolved = resolve11(input);
-  const stats = safeStat(resolved);
-  if (stats?.isFile())
-    return dirname6(resolved);
-  return resolved;
-}
-function findUp(start, marker) {
-  let current = canonicalPath(start);
-  while (true) {
-    if (existsSync13(resolve11(current, marker)))
-      return current;
-    const parent = dirname6(current);
-    if (parent === current)
-      return null;
-    current = parent;
-  }
+// src/lib/integrity.ts
+function resolveIntegritySeverity(spec, measurement) {
+  if (spec.kind === "dangling")
+    return "error";
+  if (spec.escalate_when_open && (measurement.open_count ?? 0) > 0)
+    return "error";
+  return spec.base_severity;
 }
-function readPackageJson(path) {
-  if (!path)
-    return null;
-  const file = resolve11(path, "package.json");
-  if (!existsSync13(file))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync7(file, "utf-8"));
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
+function plural(entity, count) {
+  const [one, many] = ENTITY_LABEL[entity];
+  return count === 1 ? one : many;
 }
-function packageDisplayName(name, fallbackPath) {
-  if (!name)
-    return basename4(fallbackPath);
-  const withoutScope = name.startsWith("@") ? name.split("/")[1] : name;
-  return withoutScope || basename4(fallbackPath);
+function formatIntegrityMessage(spec, measurement) {
+  const noun = plural(spec.entity, measurement.count);
+  const verb = measurement.count === 1 ? ["has", "references"] : ["have", "reference"];
+  const open = measurement.open_count === null || measurement.open_count === 0 ? "" : ` (${measurement.open_count} still open)`;
+  return spec.kind === "missing" ? `${measurement.count} ${noun} ${verb[0]} no ${spec.field}${open}` : `${measurement.count} ${noun} ${verb[1]} a ${spec.target.replace("_", " ")} that is not registered${open}`;
 }
-function workspaceMarker(root, rootPackage) {
-  if (!root)
-    return { kind: null, markers: [] };
-  const markers = [];
-  if (rootPackage?.workspaces)
-    markers.push("package.json#workspaces");
-  for (const marker of ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json", "rush.json", "bun.lock", "bun.lockb"]) {
-    if (existsSync13(resolve11(root, marker)))
-      markers.push(marker);
-  }
-  const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
-  return { kind, markers };
+function measuredCondition(spec, measurement, source) {
+  return {
+    id: spec.id,
+    entity: spec.entity,
+    field: spec.field,
+    kind: spec.kind,
+    count: measurement.count,
+    open_count: measurement.open_count,
+    severity: measurement.count > 0 ? resolveIntegritySeverity(spec, measurement) : null,
+    verified: true,
+    source,
+    message: formatIntegrityMessage(spec, measurement),
+    impact: spec.impact
+  };
 }
-function discoverProjectWorkspace(inputPath = process.cwd()) {
-  const input = canonicalPath(inputPath);
-  const gitRoot = findUp(input, ".git");
-  const packageRoot = findUp(input, "package.json");
-  const rootPackage = readPackageJson(gitRoot);
-  const packageMeta = readPackageJson(packageRoot);
-  const workspace = workspaceMarker(gitRoot, rootPackage);
-  const monorepo = Boolean(gitRoot && packageRoot && packageRoot !== gitRoot && workspace.kind);
-  const projectPath = monorepo ? packageRoot : gitRoot ?? packageRoot ?? input;
-  const projectName = packageDisplayName(packageMeta?.name ?? rootPackage?.name ?? null, projectPath);
+function unverifiedCondition(spec, reason) {
   return {
-    inputPath: input,
-    projectPath,
-    projectName,
-    gitRoot,
-    packageRoot,
-    packageName: packageMeta?.name ?? null,
-    workspaceRoot: workspace.kind ? gitRoot : null,
-    workspaceKind: workspace.kind,
-    monorepo,
-    markers: workspace.markers
+    id: spec.id,
+    entity: spec.entity,
+    field: spec.field,
+    kind: spec.kind,
+    count: null,
+    open_count: null,
+    severity: null,
+    verified: false,
+    source: "unverified",
+    unverified_reason: reason,
+    message: `${spec.id}: NOT CHECKED \u2014 ${reason}`,
+    impact: spec.impact
   };
 }
-function sourceExists(projectId, type, uri, db) {
-  return listProjectSources(projectId, db).some((source) => source.type === type && source.uri === uri);
+function summarizeIntegrity(conditions) {
+  const measured = conditions.filter((condition) => condition.verified && condition.count !== null);
+  const findings = measured.filter((condition) => (condition.count ?? 0) > 0);
+  const unverified = conditions.length - measured.length;
+  return {
+    ok: unverified === 0 && findings.length === 0,
+    findings: findings.length,
+    rows: findings.reduce((total, condition) => total + (condition.count ?? 0), 0),
+    errors: findings.filter((condition) => condition.severity === "error").length,
+    warnings: findings.filter((condition) => condition.severity === "warn").length,
+    unverified,
+    complete: unverified === 0
+  };
 }
-function addSourceOnce(projectId, type, name, uri, metadata, db) {
-  if (!uri || sourceExists(projectId, type, uri, db))
-    return null;
-  return addProjectSource({ project_id: projectId, type, name, uri, metadata }, db);
+function buildIntegrityReport(conditions, generatedAt) {
+  const measuredSources = [...new Set(conditions.map((condition) => condition.source))].filter((source) => source !== "unverified");
+  return {
+    schema_version: TODOS_INTEGRITY_SCHEMA_VERSION,
+    generated_at: generatedAt,
+    source: measuredSources.length === 0 ? "unverified" : measuredSources.length === 1 ? measuredSources[0] : "remote-derived",
+    conditions,
+    summary: summarizeIntegrity(conditions)
+  };
 }
-function bootstrapProject(options = {}, db) {
-  const d = db || getDatabase();
-  const discovery = discoverProjectWorkspace(options.path);
-  const taskListSlug = options.taskListSlug || `todos-${slugify(options.name || discovery.projectName)}`;
-  if (options.dryRun) {
-    return {
-      dryRun: true,
-      discovery: { ...discovery, projectName: options.name || discovery.projectName },
-      project: null,
-      taskList: null,
-      sources: [],
-      created: { project: false, taskList: false, sources: [] }
-    };
-  }
-  const beforeProject = getProjectByCanonicalPath(discovery.projectPath, d);
-  let project = ensureProject(options.name || discovery.projectName, discovery.projectPath, d);
-  const createdProject = !beforeProject;
-  if (project.task_list_id !== taskListSlug || options.name && project.name !== options.name) {
-    project = renameProject(project.id, {
-      name: options.name ?? project.name,
-      new_slug: taskListSlug
-    }, d).project;
-  }
-  setMachineLocalPath(project.id, discovery.projectPath, d);
-  const beforeTaskList = d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ?").get(project.id, taskListSlug);
-  let taskList = ensureTaskList(`${project.name} Tasks`, taskListSlug, project.id, d);
-  if (options.routeEnabled && taskList.metadata.route_enabled !== true) {
-    taskList = updateTaskList(taskList.id, {
-      metadata: {
-        ...taskList.metadata,
-        route_enabled: true,
-        automation: {
-          ...taskList.metadata.automation && typeof taskList.metadata.automation === "object" && !Array.isArray(taskList.metadata.automation) ? taskList.metadata.automation : {},
-          no_auto: false
-        }
-      }
-    }, d);
-  }
-  const createdSources = [];
-  for (const source of [
-    addSourceOnce(project.id, "local", "Project root", discovery.projectPath, { role: "project-root" }, d),
-    addSourceOnce(project.id, "git", "Git root", discovery.gitRoot, { role: "git-root" }, d),
-    addSourceOnce(project.id, "workspace", "Workspace root", discovery.workspaceRoot, {
-      role: "workspace-root",
-      kind: discovery.workspaceKind,
-      markers: discovery.markers,
-      monorepo: discovery.monorepo
-    }, d)
-  ]) {
-    if (source) {
-      createdSources.push(source.type);
+function adoptRemoteIntegrityReport(raw, fallbackGeneratedAt) {
+  const received = new Map;
+  if (Array.isArray(raw.conditions)) {
+    for (const entry of raw.conditions) {
+      if (entry && typeof entry["id"] === "string")
+        received.set(entry["id"], entry);
     }
   }
-  return {
-    dryRun: false,
-    discovery: { ...discovery, projectName: options.name || discovery.projectName },
-    project,
-    taskList,
-    sources: listProjectSources(project.id, d),
-    created: {
-      project: createdProject,
-      taskList: !beforeTaskList,
-      sources: createdSources
+  const conditions = INTEGRITY_CONDITIONS.map((spec) => {
+    const entry = received.get(spec.id);
+    const count = entry?.["count"];
+    const verified = entry?.["verified"];
+    if (!entry || verified === false || typeof count !== "number" || !Number.isFinite(count)) {
+      return unverifiedCondition(spec, entry ? typeof entry["unverified_reason"] === "string" ? String(entry["unverified_reason"]) : "authority reported this condition without a usable count" : "authority did not report this condition");
     }
-  };
+    const openRaw = entry["open_count"];
+    return measuredCondition(spec, {
+      count,
+      open_count: spec.entity === "task" ? typeof openRaw === "number" && Number.isFinite(openRaw) ? openRaw : 0 : null
+    }, typeof raw.source === "string" && raw.source === "postgres" ? "postgres" : "remote-authority");
+  });
+  const report = buildIntegrityReport(conditions, typeof raw.generated_at === "string" ? raw.generated_at : fallbackGeneratedAt);
+  return typeof raw.source === "string" && (raw.source === "sqlite" || raw.source === "postgres") ? { ...report, source: raw.source } : report;
 }
-function getProjectByCanonicalPath(path, db) {
-  return getProjectByExactPath(path, db) ?? null;
+function sqliteOpenStatusList() {
+  return OPEN_TASK_STATUSES.map((status) => `'${status}'`).join(", ");
 }
-function getProjectByExactPath(path, db) {
-  return getProjectByPathForBootstrap(path, db);
+function buildSqliteIntegritySql(spec) {
+  const table = SQLITE_TABLE[spec.entity];
+  const target = SQLITE_TABLE[spec.target];
+  const column = `t."${spec.field}"`;
+  const predicate = spec.kind === "missing" ? `(${column} IS NULL OR ${column} = '')` : `${column} IS NOT NULL AND ${column} <> '' ` + `AND NOT EXISTS (SELECT 1 FROM "${target}" r WHERE r."id" = ${column})`;
+  const openExpr = spec.entity === "task" ? `SUM(CASE WHEN t."status" IN (${sqliteOpenStatusList()}) THEN 1 ELSE 0 END)` : "NULL";
+  return `SELECT COUNT(*) AS count, ${openExpr} AS open_count FROM "${table}" t WHERE ${predicate}`;
 }
-function getProjectByPathForBootstrap(path, db) {
-  const row = db.query("SELECT * FROM projects WHERE path = ?").get(path);
-  if (row)
-    return row;
-  const machineRow = db.query(`SELECT p.* FROM projects p
-     JOIN project_machine_paths pmp ON pmp.project_id = p.id
-     WHERE pmp.path = ?`).get(path);
-  return machineRow ?? null;
+function buildPostgresIntegritySql(spec, options) {
+  const params = [options.service, RECORD_TYPE[spec.entity]];
+  const p = (value) => {
+    params.push(value);
+    return `$${params.length}`;
+  };
+  const column = `t.payload->>'${spec.field}'`;
+  const predicate = spec.kind === "missing" ? `(${column} IS NULL OR ${column} = '')` : `${column} IS NOT NULL AND ${column} <> '' AND NOT EXISTS (` + `SELECT 1 FROM ${options.table} r WHERE r.service = $1 AND r.object_type = ${p(RECORD_TYPE[spec.target])} ` + `AND r.deleted_at IS NULL AND r.object_id = ${column})`;
+  const openExpr = spec.entity === "task" ? `COUNT(*) FILTER (WHERE t.payload->>'status' IN (${OPEN_TASK_STATUSES.map((status) => p(status)).join(", ")}))::int` : "NULL::int";
+  const sql = `/* todos:integrity-${spec.id} */ SELECT COUNT(*)::int AS count, ${openExpr} AS open_count ` + `FROM ${options.table} t WHERE t.service = $1 AND t.object_type = $2 AND t.deleted_at IS NULL AND ${predicate}`;
+  return { sql, params };
 }
-var init_project_bootstrap = __esm(() => {
-  init_database();
-  init_projects();
-  init_task_lists();
-});
-
-// src/lib/project-panel.ts
-var exports_project_panel = {};
-__export(exports_project_panel, {
-  createTodosProjectPanel: () => createTodosProjectPanel
-});
-import {
-  parseContract,
-  SCHEMA_IDS
-} from "@hasna/contracts";
-function clampLimit(limit) {
-  if (!Number.isFinite(limit ?? 0))
-    return 20;
-  return Math.max(1, Math.min(100, Math.trunc(limit ?? 20)));
+function referenceOf(row, field) {
+  const raw = row[field];
+  if (typeof raw !== "string")
+    return null;
+  const trimmed = raw.trim();
+  return trimmed === "" ? null : trimmed;
 }
-function taskUri(id) {
-  return `todo://tasks/${id}`;
+function measureIntegrityRows(spec, sets) {
+  const rows = spec.entity === "task" ? sets.tasks : sets.taskLists;
+  if (!rows)
+    return null;
+  const registered = spec.kind === "dangling" ? spec.target === "project" ? sets.projectIds : sets.taskListIds : undefined;
+  if (spec.kind === "dangling" && !registered)
+    return null;
+  let count = 0;
+  let open = 0;
+  for (const row of rows) {
+    const reference = referenceOf(row, spec.field);
+    const matches = spec.kind === "missing" ? reference === null : reference !== null && !registered.has(reference);
+    if (!matches)
+      continue;
+    count++;
+    if (spec.entity === "task") {
+      const status = row.status;
+      if (typeof status === "string" && OPEN_TASK_STATUSES.includes(status))
+        open++;
+    }
+  }
+  return { count, open_count: spec.entity === "task" ? open : null };
 }
-function taskResource(task) {
-  return {
-    kind: "task",
-    id: task.id,
-    name: task.title,
-    uri: taskUri(task.id),
-    externalId: task.id,
-    sourcePackage: SOURCE_PACKAGE,
-    tags: task.tags
+var TODOS_INTEGRITY_SCHEMA_VERSION = "todos.integrity.v1", TERMINAL_TASK_STATUSES, OPEN_TASK_STATUSES, INTEGRITY_CONDITIONS, ENTITY_LABEL, SQLITE_TABLE, RECORD_TYPE;
+var init_integrity = __esm(() => {
+  init_types();
+  TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled"];
+  OPEN_TASK_STATUSES = TASK_STATUSES.filter((status) => !TERMINAL_TASK_STATUSES.includes(status));
+  INTEGRITY_CONDITIONS = [
+    {
+      id: "tasks_without_project",
+      entity: "task",
+      field: "project_id",
+      target: "project",
+      kind: "missing",
+      base_severity: "warn",
+      escalate_when_open: true,
+      impact: "invisible to every project-scoped read (list, status, next, claim)"
+    },
+    {
+      id: "tasks_without_task_list",
+      entity: "task",
+      field: "task_list_id",
+      target: "task_list",
+      kind: "missing",
+      base_severity: "warn",
+      escalate_when_open: true,
+      impact: "invisible to every task-list read \u2014 the list reports zero open work"
+    },
+    {
+      id: "tasks_with_unregistered_project",
+      entity: "task",
+      field: "project_id",
+      target: "project",
+      kind: "dangling",
+      base_severity: "error",
+      escalate_when_open: false,
+      impact: "points at a project id that does not exist; the reference can never resolve"
+    },
+    {
+      id: "tasks_with_unregistered_task_list",
+      entity: "task",
+      field: "task_list_id",
+      target: "task_list",
+      kind: "dangling",
+      base_severity: "error",
+      escalate_when_open: false,
+      impact: "points at a task-list id that does not exist; the reference can never resolve"
+    },
+    {
+      id: "task_lists_without_project",
+      entity: "task_list",
+      field: "project_id",
+      target: "project",
+      kind: "missing",
+      base_severity: "warn",
+      escalate_when_open: false,
+      impact: "unbound list \u2014 unreachable from any project, so its tasks are unroutable"
+    },
+    {
+      id: "task_lists_with_unregistered_project",
+      entity: "task_list",
+      field: "project_id",
+      target: "project",
+      kind: "dangling",
+      base_severity: "error",
+      escalate_when_open: false,
+      impact: "points at a project id that does not exist; the list can never be reached"
+    }
+  ];
+  ENTITY_LABEL = {
+    task: ["task", "tasks"],
+    task_list: ["task list", "task lists"]
   };
-}
-function planResource(id, name) {
-  return {
-    kind: "workflow",
-    id,
-    name: name ?? undefined,
-    externalId: id,
-    sourcePackage: SOURCE_PACKAGE
+  SQLITE_TABLE = {
+    task: "tasks",
+    task_list: "task_lists",
+    project: "projects"
   };
-}
-function projectResource(project) {
-  const projectSlug = projectSlugForPanel(project);
-  return {
-    kind: "project",
-    id: projectSlug,
-    name: project.name,
-    uri: `project://${projectSlug}`,
-    externalId: project.id,
-    sourcePackage: SOURCE_PACKAGE
+  RECORD_TYPE = {
+    task: "tasks",
+    task_list: "task_lists",
+    project: "projects"
   };
+});
+
+// src/db/integrity.ts
+function tableExists(db, table) {
+  return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
-function projectSlugForPanel(project) {
-  const taskListSlug = project.task_list_id?.replace(/^todos-/, "");
-  return taskListSlug && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(taskListSlug) ? taskListSlug : slugify(project.name) || project.id.toLowerCase();
+function scanSqliteIntegrity(db = getDatabase()) {
+  const missing = Object.keys(REQUIRED_TABLES).filter((table) => !tableExists(db, table));
+  const conditions = INTEGRITY_CONDITIONS.map((spec) => {
+    if (missing.length > 0) {
+      return unverifiedCondition(spec, `local schema is missing table(s): ${missing.join(", ")}`);
+    }
+    try {
+      const row = db.query(buildSqliteIntegritySql(spec)).get();
+      return measuredCondition(spec, { count: Number(row?.count ?? 0), open_count: spec.entity === "task" ? Number(row?.open_count ?? 0) : null }, "sqlite");
+    } catch (error) {
+      return unverifiedCondition(spec, error instanceof Error ? error.message : String(error));
+    }
+  });
+  return buildIntegrityReport(conditions, now());
 }
-function countByStatus(tasks) {
+var REQUIRED_TABLES;
+var init_integrity2 = __esm(() => {
+  init_database();
+  init_integrity();
+  REQUIRED_TABLES = { tasks: true, task_lists: true, projects: true };
+});
+
+// src/storage/sqlite-snapshot.ts
+function exportSqliteTodosStorageSnapshot(db) {
+  const d = db ?? getDatabase();
   return {
-    pending: tasks.filter((task) => task.status === "pending").length,
-    in_progress: tasks.filter((task) => task.status === "in_progress").length,
-    completed: tasks.filter((task) => task.status === "completed").length,
-    failed: tasks.filter((task) => task.status === "failed").length,
-    cancelled: tasks.filter((task) => task.status === "cancelled").length
+    exportedAt: new Date().toISOString(),
+    source: "sqlite",
+    tasks: listTasks({ include_archived: true }, d),
+    projects: listProjects(d),
+    projectMachinePaths: listProjectMachinePaths(d),
+    plans: listPlans(undefined, d),
+    agents: listAgents({ include_archived: true }, d),
+    taskLists: listTaskLists(undefined, d),
+    templates: listTemplates(d),
+    templateTasks: listTemplates(d).flatMap((template) => getTemplateTasks(template.id, d)),
+    auditHistory: getRecentActivity(Number.MAX_SAFE_INTEGER, d),
+    tombstones: listStorageTombstones(d)
   };
 }
-function countByPriority(tasks) {
-  return {
-    critical: tasks.filter((task) => task.priority === "critical").length,
-    high: tasks.filter((task) => task.priority === "high").length,
-    medium: tasks.filter((task) => task.priority === "medium").length,
-    low: tasks.filter((task) => task.priority === "low").length
+function importSqliteTodosStorageSnapshot(snapshot, db) {
+  const d = db ?? getDatabase();
+  const result = {
+    inserted: 0,
+    updated: 0,
+    deleted: 0,
+    skipped: 0,
+    errors: []
   };
-}
-function isOverdue(task, generatedAt) {
-  if (!task.due_at || TERMINAL_STATUSES.has(task.status))
-    return false;
-  const due = Date.parse(task.due_at);
-  return Number.isFinite(due) && due < Date.parse(generatedAt);
-}
-function taskSummary(task, blockers) {
-  if (blockers.length > 0) {
-    return `Blocked by ${blockers.map((blocker) => blocker.id.slice(0, 8)).join(", ")}`;
+  result.errors.push(...validateSnapshotRoutingRecords(snapshot.projects, snapshot.taskLists));
+  if (result.errors.length === 0) {
+    const existingProjects = d.query("SELECT id, task_list_id FROM projects").all();
+    const existingTaskLists = d.query("SELECT id, project_id, slug FROM task_lists").all();
+    result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
+  }
+  if (result.errors.length > 0)
+    return result;
+  const applyRows = (objectType, table, columns, rows, updateClockColumn, afterUpsert) => {
+    for (const row of rows) {
+      try {
+        const record = asRecord(row);
+        const tombstone = typeof record["id"] === "string" ? getStorageTombstone(objectType, record["id"], d) : null;
+        if (tombstone && shouldApplyStorageTombstone(tombstone, rowClock(record, updateClockColumn))) {
+          result.skipped += 1;
+          continue;
+        }
+        const state = upsertById(d, table, columns, record, updateClockColumn);
+        if (state === "inserted")
+          result.inserted += 1;
+        else if (state === "updated")
+          result.updated += 1;
+        else
+          result.skipped += 1;
+        afterUpsert?.(record, state !== "skipped");
+      } catch (error) {
+        result.errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+  };
+  applyRows("projects", "projects", PROJECT_COLUMNS, snapshot.projects, "updated_at");
+  applyRows("project_machine_paths", "project_machine_paths", PROJECT_MACHINE_PATH_COLUMNS, snapshot.projectMachinePaths ?? [], "updated_at");
+  applyRows("agents", "agents", AGENT_COLUMNS, snapshot.agents, "last_seen_at");
+  applyRows("task_lists", "task_lists", TASK_LIST_COLUMNS, snapshot.taskLists, "updated_at");
+  applyRows("plans", "plans", PLAN_COLUMNS, snapshot.plans, "updated_at");
+  applyRows("templates", "task_templates", TEMPLATE_COLUMNS, snapshot.templates);
+  applyRows("template_tasks", "template_tasks", TEMPLATE_TASK_COLUMNS, snapshot.templateTasks ?? []);
+  applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks(snapshot.tasks), "updated_at", (row, changed) => {
+    if (changed && Array.isArray(row["tags"]) && typeof row["id"] === "string") {
+      replaceTaskTags(row["id"], row["tags"].filter((tag) => typeof tag === "string"), d);
+    }
+  });
+  applyRows("audit_history", "task_history", AUDIT_COLUMNS, snapshot.auditHistory);
+  applyTombstones(d, snapshot.tombstones ?? [], result);
+  return result;
+}
+function upsertById(db, table, columns, row, updateClockColumn) {
+  const id = row["id"];
+  if (typeof id !== "string" || !id)
+    throw new Error(`${table} row is missing id`);
+  const presentColumns = columns.filter((column) => (column in row));
+  if (!presentColumns.includes("id"))
+    presentColumns.unshift("id");
+  const existing = existsById(db, table, id);
+  const placeholders = presentColumns.map(() => "?").join(", ");
+  const values = presentColumns.map((column) => valueForColumn(column, row[column]));
+  const updateColumns = presentColumns.filter((column) => column !== "id");
+  const updateSet = updateColumns.map((column) => column === "version" ? `version = MAX(COALESCE(${table}.version, 0), excluded.version)` : `${column} = excluded.${column}`).join(", ");
+  const clockGuard = updateClockColumn && presentColumns.includes(updateClockColumn) ? ` WHERE ${table}.${updateClockColumn} IS NULL OR ${table}.${updateClockColumn} <= excluded.${updateClockColumn}` : "";
+  const sql = updateSet ? `INSERT INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders})
+       ON CONFLICT(id) DO UPDATE SET ${updateSet}${clockGuard}` : `INSERT OR IGNORE INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders})`;
+  const changes = db.run(sql, values).changes;
+  if (changes === 0)
+    return "skipped";
+  return existing ? "updated" : "inserted";
+}
+function existsById(db, table, id) {
+  return Boolean(db.query(`SELECT id FROM ${table} WHERE id = ?`).get(id));
+}
+function valueForColumn(column, value) {
+  if (BOOLEAN_COLUMNS.has(column))
+    return value ? 1 : 0;
+  if (JSON_COLUMNS.has(column))
+    return JSON.stringify(value ?? (column === "tags" || column === "permissions" || column === "capabilities" || column === "variables" ? [] : {}));
+  return value === undefined ? null : value;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("snapshot rows must be objects");
+  }
+  return value;
+}
+function sortedTasks(tasks) {
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const seen = new Set;
+  const result = [];
+  const visit = (task) => {
+    if (seen.has(task.id))
+      return;
+    if (task.parent_id && byId.has(task.parent_id))
+      visit(byId.get(task.parent_id));
+    seen.add(task.id);
+    result.push(task);
+  };
+  for (const task of tasks)
+    visit(task);
+  return result;
+}
+function applyTombstones(db, tombstones, result) {
+  for (const tombstone of tombstones) {
+    try {
+      recordStorageTombstone({
+        object_type: tombstone.object_type,
+        object_id: tombstone.object_id,
+        deleted_at: tombstone.deleted_at,
+        source_machine_id: tombstone.source_machine_id ?? null,
+        payload: tombstone.payload ?? null,
+        version: tombstone.version ?? null
+      }, db);
+      const table = tableForTombstone(tombstone.object_type);
+      const existing = existingClock(db, table, tombstone.object_id);
+      if (!shouldApplyStorageTombstone(tombstone, existing)) {
+        result.skipped += 1;
+        continue;
+      }
+      const deletedTags = table === "tasks" ? db.run("DELETE FROM task_tags WHERE task_id = ?", [tombstone.object_id]).changes : 0;
+      const deleted = db.run(`DELETE FROM ${table} WHERE id = ?`, [tombstone.object_id]).changes;
+      if (deleted > 0 || deletedTags > 0)
+        result.deleted = (result.deleted ?? 0) + 1;
+      else
+        result.skipped += 1;
+    } catch (error) {
+      result.errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function tableForTombstone(objectType) {
+  if (objectType === "tasks")
+    return "tasks";
+  if (objectType === "projects")
+    return "projects";
+  if (objectType === "project_machine_paths")
+    return "project_machine_paths";
+  if (objectType === "plans")
+    return "plans";
+  if (objectType === "agents")
+    return "agents";
+  if (objectType === "task_lists")
+    return "task_lists";
+  if (objectType === "templates")
+    return "task_templates";
+  if (objectType === "template_tasks")
+    return "template_tasks";
+  return "task_history";
+}
+function listRows(db, table, columns) {
+  return db.query(`SELECT ${columns.join(", ")} FROM ${table} ORDER BY id`).all();
+}
+function listProjectMachinePaths(db) {
+  return listRows(db, "project_machine_paths", PROJECT_MACHINE_PATH_COLUMNS).map((row) => ({
+    id: String(row.id),
+    project_id: String(row.project_id),
+    machine_id: String(row.machine_id),
+    path: String(row.path),
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  }));
+}
+function existingClock(db, table, id) {
+  const clockColumns = clockColumnsForTable(table);
+  const row = db.query(`SELECT ${clockColumns.join(", ")} FROM ${table} WHERE id = ?`).get(id);
+  return row?.updated_at ?? row?.last_seen_at ?? row?.created_at ?? null;
+}
+function rowClock(row, updateClockColumn) {
+  const value = updateClockColumn ? row[updateClockColumn] : null;
+  return stringClock(value) ?? stringClock(row["updated_at"]) ?? stringClock(row["last_seen_at"]) ?? stringClock(row["created_at"]);
+}
+function stringClock(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function clockColumnsForTable(table) {
+  if (table === "agents")
+    return ["last_seen_at", "created_at"];
+  if (table === "task_templates")
+    return ["created_at"];
+  if (table === "task_history")
+    return ["created_at"];
+  return ["updated_at", "created_at"];
+}
+var PROJECT_COLUMNS, PROJECT_MACHINE_PATH_COLUMNS, TASK_LIST_COLUMNS, PLAN_COLUMNS, AGENT_COLUMNS, TEMPLATE_COLUMNS, TEMPLATE_TASK_COLUMNS, TASK_COLUMNS, AUDIT_COLUMNS, JSON_COLUMNS, BOOLEAN_COLUMNS;
+var init_sqlite_snapshot = __esm(() => {
+  init_database();
+  init_agents();
+  init_audit();
+  init_plans();
+  init_projects();
+  init_task_lists();
+  init_tasks();
+  init_templates();
+  init_storage_tombstones();
+  PROJECT_COLUMNS = [
+    "id",
+    "name",
+    "path",
+    "description",
+    "task_list_id",
+    "task_prefix",
+    "task_counter",
+    "created_at",
+    "updated_at",
+    "machine_id",
+    "synced_at"
+  ];
+  PROJECT_MACHINE_PATH_COLUMNS = [
+    "id",
+    "project_id",
+    "machine_id",
+    "path",
+    "created_at",
+    "updated_at"
+  ];
+  TASK_LIST_COLUMNS = [
+    "id",
+    "project_id",
+    "slug",
+    "name",
+    "description",
+    "metadata",
+    "created_at",
+    "updated_at",
+    "machine_id",
+    "synced_at"
+  ];
+  PLAN_COLUMNS = [
+    "id",
+    "project_id",
+    "task_list_id",
+    "agent_id",
+    "name",
+    "description",
+    "status",
+    "created_at",
+    "updated_at",
+    "machine_id",
+    "synced_at"
+  ];
+  AGENT_COLUMNS = [
+    "id",
+    "name",
+    "description",
+    "role",
+    "title",
+    "level",
+    "permissions",
+    "capabilities",
+    "reports_to",
+    "org_id",
+    "metadata",
+    "status",
+    "created_at",
+    "last_seen_at",
+    "session_id",
+    "working_dir",
+    "active_project_id",
+    "machine_id",
+    "synced_at"
+  ];
+  TEMPLATE_COLUMNS = [
+    "id",
+    "name",
+    "title_pattern",
+    "description",
+    "priority",
+    "tags",
+    "variables",
+    "project_id",
+    "plan_id",
+    "metadata",
+    "version",
+    "created_at",
+    "machine_id",
+    "synced_at"
+  ];
+  TEMPLATE_TASK_COLUMNS = [
+    "id",
+    "template_id",
+    "position",
+    "title_pattern",
+    "description",
+    "priority",
+    "tags",
+    "task_type",
+    "condition",
+    "include_template_id",
+    "depends_on_positions",
+    "metadata",
+    "created_at"
+  ];
+  TASK_COLUMNS = [
+    "id",
+    "short_id",
+    "project_id",
+    "parent_id",
+    "plan_id",
+    "task_list_id",
+    "title",
+    "description",
+    "status",
+    "priority",
+    "agent_id",
+    "assigned_to",
+    "session_id",
+    "working_dir",
+    "tags",
+    "metadata",
+    "version",
+    "locked_by",
+    "locked_at",
+    "created_at",
+    "updated_at",
+    "started_at",
+    "completed_at",
+    "due_at",
+    "estimated_minutes",
+    "actual_minutes",
+    "requires_approval",
+    "approved_by",
+    "approved_at",
+    "recurrence_rule",
+    "recurrence_parent_id",
+    "spawns_template_id",
+    "confidence",
+    "reason",
+    "spawned_from_session",
+    "assigned_by",
+    "assigned_from_project",
+    "task_type",
+    "cost_tokens",
+    "cost_usd",
+    "delegated_from",
+    "delegation_depth",
+    "retry_count",
+    "max_retries",
+    "retry_after",
+    "sla_minutes",
+    "runner_id",
+    "runner_started_at",
+    "runner_completed_at",
+    "current_step",
+    "total_steps",
+    "cycle_id",
+    "machine_id",
+    "synced_at",
+    "archived_at"
+  ];
+  AUDIT_COLUMNS = [
+    "id",
+    "task_id",
+    "action",
+    "field",
+    "old_value",
+    "new_value",
+    "agent_id",
+    "created_at",
+    "machine_id"
+  ];
+  JSON_COLUMNS = new Set(["tags", "metadata", "permissions", "capabilities", "variables", "depends_on_positions"]);
+  BOOLEAN_COLUMNS = new Set(["requires_approval"]);
+});
+
+// src/storage/local-sqlite.ts
+function resolveTaskRefLocal(db, ref) {
+  const raw = ref.trim().toLowerCase();
+  if (!raw)
+    return null;
+  if (TASK_UUID_RE2.test(raw))
+    return getTask(raw, db);
+  const prefixRows = db.query("SELECT id, project_id FROM tasks WHERE LOWER(id) LIKE ? ESCAPE '\\' ORDER BY project_id, id LIMIT 2").all(`${raw.replace(/[\\%_]/g, (c) => `\\${c}`)}%`);
+  if (prefixRows.length > 1) {
+    throw new TaskReferenceAmbiguousError(ref, prefixRows.map((row) => ({ task_id: row.id, project_id: row.project_id })));
+  }
+  if (prefixRows.length === 1)
+    return getTask(prefixRows[0].id, db);
+  const shortIdRows = db.query("SELECT id, project_id FROM tasks WHERE LOWER(short_id) = ? ORDER BY project_id, id LIMIT 2").all(raw);
+  if (shortIdRows.length > 1) {
+    throw new TaskReferenceAmbiguousError(ref, shortIdRows.map((row) => ({ task_id: row.id, project_id: row.project_id })));
+  }
+  if (shortIdRows.length === 1)
+    return getTask(shortIdRows[0].id, db);
+  return null;
+}
+function isSearchQuery(filter) {
+  const q = filter.query?.trim();
+  return !!q && q !== "*";
+}
+function matchesExtraFilters(task, filter) {
+  if (filter.ids && !filter.ids.includes(task.id))
+    return false;
+  if (filter.parent_id !== undefined && (task.parent_id ?? null) !== filter.parent_id)
+    return false;
+  if (filter.plan_id !== undefined && task.plan_id !== filter.plan_id)
+    return false;
+  if (filter.session_id !== undefined && task.session_id !== filter.session_id)
+    return false;
+  if (filter.has_recurrence !== undefined && Boolean(task.recurrence_rule) !== filter.has_recurrence)
+    return false;
+  if (filter.task_type !== undefined) {
+    const allowed = Array.isArray(filter.task_type) ? filter.task_type : [filter.task_type];
+    if (!allowed.includes(task.task_type ?? ""))
+      return false;
+  }
+  if (filter.tags?.length) {
+    const taskTags = new Set(task.tags ?? []);
+    if (!filter.tags.every((tag) => taskTags.has(tag)))
+      return false;
+  }
+  if (filter.include_subtasks !== true && filter.parent_id === undefined && task.parent_id)
+    return false;
+  return true;
+}
+function listTasksMaybeSearch(filter, db) {
+  if (!isSearchQuery(filter))
+    return listTasks(filter, db);
+  const matched = searchTasks({
+    query: filter.query,
+    project_id: filter.project_id,
+    task_list_id: filter.task_list_id,
+    status: filter.status,
+    priority: filter.priority,
+    assigned_to: filter.assigned_to,
+    agent_id: filter.agent_id
+  }, undefined, undefined, db).filter((task) => matchesExtraFilters(task, filter));
+  const offset = filter.offset && filter.offset > 0 ? Math.trunc(filter.offset) : 0;
+  if (filter.limit !== undefined && filter.limit >= 0)
+    return matched.slice(offset, offset + filter.limit);
+  return offset ? matched.slice(offset) : matched;
+}
+function createLocalSqliteTodosStorageAdapter(options = {}) {
+  const database = () => options.db ?? getDatabase();
+  let adapter;
+  adapter = {
+    kind: "sqlite",
+    capabilities: {
+      localPersistence: true,
+      remotePersistence: false,
+      transactions: true,
+      auditLog: true,
+      sync: true
+    },
+    tasks: {
+      create: (input, context) => createTask({
+        ...input,
+        agent_id: input.agent_id ?? context?.agentId,
+        created_by: input.created_by ?? input.agent_id ?? context?.agentId
+      }, database()),
+      get: (id) => getTask(id, database()),
+      resolveRef: (ref) => resolveTaskRefLocal(database(), ref),
+      list: (filter = {}) => listTasksMaybeSearch(filter, database()),
+      count: (filter = {}) => isSearchQuery(filter) ? listTasksMaybeSearch({ ...filter, limit: undefined, offset: undefined }, database()).length : countTasks(filter, database()),
+      update: (id, input) => updateTask(id, input, database()),
+      unlock: (id, agentId) => {
+        unlockTask(id, agentId, database());
+        return true;
+      },
+      delete: (id) => deleteTask(id, database()),
+      start: (id, agentId) => startTask(id, agentId, database()),
+      complete: (id, agentId, options2) => completeTask(id, agentId, database(), options2),
+      fail: (id, agentId, reason, options2) => failTask(id, agentId, reason, options2, database()),
+      claimNext: (agentId, filters) => claimNextTask(agentId, filters, database()),
+      getNext: (agentId, filters) => getNextTask(agentId, filters, database()),
+      getActiveWork: (filters) => getActiveWork(filters, database()),
+      getChangedSince: (since, filters) => getTasksChangedSince(since, filters, database())
+    },
+    projects: {
+      create: (input) => createProject(input, database()),
+      get: (id) => getProject(id, database()),
+      getByPath: (path) => getProjectByPath(path, database()),
+      list: () => listProjects(database()),
+      update: (id, input) => updateProject(id, input, database()),
+      rename: (id, input) => renameProject(id, input, database()),
+      delete: (id) => deleteProject(id, database())
+    },
+    plans: {
+      create: (input) => createPlan(input, database()),
+      get: (id) => getPlan(id, database()),
+      list: (projectId) => listPlans(projectId, database()),
+      update: (id, input) => updatePlan(id, input, database()),
+      delete: (id) => deletePlan(id, database())
+    },
+    agents: {
+      register: (input) => registerAgent(input, database()),
+      get: (id) => getAgent(id, database()),
+      getByName: (name) => getAgentByName(name, database()),
+      list: (options2) => listAgents(options2, database()),
+      update: (id, input) => updateAgent(id, input, database())
+    },
+    taskLists: {
+      create: (input) => createTaskList(input, database()),
+      get: (id) => getTaskList(id, database()),
+      getBySlug: (slug, projectId) => getTaskListBySlug(slug, projectId, database()),
+      list: (projectId) => listTaskLists(projectId, database()),
+      update: (id, input) => updateTaskList(id, input, database()),
+      delete: (id) => deleteTaskList(id, database()),
+      deleteIfUnchangedAndUnused: (id, expected) => deleteTaskListIfUnchangedAndUnused(id, expected, database())
+    },
+    templates: {
+      create: (input) => createTemplate(input, database()),
+      get: (id) => getTemplate(id, database()),
+      list: () => listTemplates(database()),
+      update: (id, input) => updateTemplate(id, input, database()),
+      delete: (id) => deleteTemplate(id, database()),
+      getWithTasks: (id) => getTemplateWithTasks(id, database())
+    },
+    audit: {
+      logTaskChange: (taskId, action, field, oldValue, newValue, agentId) => logTaskChange(taskId, action, field, oldValue, newValue, agentId, database()),
+      addComment: (input) => addComment(input, database()),
+      getComments: (taskId) => listComments(taskId, database()),
+      getCommentsPage: (taskId, options2) => {
+        if (options2?.limit !== undefined && (!Number.isSafeInteger(options2.limit) || options2.limit < 1 || options2.limit > 1001)) {
+          throw new Error("Comment limit must be an integer between 1 and 1001");
+        }
+        let comments = listComments(taskId, database());
+        comments = comments.sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id));
+        if (options2?.before) {
+          const before = options2.before;
+          comments = comments.filter((comment) => comment.created_at < before.created_at || comment.created_at === before.created_at && comment.id < before.id);
+        }
+        if (options2?.limit !== undefined)
+          comments = comments.slice(-options2.limit);
+        return comments;
+      },
+      getTaskHistory: (taskId) => getTaskHistory(taskId, database()),
+      getRecentActivity: (limit) => getRecentActivity(limit, database())
+    },
+    sync: {
+      getTasksChangedSince: (since, filters) => getTasksChangedSince(since, filters, database()),
+      exportSnapshot: () => exportSqliteTodosStorageSnapshot(database()),
+      importSnapshot: (snapshot) => importSqliteTodosStorageSnapshot(snapshot, database())
+    },
+    integrity: {
+      report: () => scanSqliteIntegrity(database())
+    },
+    transaction: (fn) => {
+      const tx = database().transaction(() => fn(adapter));
+      return tx();
+    }
+  };
+  return adapter;
+}
+var TASK_UUID_RE2;
+var init_local_sqlite = __esm(() => {
+  init_types();
+  init_search();
+  init_tasks();
+  init_projects();
+  init_plans();
+  init_agents();
+  init_task_lists();
+  init_templates();
+  init_audit();
+  init_comments();
+  init_database();
+  init_integrity2();
+  init_sqlite_snapshot();
+  TASK_UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+});
+
+// src/lib/project-task-list-ensure.ts
+import { createHash as createHash5 } 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 createHash5("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 receiptId(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: receiptId(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/lib/project-bootstrap.ts
+var exports_project_bootstrap = {};
+__export(exports_project_bootstrap, {
+  discoverProjectWorkspace: () => discoverProjectWorkspace,
+  bootstrapProject: () => bootstrapProject
+});
+import { existsSync as existsSync13, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { basename as basename4, dirname as dirname6, resolve as resolve11 } from "path";
+function safeStat(path) {
+  try {
+    return statSync4(path);
+  } catch {
+    return null;
+  }
+}
+function canonicalPath(input) {
+  const resolved = resolve11(input);
+  const stats = safeStat(resolved);
+  if (stats?.isFile())
+    return dirname6(resolved);
+  return resolved;
+}
+function findUp(start, marker) {
+  let current = canonicalPath(start);
+  while (true) {
+    if (existsSync13(resolve11(current, marker)))
+      return current;
+    const parent = dirname6(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function readPackageJson(path) {
+  if (!path)
+    return null;
+  const file = resolve11(path, "package.json");
+  if (!existsSync13(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync7(file, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function packageDisplayName(name, fallbackPath) {
+  if (!name)
+    return basename4(fallbackPath);
+  const withoutScope = name.startsWith("@") ? name.split("/")[1] : name;
+  return withoutScope || basename4(fallbackPath);
+}
+function workspaceMarker(root, rootPackage) {
+  if (!root)
+    return { kind: null, markers: [] };
+  const markers = [];
+  if (rootPackage?.workspaces)
+    markers.push("package.json#workspaces");
+  for (const marker of ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json", "rush.json", "bun.lock", "bun.lockb"]) {
+    if (existsSync13(resolve11(root, marker)))
+      markers.push(marker);
+  }
+  const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
+  return { kind, markers };
+}
+function discoverProjectWorkspace(inputPath = process.cwd()) {
+  const input = canonicalPath(inputPath);
+  const gitRoot = findUp(input, ".git");
+  const packageRoot = findUp(input, "package.json");
+  const rootPackage = readPackageJson(gitRoot);
+  const packageMeta = readPackageJson(packageRoot);
+  const workspace = workspaceMarker(gitRoot, rootPackage);
+  const monorepo = Boolean(gitRoot && packageRoot && packageRoot !== gitRoot && workspace.kind);
+  const projectPath = monorepo ? packageRoot : gitRoot ?? packageRoot ?? input;
+  const projectName = packageDisplayName(packageMeta?.name ?? rootPackage?.name ?? null, projectPath);
+  return {
+    inputPath: input,
+    projectPath,
+    projectName,
+    gitRoot,
+    packageRoot,
+    packageName: packageMeta?.name ?? null,
+    workspaceRoot: workspace.kind ? gitRoot : null,
+    workspaceKind: workspace.kind,
+    monorepo,
+    markers: workspace.markers
+  };
+}
+function sourceExists(projectId, type, uri, db) {
+  return listProjectSources(projectId, db).some((source) => source.type === type && source.uri === uri);
+}
+function addSourceOnce(projectId, type, name, uri, metadata, db) {
+  if (!uri || sourceExists(projectId, type, uri, db))
+    return null;
+  return addProjectSource({ project_id: projectId, type, name, uri, metadata }, db);
+}
+function bootstrapProject(options = {}, db) {
+  const d = db || getDatabase();
+  const discovery = discoverProjectWorkspace(options.path);
+  const taskListSlug = options.taskListSlug || `todos-${slugify(options.name || discovery.projectName)}`;
+  if (options.dryRun) {
+    return {
+      dryRun: true,
+      discovery: { ...discovery, projectName: options.name || discovery.projectName },
+      project: null,
+      taskList: null,
+      sources: [],
+      created: { project: false, taskList: false, sources: [] }
+    };
+  }
+  const beforeProject = getProjectByCanonicalPath(discovery.projectPath, d);
+  let project = ensureProject(options.name || discovery.projectName, discovery.projectPath, d);
+  const createdProject = !beforeProject;
+  if (project.task_list_id !== taskListSlug || options.name && project.name !== options.name) {
+    project = renameProject(project.id, {
+      name: options.name ?? project.name,
+      new_slug: taskListSlug
+    }, d).project;
+  }
+  setMachineLocalPath(project.id, discovery.projectPath, d);
+  const beforeTaskList = d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ?").get(project.id, taskListSlug);
+  let taskList = ensureTaskList(`${project.name} Tasks`, taskListSlug, project.id, d);
+  if (options.routeEnabled && taskList.metadata.route_enabled !== true) {
+    taskList = updateTaskList(taskList.id, {
+      metadata: {
+        ...taskList.metadata,
+        route_enabled: true,
+        automation: {
+          ...taskList.metadata.automation && typeof taskList.metadata.automation === "object" && !Array.isArray(taskList.metadata.automation) ? taskList.metadata.automation : {},
+          no_auto: false
+        }
+      }
+    }, d);
+  }
+  const createdSources = [];
+  for (const source of [
+    addSourceOnce(project.id, "local", "Project root", discovery.projectPath, { role: "project-root" }, d),
+    addSourceOnce(project.id, "git", "Git root", discovery.gitRoot, { role: "git-root" }, d),
+    addSourceOnce(project.id, "workspace", "Workspace root", discovery.workspaceRoot, {
+      role: "workspace-root",
+      kind: discovery.workspaceKind,
+      markers: discovery.markers,
+      monorepo: discovery.monorepo
+    }, d)
+  ]) {
+    if (source) {
+      createdSources.push(source.type);
+    }
+  }
+  return {
+    dryRun: false,
+    discovery: { ...discovery, projectName: options.name || discovery.projectName },
+    project,
+    taskList,
+    sources: listProjectSources(project.id, d),
+    created: {
+      project: createdProject,
+      taskList: !beforeTaskList,
+      sources: createdSources
+    }
+  };
+}
+function getProjectByCanonicalPath(path, db) {
+  return getProjectByExactPath(path, db) ?? null;
+}
+function getProjectByExactPath(path, db) {
+  return getProjectByPathForBootstrap(path, db);
+}
+function getProjectByPathForBootstrap(path, db) {
+  const row = db.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (row)
+    return row;
+  const machineRow = db.query(`SELECT p.* FROM projects p
+     JOIN project_machine_paths pmp ON pmp.project_id = p.id
+     WHERE pmp.path = ?`).get(path);
+  return machineRow ?? null;
+}
+var init_project_bootstrap = __esm(() => {
+  init_database();
+  init_projects();
+  init_task_lists();
+});
+
+// src/lib/project-panel.ts
+var exports_project_panel = {};
+__export(exports_project_panel, {
+  createTodosProjectPanel: () => createTodosProjectPanel
+});
+import {
+  parseContract,
+  SCHEMA_IDS
+} from "@hasna/contracts";
+function clampLimit(limit) {
+  if (!Number.isFinite(limit ?? 0))
+    return 20;
+  return Math.max(1, Math.min(100, Math.trunc(limit ?? 20)));
+}
+function taskUri(id) {
+  return `todo://tasks/${id}`;
+}
+function taskResource(task) {
+  return {
+    kind: "task",
+    id: task.id,
+    name: task.title,
+    uri: taskUri(task.id),
+    externalId: task.id,
+    sourcePackage: SOURCE_PACKAGE,
+    tags: task.tags
+  };
+}
+function planResource(id, name) {
+  return {
+    kind: "workflow",
+    id,
+    name: name ?? undefined,
+    externalId: id,
+    sourcePackage: SOURCE_PACKAGE
+  };
+}
+function projectResource(project) {
+  const projectSlug = projectSlugForPanel(project);
+  return {
+    kind: "project",
+    id: projectSlug,
+    name: project.name,
+    uri: `project://${projectSlug}`,
+    externalId: project.id,
+    sourcePackage: SOURCE_PACKAGE
+  };
+}
+function projectSlugForPanel(project) {
+  const taskListSlug = project.task_list_id?.replace(/^todos-/, "");
+  return taskListSlug && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(taskListSlug) ? taskListSlug : slugify(project.name) || project.id.toLowerCase();
+}
+function countByStatus(tasks) {
+  return {
+    pending: tasks.filter((task) => task.status === "pending").length,
+    in_progress: tasks.filter((task) => task.status === "in_progress").length,
+    completed: tasks.filter((task) => task.status === "completed").length,
+    failed: tasks.filter((task) => task.status === "failed").length,
+    cancelled: tasks.filter((task) => task.status === "cancelled").length
+  };
+}
+function countByPriority(tasks) {
+  return {
+    critical: tasks.filter((task) => task.priority === "critical").length,
+    high: tasks.filter((task) => task.priority === "high").length,
+    medium: tasks.filter((task) => task.priority === "medium").length,
+    low: tasks.filter((task) => task.priority === "low").length
+  };
+}
+function isOverdue(task, generatedAt) {
+  if (!task.due_at || TERMINAL_STATUSES.has(task.status))
+    return false;
+  const due = Date.parse(task.due_at);
+  return Number.isFinite(due) && due < Date.parse(generatedAt);
+}
+function taskSummary(task, blockers) {
+  if (blockers.length > 0) {
+    return `Blocked by ${blockers.map((blocker) => blocker.id.slice(0, 8)).join(", ")}`;
   }
   const firstLine = task.description?.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
   return firstLine || undefined;
@@ -25430,10 +26601,10 @@ __export(exports_extract, {
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
 import { existsSync as existsSync14, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { relative as relative3, resolve as resolve12, join as join13 } from "path";
 function stableHash(value) {
-  return createHash5("sha256").update(value).digest("hex");
+  return createHash6("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -25974,7 +27145,7 @@ function validateLocalBridgeBundle(value) {
   }
   return { ok: issues.length === 0, issues };
 }
-function existsById(db, table, id) {
+function existsById2(db, table, id) {
   return Boolean(db.query(`SELECT id FROM ${table} WHERE id = ?`).get(id));
 }
 function dependencyExists(db, row) {
@@ -25990,7 +27161,7 @@ function plannedIdSets(data) {
   return result;
 }
 function hasExistingOrPlannedId(db, tableKey, id, plannedIds) {
-  return existsById(db, tableByKey[tableKey], id) || Boolean(plannedIds.get(tableKey)?.has(id));
+  return existsById2(db, tableByKey[tableKey], id) || Boolean(plannedIds.get(tableKey)?.has(id));
 }
 function missingDependency(db, tableKey, row, plannedIds) {
   const taskId = typeof row.task_id === "string" ? row.task_id : null;
@@ -26067,7 +27238,7 @@ function insertRecord(db, tableKey, row) {
   }
   return result.changes > 0;
 }
-function sortedTasks(tasks) {
+function sortedTasks2(tasks) {
   const byId = new Map(tasks.map((task) => [task.id, task]));
   const visited = new Set;
   const result = [];
@@ -26188,7 +27359,7 @@ function importLocalBridgeBundle(bundle, options = {}, db) {
   const data = {
     ...bundle.data,
     plans: normalizeBridgePlanSlugs(bundle.data.plans, d),
-    tasks: sortedTasks(bundle.data.tasks),
+    tasks: sortedTasks2(bundle.data.tasks),
     saved_views: bundle.data.saved_views ?? [],
     task_boards: bundle.data.task_boards ?? [],
     local_calendar_items: bundle.data.local_calendar_items ?? []
@@ -26198,7 +27369,7 @@ function importLocalBridgeBundle(bundle, options = {}, db) {
     for (const row of data[key]) {
       const table = tableByKey[key];
       const id = key === "task_dependencies" ? `${row.task_id}->${row.depends_on}` : String(row.id);
-      const exists = key === "task_dependencies" ? dependencyExists(d, row) : existsById(d, table, id);
+      const exists = key === "task_dependencies" ? dependencyExists(d, row) : existsById2(d, table, id);
       if (exists) {
         if (key === "tasks" && conflictStrategy === "safe_merge") {
           const merge = safeMergeTask(d, row, { dryRun });
@@ -26413,12 +27584,12 @@ __export(exports_local_encryption, {
   DEFAULT_ENCRYPTION_PROFILE: () => DEFAULT_ENCRYPTION_PROFILE,
   DEFAULT_ENCRYPTION_KEY_ENV: () => DEFAULT_ENCRYPTION_KEY_ENV
 });
-import { createCipheriv, createDecipheriv, createHash as createHash6, randomBytes, scryptSync, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash7, randomBytes, scryptSync, timingSafeEqual as timingSafeEqual2 } from "crypto";
 function now3() {
   return new Date().toISOString();
 }
 function sha2563(value) {
-  return createHash6("sha256").update(value).digest("hex");
+  return createHash7("sha256").update(value).digest("hex");
 }
 function normalizeProfileName(value) {
   const name = (value || DEFAULT_ENCRYPTION_PROFILE).trim();
@@ -27474,9 +28645,69 @@ function registerProjectCommands(program2) {
       }
     }
   });
-  program2.command("projects").description("List and manage projects").option("--add <path>", "Register a project by path").option("--show <project>", "Resolve and show a project").option("--update <project>", "Update a project's name, path, or description").option("--deregister <project>", "Deregister a project without deleting its tasks; refuses projects with incomplete tasks").option("--path-prefix <prefix>", "Require deregistered project path to start with this prefix").option("--dry-run", "Show what would change without modifying local state").option("--name <name>", "Project name (with --add)").option("--path <path>", "Project path (with --update)").option("--description <text>", "Project description (with --add or --update)").option("--task-list-id <id>", "Custom task list ID (with --add)").action(async (opts) => {
+  program2.command("projects").description("List and manage projects").option("--add <path>", "Register a project by path").option("--show <project>", "Resolve and show a project").option("--update <project>", "Update a project's name, path, or description").option("--deregister <project>", "Deregister a project without deleting its tasks; refuses projects with incomplete tasks").option("--path-prefix <prefix>", "Require deregistered project path to start with this prefix").option("--dry-run", "Show what would change without modifying local state").option("--name <name>", "Project name (with --add)").option("--path <path>", "Project path (with --update)").option("--description <text>", "Project description (with --add or --update)").option("--task-list-id <id>", "Custom task list ID (with --add)").option("--ensure-task-list <project>", "Plan or apply creation of an existing project's declared task list").option("--rollback-task-list <project>", "Conditionally roll back a task list created by --ensure-task-list").option("--apply", "Apply --ensure-task-list or --rollback-task-list; ensure plans by default").option("--idempotency-key <key>", "Stable idempotency key for --ensure-task-list --apply").option("--receipt <id>", "Accepted ensure receipt for --rollback-task-list --apply").action(async (opts) => {
     const globalOpts = program2.opts();
     const cloud = getTodosCloudClient();
+    if (opts.ensureTaskList && opts.rollbackTaskList) {
+      handleError(new Error("Choose either --ensure-task-list or --rollback-task-list, not both"));
+    }
+    if (opts.apply && !opts.ensureTaskList && !opts.rollbackTaskList) {
+      handleError(new Error("projects --apply requires --ensure-task-list or --rollback-task-list"));
+    }
+    if (opts.dryRun && opts.apply && (opts.ensureTaskList || opts.rollbackTaskList)) {
+      handleError(new Error("Choose either --dry-run or --apply, not both"));
+    }
+    if (opts.ensureTaskList) {
+      const project = cloud ? await cloudResolveProject(cloud, opts.ensureTaskList) : resolveExplicitProject(opts.ensureTaskList);
+      const store = cloud ? null : createLocalSqliteTodosStorageAdapter({ db: getDatabase() });
+      const plan = cloud ? await cloudPlanProjectTaskListEnsure(cloud, project.id) : await planProjectTaskListEnsure(store, project.id);
+      const result = opts.apply ? cloud ? await cloudApplyProjectTaskListEnsure(cloud, project.id, {
+        expected_project_revision: plan.project.updated_at,
+        ...opts.idempotencyKey ? { idempotency_key: opts.idempotencyKey } : {}
+      }) : await applyProjectTaskListEnsure(store, project.id, {
+        expected_project_revision: plan.project.updated_at,
+        ...opts.idempotencyKey ? { idempotency_key: opts.idempotencyKey } : {}
+      }) : plan;
+      if (globalOpts.json) {
+        output(result, true);
+      } else {
+        const list = result.task_list ? `${result.task_list.slug} (${result.task_list.id})` : result.project.task_list_id;
+        console.log(chalk5.green(`${result.mode === "plan" ? "Task-list plan" : "Task-list ensure"}: ${result.action}`));
+        console.log(chalk5.dim(`  Project: ${result.project.name} (${result.project.id})`));
+        console.log(chalk5.dim(`  Task list: ${list}`));
+        if (result.receipt)
+          console.log(chalk5.dim(`  Receipt: ${result.receipt.receipt_id}`));
+      }
+      return;
+    }
+    if (opts.rollbackTaskList) {
+      if (!opts.apply) {
+        handleError(new Error("projects --rollback-task-list requires --apply"));
+      }
+      if (!opts.receipt) {
+        handleError(new Error("projects --rollback-task-list requires --receipt"));
+      }
+      const project = cloud ? await cloudResolveProject(cloud, opts.rollbackTaskList) : resolveExplicitProject(opts.rollbackTaskList);
+      const store = cloud ? null : createLocalSqliteTodosStorageAdapter({ db: getDatabase() });
+      const plan = cloud ? await cloudPlanProjectTaskListEnsure(cloud, project.id) : await planProjectTaskListEnsure(store, project.id);
+      if (!plan.task_list) {
+        handleError(new Error("The project has no exact declared task list to roll back"));
+      }
+      const input = {
+        receipt_id: opts.receipt,
+        expected_task_list_revision: plan.task_list.updated_at
+      };
+      const result = cloud ? await cloudRollbackProjectTaskListEnsure(cloud, project.id, input) : await rollbackProjectTaskListEnsure(store, project.id, input);
+      if (globalOpts.json) {
+        output(result, true);
+      } else {
+        console.log(chalk5.green(`Task-list rollback: ${result.action}`));
+        console.log(chalk5.dim(`  Project: ${result.project_id}`));
+        console.log(chalk5.dim(`  Removed task list: ${result.task_list_id}`));
+        console.log(chalk5.dim(`  Rollback receipt: ${result.rollback_receipt_id}`));
+      }
+      return;
+    }
     if (opts.show) {
       const project = cloud ? await cloudResolveProject(cloud, opts.show) : resolveExplicitProject(opts.show);
       outputRecord(project, Boolean(globalOpts.json), "Project:");
@@ -27976,6 +29207,8 @@ var init_project_commands = __esm(() => {
   init_config();
   init_helpers();
   init_output_redaction();
+  init_local_sqlite();
+  init_project_task_list_ensure();
   SEARCH_SCOPE_FLAG = {
     name: "--scope",
     vocabulary: SAVED_SEARCH_SCOPES,
@@ -28662,12 +29895,12 @@ function unique4(values) {
 function placeholders(values) {
   return values.map(() => "?").join(", ");
 }
-function tableExists(db, table) {
+function tableExists2(db, table) {
   const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
   return Boolean(row);
 }
 function tableColumns(db, table) {
-  if (!tableExists(db, table))
+  if (!tableExists2(db, table))
     return new Set;
   const rows = db.query(`PRAGMA table_info(${table})`).all();
   return new Set(rows.map((row) => row.name));
@@ -28683,7 +29916,7 @@ function normalizeScope2(options) {
   };
 }
 function scopedCommentTaskIds(db, commentIds) {
-  if (commentIds.length === 0 || !tableExists(db, "task_comments"))
+  if (commentIds.length === 0 || !tableExists2(db, "task_comments"))
     return [];
   const rows = db.query(`SELECT DISTINCT task_id FROM task_comments WHERE id IN (${placeholders(commentIds)})`).all(...commentIds);
   return rows.map((row) => row.task_id).filter(Boolean);
@@ -29896,7 +31129,7 @@ __export(exports_local_extensions, {
   getLocalExtension: () => getLocalExtension,
   discoverLocalExtensions: () => discoverLocalExtensions
 });
-import { createHash as createHash7, createVerify } from "crypto";
+import { createHash as createHash8, createVerify } from "crypto";
 import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
 import { basename as basename6, join as join16, resolve as resolve15 } from "path";
 function isObject(value) {
@@ -29982,7 +31215,7 @@ function parseJson(path) {
   return JSON.parse(readFileSync10(path, "utf8"));
 }
 function sha2564(bytes) {
-  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash8("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -31339,7 +32572,7 @@ var init_terminal_notifications = __esm(() => {
 });
 
 // src/db/api-keys.ts
-import { createHash as createHash8, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash9, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -31353,7 +32586,7 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key) {
-  return createHash8("sha256").update(key).digest("hex");
+  return createHash9("sha256").update(key).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
@@ -31361,8 +32594,8 @@ function safeEqualHex(a, b) {
   return timingSafeEqual3(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
 }
 function safeEqualStrings(a, b) {
-  const ah = createHash8("sha256").update(a, "utf8").digest();
-  const bh = createHash8("sha256").update(b, "utf8").digest();
+  const ah = createHash9("sha256").update(a, "utf8").digest();
+  const bh = createHash9("sha256").update(b, "utf8").digest();
   return timingSafeEqual3(ah, bh);
 }
 function generatePlaintextKey() {
@@ -31889,239 +33122,6 @@ var init_postgres_sync = __esm(() => {
   };
 });
 
-// src/lib/integrity.ts
-function resolveIntegritySeverity(spec, measurement) {
-  if (spec.kind === "dangling")
-    return "error";
-  if (spec.escalate_when_open && (measurement.open_count ?? 0) > 0)
-    return "error";
-  return spec.base_severity;
-}
-function plural(entity, count) {
-  const [one, many] = ENTITY_LABEL[entity];
-  return count === 1 ? one : many;
-}
-function formatIntegrityMessage(spec, measurement) {
-  const noun = plural(spec.entity, measurement.count);
-  const verb = measurement.count === 1 ? ["has", "references"] : ["have", "reference"];
-  const open = measurement.open_count === null || measurement.open_count === 0 ? "" : ` (${measurement.open_count} still open)`;
-  return spec.kind === "missing" ? `${measurement.count} ${noun} ${verb[0]} no ${spec.field}${open}` : `${measurement.count} ${noun} ${verb[1]} a ${spec.target.replace("_", " ")} that is not registered${open}`;
-}
-function measuredCondition(spec, measurement, source2) {
-  return {
-    id: spec.id,
-    entity: spec.entity,
-    field: spec.field,
-    kind: spec.kind,
-    count: measurement.count,
-    open_count: measurement.open_count,
-    severity: measurement.count > 0 ? resolveIntegritySeverity(spec, measurement) : null,
-    verified: true,
-    source: source2,
-    message: formatIntegrityMessage(spec, measurement),
-    impact: spec.impact
-  };
-}
-function unverifiedCondition(spec, reason) {
-  return {
-    id: spec.id,
-    entity: spec.entity,
-    field: spec.field,
-    kind: spec.kind,
-    count: null,
-    open_count: null,
-    severity: null,
-    verified: false,
-    source: "unverified",
-    unverified_reason: reason,
-    message: `${spec.id}: NOT CHECKED \u2014 ${reason}`,
-    impact: spec.impact
-  };
-}
-function summarizeIntegrity(conditions) {
-  const measured = conditions.filter((condition) => condition.verified && condition.count !== null);
-  const findings = measured.filter((condition) => (condition.count ?? 0) > 0);
-  const unverified = conditions.length - measured.length;
-  return {
-    ok: unverified === 0 && findings.length === 0,
-    findings: findings.length,
-    rows: findings.reduce((total, condition) => total + (condition.count ?? 0), 0),
-    errors: findings.filter((condition) => condition.severity === "error").length,
-    warnings: findings.filter((condition) => condition.severity === "warn").length,
-    unverified,
-    complete: unverified === 0
-  };
-}
-function buildIntegrityReport(conditions, generatedAt) {
-  const measuredSources = [...new Set(conditions.map((condition) => condition.source))].filter((source2) => source2 !== "unverified");
-  return {
-    schema_version: TODOS_INTEGRITY_SCHEMA_VERSION,
-    generated_at: generatedAt,
-    source: measuredSources.length === 0 ? "unverified" : measuredSources.length === 1 ? measuredSources[0] : "remote-derived",
-    conditions,
-    summary: summarizeIntegrity(conditions)
-  };
-}
-function adoptRemoteIntegrityReport(raw, fallbackGeneratedAt) {
-  const received = new Map;
-  if (Array.isArray(raw.conditions)) {
-    for (const entry2 of raw.conditions) {
-      if (entry2 && typeof entry2["id"] === "string")
-        received.set(entry2["id"], entry2);
-    }
-  }
-  const conditions = INTEGRITY_CONDITIONS.map((spec) => {
-    const entry2 = received.get(spec.id);
-    const count = entry2?.["count"];
-    const verified = entry2?.["verified"];
-    if (!entry2 || verified === false || typeof count !== "number" || !Number.isFinite(count)) {
-      return unverifiedCondition(spec, entry2 ? typeof entry2["unverified_reason"] === "string" ? String(entry2["unverified_reason"]) : "authority reported this condition without a usable count" : "authority did not report this condition");
-    }
-    const openRaw = entry2["open_count"];
-    return measuredCondition(spec, {
-      count,
-      open_count: spec.entity === "task" ? typeof openRaw === "number" && Number.isFinite(openRaw) ? openRaw : 0 : null
-    }, typeof raw.source === "string" && raw.source === "postgres" ? "postgres" : "remote-authority");
-  });
-  const report = buildIntegrityReport(conditions, typeof raw.generated_at === "string" ? raw.generated_at : fallbackGeneratedAt);
-  return typeof raw.source === "string" && (raw.source === "sqlite" || raw.source === "postgres") ? { ...report, source: raw.source } : report;
-}
-function sqliteOpenStatusList() {
-  return OPEN_TASK_STATUSES.map((status) => `'${status}'`).join(", ");
-}
-function buildSqliteIntegritySql(spec) {
-  const table = SQLITE_TABLE[spec.entity];
-  const target = SQLITE_TABLE[spec.target];
-  const column = `t."${spec.field}"`;
-  const predicate = spec.kind === "missing" ? `(${column} IS NULL OR ${column} = '')` : `${column} IS NOT NULL AND ${column} <> '' ` + `AND NOT EXISTS (SELECT 1 FROM "${target}" r WHERE r."id" = ${column})`;
-  const openExpr = spec.entity === "task" ? `SUM(CASE WHEN t."status" IN (${sqliteOpenStatusList()}) THEN 1 ELSE 0 END)` : "NULL";
-  return `SELECT COUNT(*) AS count, ${openExpr} AS open_count FROM "${table}" t WHERE ${predicate}`;
-}
-function buildPostgresIntegritySql(spec, options) {
-  const params = [options.service, RECORD_TYPE[spec.entity]];
-  const p = (value) => {
-    params.push(value);
-    return `$${params.length}`;
-  };
-  const column = `t.payload->>'${spec.field}'`;
-  const predicate = spec.kind === "missing" ? `(${column} IS NULL OR ${column} = '')` : `${column} IS NOT NULL AND ${column} <> '' AND NOT EXISTS (` + `SELECT 1 FROM ${options.table} r WHERE r.service = $1 AND r.object_type = ${p(RECORD_TYPE[spec.target])} ` + `AND r.deleted_at IS NULL AND r.object_id = ${column})`;
-  const openExpr = spec.entity === "task" ? `COUNT(*) FILTER (WHERE t.payload->>'status' IN (${OPEN_TASK_STATUSES.map((status) => p(status)).join(", ")}))::int` : "NULL::int";
-  const sql = `/* todos:integrity-${spec.id} */ SELECT COUNT(*)::int AS count, ${openExpr} AS open_count ` + `FROM ${options.table} t WHERE t.service = $1 AND t.object_type = $2 AND t.deleted_at IS NULL AND ${predicate}`;
-  return { sql, params };
-}
-function referenceOf(row, field) {
-  const raw = row[field];
-  if (typeof raw !== "string")
-    return null;
-  const trimmed = raw.trim();
-  return trimmed === "" ? null : trimmed;
-}
-function measureIntegrityRows(spec, sets) {
-  const rows = spec.entity === "task" ? sets.tasks : sets.taskLists;
-  if (!rows)
-    return null;
-  const registered = spec.kind === "dangling" ? spec.target === "project" ? sets.projectIds : sets.taskListIds : undefined;
-  if (spec.kind === "dangling" && !registered)
-    return null;
-  let count = 0;
-  let open = 0;
-  for (const row of rows) {
-    const reference = referenceOf(row, spec.field);
-    const matches = spec.kind === "missing" ? reference === null : reference !== null && !registered.has(reference);
-    if (!matches)
-      continue;
-    count++;
-    if (spec.entity === "task") {
-      const status = row.status;
-      if (typeof status === "string" && OPEN_TASK_STATUSES.includes(status))
-        open++;
-    }
-  }
-  return { count, open_count: spec.entity === "task" ? open : null };
-}
-var TODOS_INTEGRITY_SCHEMA_VERSION = "todos.integrity.v1", TERMINAL_TASK_STATUSES, OPEN_TASK_STATUSES, INTEGRITY_CONDITIONS, ENTITY_LABEL, SQLITE_TABLE, RECORD_TYPE;
-var init_integrity = __esm(() => {
-  init_types();
-  TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled"];
-  OPEN_TASK_STATUSES = TASK_STATUSES.filter((status) => !TERMINAL_TASK_STATUSES.includes(status));
-  INTEGRITY_CONDITIONS = [
-    {
-      id: "tasks_without_project",
-      entity: "task",
-      field: "project_id",
-      target: "project",
-      kind: "missing",
-      base_severity: "warn",
-      escalate_when_open: true,
-      impact: "invisible to every project-scoped read (list, status, next, claim)"
-    },
-    {
-      id: "tasks_without_task_list",
-      entity: "task",
-      field: "task_list_id",
-      target: "task_list",
-      kind: "missing",
-      base_severity: "warn",
-      escalate_when_open: true,
-      impact: "invisible to every task-list read \u2014 the list reports zero open work"
-    },
-    {
-      id: "tasks_with_unregistered_project",
-      entity: "task",
-      field: "project_id",
-      target: "project",
-      kind: "dangling",
-      base_severity: "error",
-      escalate_when_open: false,
-      impact: "points at a project id that does not exist; the reference can never resolve"
-    },
-    {
-      id: "tasks_with_unregistered_task_list",
-      entity: "task",
-      field: "task_list_id",
-      target: "task_list",
-      kind: "dangling",
-      base_severity: "error",
-      escalate_when_open: false,
-      impact: "points at a task-list id that does not exist; the reference can never resolve"
-    },
-    {
-      id: "task_lists_without_project",
-      entity: "task_list",
-      field: "project_id",
-      target: "project",
-      kind: "missing",
-      base_severity: "warn",
-      escalate_when_open: false,
-      impact: "unbound list \u2014 unreachable from any project, so its tasks are unroutable"
-    },
-    {
-      id: "task_lists_with_unregistered_project",
-      entity: "task_list",
-      field: "project_id",
-      target: "project",
-      kind: "dangling",
-      base_severity: "error",
-      escalate_when_open: false,
-      impact: "points at a project id that does not exist; the list can never be reached"
-    }
-  ];
-  ENTITY_LABEL = {
-    task: ["task", "tasks"],
-    task_list: ["task list", "task lists"]
-  };
-  SQLITE_TABLE = {
-    task: "tasks",
-    task_list: "task_lists",
-    project: "projects"
-  };
-  RECORD_TYPE = {
-    task: "tasks",
-    task_list: "task_lists",
-    project: "projects"
-  };
-});
-
 // src/storage/postgres-adapter.ts
 import { randomUUID as randomUUID3 } from "crypto";
 function createPostgresTodosStorageAdapter(options) {
@@ -34271,8 +35271,8 @@ class PostgresTodosProjectRegistrationTransaction {
     ]);
     return result.rows[0] ? receiptFromRow(result.rows[0]) : null;
   }
-  async getReceiptById(receiptId) {
-    const result = await this.client.query("SELECT * FROM todos_project_registration_receipts WHERE receipt_id = $1 LIMIT 1", [receiptId]);
+  async getReceiptById(receiptId2) {
+    const result = await this.client.query("SELECT * FROM todos_project_registration_receipts WHERE receipt_id = $1 LIMIT 1", [receiptId2]);
     return result.rows[0] ? receiptFromRow(result.rows[0]) : null;
   }
   async getAcceptedReceiptForStep(identity) {
@@ -34552,8 +35552,8 @@ class PostgresTodosProjectRegistrationBackend {
   async getReceiptForLookup(identity) {
     return (await this.direct()).getReceiptForLookup(identity);
   }
-  async getReceiptById(receiptId) {
-    return (await this.direct()).getReceiptById(receiptId);
+  async getReceiptById(receiptId2) {
+    return (await this.direct()).getReceiptById(receiptId2);
   }
   async getBinding(scope, resourceKind, targetSelector) {
     return (await this.direct()).getBinding(scope, resourceKind, targetSelector);
@@ -34571,618 +35571,593 @@ var init_postgres2 = __esm(() => {
   init_types3();
 });
 
-// src/db/integrity.ts
-function tableExists2(db, table) {
-  return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
-}
-function scanSqliteIntegrity(db = getDatabase()) {
-  const missing = Object.keys(REQUIRED_TABLES).filter((table) => !tableExists2(db, table));
-  const conditions = INTEGRITY_CONDITIONS.map((spec) => {
-    if (missing.length > 0) {
-      return unverifiedCondition(spec, `local schema is missing table(s): ${missing.join(", ")}`);
-    }
-    try {
-      const row = db.query(buildSqliteIntegritySql(spec)).get();
-      return measuredCondition(spec, { count: Number(row?.count ?? 0), open_count: spec.entity === "task" ? Number(row?.open_count ?? 0) : null }, "sqlite");
-    } catch (error) {
-      return unverifiedCondition(spec, error instanceof Error ? error.message : String(error));
-    }
-  });
-  return buildIntegrityReport(conditions, now());
+// src/project-registration/sqlite.ts
+function sameSqliteValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
 }
-var REQUIRED_TABLES;
-var init_integrity2 = __esm(() => {
-  init_database();
-  init_integrity();
-  REQUIRED_TABLES = { tasks: true, task_lists: true, projects: true };
-});
-
-// src/storage/sqlite-snapshot.ts
-function exportSqliteTodosStorageSnapshot(db) {
-  const d = db ?? getDatabase();
+function taskListFromRow(row) {
   return {
-    exportedAt: new Date().toISOString(),
-    source: "sqlite",
-    tasks: listTasks({ include_archived: true }, d),
-    projects: listProjects(d),
-    projectMachinePaths: listProjectMachinePaths(d),
-    plans: listPlans(undefined, d),
-    agents: listAgents({ include_archived: true }, d),
-    taskLists: listTaskLists(undefined, d),
-    templates: listTemplates(d),
-    templateTasks: listTemplates(d).flatMap((template) => getTemplateTasks(template.id, d)),
-    auditHistory: getRecentActivity(Number.MAX_SAFE_INTEGER, d),
-    tombstones: listStorageTombstones(d)
-  };
-}
-function importSqliteTodosStorageSnapshot(snapshot, db) {
-  const d = db ?? getDatabase();
-  const result = {
-    inserted: 0,
-    updated: 0,
-    deleted: 0,
-    skipped: 0,
-    errors: []
-  };
-  result.errors.push(...validateSnapshotRoutingRecords(snapshot.projects, snapshot.taskLists));
-  if (result.errors.length === 0) {
-    const existingProjects = d.query("SELECT id, task_list_id FROM projects").all();
-    const existingTaskLists = d.query("SELECT id, project_id, slug FROM task_lists").all();
-    result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
-  }
-  if (result.errors.length > 0)
-    return result;
-  const applyRows = (objectType, table, columns, rows, updateClockColumn, afterUpsert) => {
-    for (const row of rows) {
-      try {
-        const record = asRecord(row);
-        const tombstone = typeof record["id"] === "string" ? getStorageTombstone(objectType, record["id"], d) : null;
-        if (tombstone && shouldApplyStorageTombstone(tombstone, rowClock(record, updateClockColumn))) {
-          result.skipped += 1;
-          continue;
-        }
-        const state = upsertById(d, table, columns, record, updateClockColumn);
-        if (state === "inserted")
-          result.inserted += 1;
-        else if (state === "updated")
-          result.updated += 1;
-        else
-          result.skipped += 1;
-        afterUpsert?.(record, state !== "skipped");
-      } catch (error) {
-        result.errors.push(error instanceof Error ? error.message : String(error));
-      }
-    }
-  };
-  applyRows("projects", "projects", PROJECT_COLUMNS, snapshot.projects, "updated_at");
-  applyRows("project_machine_paths", "project_machine_paths", PROJECT_MACHINE_PATH_COLUMNS, snapshot.projectMachinePaths ?? [], "updated_at");
-  applyRows("agents", "agents", AGENT_COLUMNS, snapshot.agents, "last_seen_at");
-  applyRows("task_lists", "task_lists", TASK_LIST_COLUMNS, snapshot.taskLists, "updated_at");
-  applyRows("plans", "plans", PLAN_COLUMNS, snapshot.plans, "updated_at");
-  applyRows("templates", "task_templates", TEMPLATE_COLUMNS, snapshot.templates);
-  applyRows("template_tasks", "template_tasks", TEMPLATE_TASK_COLUMNS, snapshot.templateTasks ?? []);
-  applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks2(snapshot.tasks), "updated_at", (row, changed) => {
-    if (changed && Array.isArray(row["tags"]) && typeof row["id"] === "string") {
-      replaceTaskTags(row["id"], row["tags"].filter((tag) => typeof tag === "string"), d);
-    }
-  });
-  applyRows("audit_history", "task_history", AUDIT_COLUMNS, snapshot.auditHistory);
-  applyTombstones(d, snapshot.tombstones ?? [], result);
-  return result;
-}
-function upsertById(db, table, columns, row, updateClockColumn) {
-  const id = row["id"];
-  if (typeof id !== "string" || !id)
-    throw new Error(`${table} row is missing id`);
-  const presentColumns = columns.filter((column) => (column in row));
-  if (!presentColumns.includes("id"))
-    presentColumns.unshift("id");
-  const existing = existsById2(db, table, id);
-  const placeholders3 = presentColumns.map(() => "?").join(", ");
-  const values = presentColumns.map((column) => valueForColumn(column, row[column]));
-  const updateColumns = presentColumns.filter((column) => column !== "id");
-  const updateSet = updateColumns.map((column) => column === "version" ? `version = MAX(COALESCE(${table}.version, 0), excluded.version)` : `${column} = excluded.${column}`).join(", ");
-  const clockGuard = updateClockColumn && presentColumns.includes(updateClockColumn) ? ` WHERE ${table}.${updateClockColumn} IS NULL OR ${table}.${updateClockColumn} <= excluded.${updateClockColumn}` : "";
-  const sql = updateSet ? `INSERT INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders3})
-       ON CONFLICT(id) DO UPDATE SET ${updateSet}${clockGuard}` : `INSERT OR IGNORE INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders3})`;
-  const changes = db.run(sql, values).changes;
-  if (changes === 0)
-    return "skipped";
-  return existing ? "updated" : "inserted";
-}
-function existsById2(db, table, id) {
-  return Boolean(db.query(`SELECT id FROM ${table} WHERE id = ?`).get(id));
-}
-function valueForColumn(column, value) {
-  if (BOOLEAN_COLUMNS.has(column))
-    return value ? 1 : 0;
-  if (JSON_COLUMNS.has(column))
-    return JSON.stringify(value ?? (column === "tags" || column === "permissions" || column === "capabilities" || column === "variables" ? [] : {}));
-  return value === undefined ? null : value;
-}
-function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("snapshot rows must be objects");
-  }
-  return value;
-}
-function sortedTasks2(tasks) {
-  const byId = new Map(tasks.map((task) => [task.id, task]));
-  const seen = new Set;
-  const result = [];
-  const visit = (task) => {
-    if (seen.has(task.id))
-      return;
-    if (task.parent_id && byId.has(task.parent_id))
-      visit(byId.get(task.parent_id));
-    seen.add(task.id);
-    result.push(task);
-  };
-  for (const task of tasks)
-    visit(task);
-  return result;
-}
-function applyTombstones(db, tombstones, result) {
-  for (const tombstone of tombstones) {
-    try {
-      recordStorageTombstone({
-        object_type: tombstone.object_type,
-        object_id: tombstone.object_id,
-        deleted_at: tombstone.deleted_at,
-        source_machine_id: tombstone.source_machine_id ?? null,
-        payload: tombstone.payload ?? null,
-        version: tombstone.version ?? null
-      }, db);
-      const table = tableForTombstone(tombstone.object_type);
-      const existing = existingClock(db, table, tombstone.object_id);
-      if (!shouldApplyStorageTombstone(tombstone, existing)) {
-        result.skipped += 1;
-        continue;
-      }
-      const deletedTags = table === "tasks" ? db.run("DELETE FROM task_tags WHERE task_id = ?", [tombstone.object_id]).changes : 0;
-      const deleted = db.run(`DELETE FROM ${table} WHERE id = ?`, [tombstone.object_id]).changes;
-      if (deleted > 0 || deletedTags > 0)
-        result.deleted = (result.deleted ?? 0) + 1;
-      else
-        result.skipped += 1;
-    } catch (error) {
-      result.errors.push(error instanceof Error ? error.message : String(error));
-    }
-  }
-}
-function tableForTombstone(objectType) {
-  if (objectType === "tasks")
-    return "tasks";
-  if (objectType === "projects")
-    return "projects";
-  if (objectType === "project_machine_paths")
-    return "project_machine_paths";
-  if (objectType === "plans")
-    return "plans";
-  if (objectType === "agents")
-    return "agents";
-  if (objectType === "task_lists")
-    return "task_lists";
-  if (objectType === "templates")
-    return "task_templates";
-  if (objectType === "template_tasks")
-    return "template_tasks";
-  return "task_history";
-}
-function listRows(db, table, columns) {
-  return db.query(`SELECT ${columns.join(", ")} FROM ${table} ORDER BY id`).all();
-}
-function listProjectMachinePaths(db) {
-  return listRows(db, "project_machine_paths", PROJECT_MACHINE_PATH_COLUMNS).map((row) => ({
-    id: String(row.id),
-    project_id: String(row.project_id),
-    machine_id: String(row.machine_id),
-    path: String(row.path),
-    created_at: String(row.created_at),
-    updated_at: String(row.updated_at)
-  }));
-}
-function existingClock(db, table, id) {
-  const clockColumns = clockColumnsForTable(table);
-  const row = db.query(`SELECT ${clockColumns.join(", ")} FROM ${table} WHERE id = ?`).get(id);
-  return row?.updated_at ?? row?.last_seen_at ?? row?.created_at ?? null;
-}
-function rowClock(row, updateClockColumn) {
-  const value = updateClockColumn ? row[updateClockColumn] : null;
-  return stringClock(value) ?? stringClock(row["updated_at"]) ?? stringClock(row["last_seen_at"]) ?? stringClock(row["created_at"]);
-}
-function stringClock(value) {
-  return typeof value === "string" && value ? value : null;
-}
-function clockColumnsForTable(table) {
-  if (table === "agents")
-    return ["last_seen_at", "created_at"];
-  if (table === "task_templates")
-    return ["created_at"];
-  if (table === "task_history")
-    return ["created_at"];
-  return ["updated_at", "created_at"];
-}
-var PROJECT_COLUMNS, PROJECT_MACHINE_PATH_COLUMNS, TASK_LIST_COLUMNS, PLAN_COLUMNS, AGENT_COLUMNS, TEMPLATE_COLUMNS, TEMPLATE_TASK_COLUMNS, TASK_COLUMNS, AUDIT_COLUMNS, JSON_COLUMNS, BOOLEAN_COLUMNS;
-var init_sqlite_snapshot = __esm(() => {
-  init_database();
-  init_agents();
-  init_audit();
-  init_plans();
-  init_projects();
-  init_task_lists();
-  init_tasks();
-  init_templates();
-  init_storage_tombstones();
-  PROJECT_COLUMNS = [
-    "id",
-    "name",
-    "path",
-    "description",
-    "task_list_id",
-    "task_prefix",
-    "task_counter",
-    "created_at",
-    "updated_at",
-    "machine_id",
-    "synced_at"
-  ];
-  PROJECT_MACHINE_PATH_COLUMNS = [
-    "id",
-    "project_id",
-    "machine_id",
-    "path",
-    "created_at",
-    "updated_at"
-  ];
-  TASK_LIST_COLUMNS = [
-    "id",
-    "project_id",
-    "slug",
-    "name",
-    "description",
-    "metadata",
-    "created_at",
-    "updated_at",
-    "machine_id",
-    "synced_at"
-  ];
-  PLAN_COLUMNS = [
-    "id",
-    "project_id",
-    "task_list_id",
-    "agent_id",
-    "name",
-    "description",
-    "status",
-    "created_at",
-    "updated_at",
-    "machine_id",
-    "synced_at"
-  ];
-  AGENT_COLUMNS = [
-    "id",
-    "name",
-    "description",
-    "role",
-    "title",
-    "level",
-    "permissions",
-    "capabilities",
-    "reports_to",
-    "org_id",
-    "metadata",
-    "status",
-    "created_at",
-    "last_seen_at",
-    "session_id",
-    "working_dir",
-    "active_project_id",
-    "machine_id",
-    "synced_at"
-  ];
-  TEMPLATE_COLUMNS = [
-    "id",
-    "name",
-    "title_pattern",
-    "description",
-    "priority",
-    "tags",
-    "variables",
-    "project_id",
-    "plan_id",
-    "metadata",
-    "version",
-    "created_at",
-    "machine_id",
-    "synced_at"
-  ];
-  TEMPLATE_TASK_COLUMNS = [
-    "id",
-    "template_id",
-    "position",
-    "title_pattern",
-    "description",
-    "priority",
-    "tags",
-    "task_type",
-    "condition",
-    "include_template_id",
-    "depends_on_positions",
-    "metadata",
-    "created_at"
-  ];
-  TASK_COLUMNS = [
-    "id",
-    "short_id",
-    "project_id",
-    "parent_id",
-    "plan_id",
-    "task_list_id",
-    "title",
-    "description",
-    "status",
-    "priority",
-    "agent_id",
-    "assigned_to",
-    "session_id",
-    "working_dir",
-    "tags",
-    "metadata",
-    "version",
-    "locked_by",
-    "locked_at",
-    "created_at",
-    "updated_at",
-    "started_at",
-    "completed_at",
-    "due_at",
-    "estimated_minutes",
-    "actual_minutes",
-    "requires_approval",
-    "approved_by",
-    "approved_at",
-    "recurrence_rule",
-    "recurrence_parent_id",
-    "spawns_template_id",
-    "confidence",
-    "reason",
-    "spawned_from_session",
-    "assigned_by",
-    "assigned_from_project",
-    "task_type",
-    "cost_tokens",
-    "cost_usd",
-    "delegated_from",
-    "delegation_depth",
-    "retry_count",
-    "max_retries",
-    "retry_after",
-    "sla_minutes",
-    "runner_id",
-    "runner_started_at",
-    "runner_completed_at",
-    "current_step",
-    "total_steps",
-    "cycle_id",
-    "machine_id",
-    "synced_at",
-    "archived_at"
-  ];
-  AUDIT_COLUMNS = [
-    "id",
-    "task_id",
-    "action",
-    "field",
-    "old_value",
-    "new_value",
-    "agent_id",
-    "created_at",
-    "machine_id"
-  ];
-  JSON_COLUMNS = new Set(["tags", "metadata", "permissions", "capabilities", "variables", "depends_on_positions"]);
-  BOOLEAN_COLUMNS = new Set(["requires_approval"]);
-});
+    ...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;
+}
 
-// src/storage/local-sqlite.ts
-function resolveTaskRefLocal(db, ref) {
-  const raw = ref.trim().toLowerCase();
-  if (!raw)
-    return null;
-  if (TASK_UUID_RE2.test(raw))
-    return getTask(raw, db);
-  const prefixRows = db.query("SELECT id, project_id FROM tasks WHERE LOWER(id) LIKE ? ESCAPE '\\' ORDER BY project_id, id LIMIT 2").all(`${raw.replace(/[\\%_]/g, (c) => `\\${c}`)}%`);
-  if (prefixRows.length > 1) {
-    throw new TaskReferenceAmbiguousError(ref, prefixRows.map((row) => ({ task_id: row.id, project_id: row.project_id })));
+class SqliteTodosProjectRegistrationTransaction {
+  db;
+  storage;
+  constructor(db) {
+    this.db = db;
+    this.storage = createLocalSqliteTodosStorageAdapter({ db });
   }
-  if (prefixRows.length === 1)
-    return getTask(prefixRows[0].id, db);
-  const shortIdRows = db.query("SELECT id, project_id FROM tasks WHERE LOWER(short_id) = ? ORDER BY project_id, id LIMIT 2").all(raw);
-  if (shortIdRows.length > 1) {
-    throw new TaskReferenceAmbiguousError(ref, shortIdRows.map((row) => ({ task_id: row.id, project_id: row.project_id })));
+  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(receiptId2) {
+    const row = this.db.query("SELECT * FROM todos_project_registration_receipts WHERE receipt_id = ? LIMIT 1").get(receiptId2);
+    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);
   }
-  if (shortIdRows.length === 1)
-    return getTask(shortIdRows[0].id, db);
-  return null;
-}
-function isSearchQuery(filter) {
-  const q = filter.query?.trim();
-  return !!q && q !== "*";
 }
-function matchesExtraFilters(task, filter) {
-  if (filter.ids && !filter.ids.includes(task.id))
-    return false;
-  if (filter.parent_id !== undefined && (task.parent_id ?? null) !== filter.parent_id)
-    return false;
-  if (filter.plan_id !== undefined && task.plan_id !== filter.plan_id)
-    return false;
-  if (filter.session_id !== undefined && task.session_id !== filter.session_id)
-    return false;
-  if (filter.has_recurrence !== undefined && Boolean(task.recurrence_rule) !== filter.has_recurrence)
-    return false;
-  if (filter.task_type !== undefined) {
-    const allowed = Array.isArray(filter.task_type) ? filter.task_type : [filter.task_type];
-    if (!allowed.includes(task.task_type ?? ""))
+
+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(receiptId2) {
+    return this.receipts.get(receiptId2) ?? this.direct.getReceiptById(receiptId2);
+  }
+  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;
   }
-  if (filter.tags?.length) {
-    const taskTags = new Set(task.tags ?? []);
-    if (!filter.tags.every((tag) => taskTags.has(tag)))
+  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;
   }
-  if (filter.include_subtasks !== true && filter.parent_id === undefined && task.parent_id)
-    return false;
-  return true;
-}
-function listTasksMaybeSearch(filter, db) {
-  if (!isSearchQuery(filter))
-    return listTasks(filter, db);
-  const matched = searchTasks({
-    query: filter.query,
-    project_id: filter.project_id,
-    task_list_id: filter.task_list_id,
-    status: filter.status,
-    priority: filter.priority,
-    assigned_to: filter.assigned_to,
-    agent_id: filter.agent_id
-  }, undefined, undefined, db).filter((task) => matchesExtraFilters(task, filter));
-  const offset = filter.offset && filter.offset > 0 ? Math.trunc(filter.offset) : 0;
-  if (filter.limit !== undefined && filter.limit >= 0)
-    return matched.slice(offset, offset + filter.limit);
-  return offset ? matched.slice(offset) : matched;
-}
-function createLocalSqliteTodosStorageAdapter(options = {}) {
-  const database = () => options.db ?? getDatabase();
-  let adapter;
-  adapter = {
-    kind: "sqlite",
-    capabilities: {
-      localPersistence: true,
-      remotePersistence: false,
-      transactions: true,
-      auditLog: true,
-      sync: true
-    },
-    tasks: {
-      create: (input, context) => createTask({
-        ...input,
-        agent_id: input.agent_id ?? context?.agentId,
-        created_by: input.created_by ?? input.agent_id ?? context?.agentId
-      }, database()),
-      get: (id) => getTask(id, database()),
-      resolveRef: (ref) => resolveTaskRefLocal(database(), ref),
-      list: (filter = {}) => listTasksMaybeSearch(filter, database()),
-      count: (filter = {}) => isSearchQuery(filter) ? listTasksMaybeSearch({ ...filter, limit: undefined, offset: undefined }, database()).length : countTasks(filter, database()),
-      update: (id, input) => updateTask(id, input, database()),
-      unlock: (id, agentId) => {
-        unlockTask(id, agentId, database());
-        return true;
-      },
-      delete: (id) => deleteTask(id, database()),
-      start: (id, agentId) => startTask(id, agentId, database()),
-      complete: (id, agentId, options2) => completeTask(id, agentId, database(), options2),
-      fail: (id, agentId, reason, options2) => failTask(id, agentId, reason, options2, database()),
-      claimNext: (agentId, filters) => claimNextTask(agentId, filters, database()),
-      getNext: (agentId, filters) => getNextTask(agentId, filters, database()),
-      getActiveWork: (filters) => getActiveWork(filters, database()),
-      getChangedSince: (since, filters) => getTasksChangedSince(since, filters, database())
-    },
-    projects: {
-      create: (input) => createProject(input, database()),
-      get: (id) => getProject(id, database()),
-      getByPath: (path) => getProjectByPath(path, database()),
-      list: () => listProjects(database()),
-      update: (id, input) => updateProject(id, input, database()),
-      rename: (id, input) => renameProject(id, input, database()),
-      delete: (id) => deleteProject(id, database())
-    },
-    plans: {
-      create: (input) => createPlan(input, database()),
-      get: (id) => getPlan(id, database()),
-      list: (projectId) => listPlans(projectId, database()),
-      update: (id, input) => updatePlan(id, input, database()),
-      delete: (id) => deletePlan(id, database())
-    },
-    agents: {
-      register: (input) => registerAgent(input, database()),
-      get: (id) => getAgent(id, database()),
-      getByName: (name) => getAgentByName(name, database()),
-      list: (options2) => listAgents(options2, database()),
-      update: (id, input) => updateAgent(id, input, database())
-    },
-    taskLists: {
-      create: (input) => createTaskList(input, database()),
-      get: (id) => getTaskList(id, database()),
-      getBySlug: (slug, projectId) => getTaskListBySlug(slug, projectId, database()),
-      list: (projectId) => listTaskLists(projectId, database()),
-      update: (id, input) => updateTaskList(id, input, database()),
-      delete: (id) => deleteTaskList(id, database())
-    },
-    templates: {
-      create: (input) => createTemplate(input, database()),
-      get: (id) => getTemplate(id, database()),
-      list: () => listTemplates(database()),
-      update: (id, input) => updateTemplate(id, input, database()),
-      delete: (id) => deleteTemplate(id, database()),
-      getWithTasks: (id) => getTemplateWithTasks(id, database())
-    },
-    audit: {
-      logTaskChange: (taskId, action, field, oldValue, newValue, agentId) => logTaskChange(taskId, action, field, oldValue, newValue, agentId, database()),
-      addComment: (input) => addComment(input, database()),
-      getComments: (taskId) => listComments(taskId, database()),
-      getCommentsPage: (taskId, options2) => {
-        if (options2?.limit !== undefined && (!Number.isSafeInteger(options2.limit) || options2.limit < 1 || options2.limit > 1001)) {
-          throw new Error("Comment limit must be an integer between 1 and 1001");
+  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");
         }
-        let comments = listComments(taskId, database());
-        comments = comments.sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id));
-        if (options2?.before) {
-          const before = options2.before;
-          comments = comments.filter((comment) => comment.created_at < before.created_at || comment.created_at === before.created_at && comment.id < before.id);
+      } 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");
         }
-        if (options2?.limit !== undefined)
-          comments = comments.slice(-options2.limit);
-        return comments;
-      },
-      getTaskHistory: (taskId) => getTaskHistory(taskId, database()),
-      getRecentActivity: (limit) => getRecentActivity(limit, database())
-    },
-    sync: {
-      getTasksChangedSince: (since, filters) => getTasksChangedSince(since, filters, database()),
-      exportSnapshot: () => exportSqliteTodosStorageSnapshot(database()),
-      importSnapshot: (snapshot) => importSqliteTodosStorageSnapshot(snapshot, database())
-    },
-    integrity: {
-      report: () => scanSqliteIntegrity(database())
-    },
-    transaction: (fn) => {
-      const tx = database().transaction(() => fn(adapter));
-      return tx();
+      } 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 adapter;
+    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 TASK_UUID_RE2;
-var init_local_sqlite = __esm(() => {
-  init_types();
-  init_search();
-  init_tasks();
-  init_projects();
-  init_plans();
-  init_agents();
-  init_task_lists();
-  init_templates();
-  init_audit();
-  init_comments();
-  init_database();
-  init_integrity2();
-  init_sqlite_snapshot();
-  TASK_UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-});
-
-// src/project-registration/sqlite.ts
-var sqliteTransactionTails, PROJECT_REFERENCE_COLUMNS, TASK_LIST_REFERENCE_COLUMNS;
+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([
@@ -35192,10 +36167,16 @@ 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
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 function canonicalProjectRegistrationJson(value) {
   return JSON.stringify(canonicalize2(value));
 }
@@ -35213,7 +36194,7 @@ function canonicalize2(value) {
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash9("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash10("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -35354,7 +36335,7 @@ function taskListRecord(taskList) {
     })
   };
 }
-function receiptId(input) {
+function receiptId2(input) {
   return `tpr_${digestProjectRegistrationValue(input).slice(0, 40)}`;
 }
 function capabilityMatches(request, capability) {
@@ -35512,7 +36493,7 @@ function assertInverseRequest(request, capability) {
 function makeReceipt(input, createdAt) {
   return {
     ...input,
-    receipt_id: receiptId(input),
+    receipt_id: receiptId2(input),
     created_at: createdAt
   };
 }
@@ -38389,6 +39370,9 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         Task: taskSchema,
         Project: projectSchema,
         TaskList: taskListSchema,
+        ProjectTaskListEnsureReceipt: projectTaskListEnsureReceiptSchema,
+        ProjectTaskListEnsureResult: projectTaskListEnsureResultSchema,
+        ProjectTaskListRollbackResult: projectTaskListRollbackResultSchema,
         TaskComment: taskCommentSchema,
         Plan: planSchema,
         Template: templateSchema,
@@ -38466,6 +39450,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"],
@@ -39568,6 +40575,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",
@@ -39849,7 +40901,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();
@@ -39897,6 +40949,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"],
@@ -40894,6 +42020,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`);
@@ -41232,6 +42404,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,
@@ -41258,6 +42434,7 @@ var init_v1 = __esm(() => {
   init_pr_groups();
   init_project_registration();
   init_redaction();
+  init_project_task_list_ensure();
   JSON_HEADERS3 = { "Content-Type": "application/json" };
 });
 
@@ -48967,7 +50144,7 @@ __export(exports_audit_ledger, {
   LOCAL_AUDIT_LEDGER_INITIAL_HASH: () => LOCAL_AUDIT_LEDGER_INITIAL_HASH,
   LOCAL_AUDIT_LEDGER_HASH_ALGORITHM: () => LOCAL_AUDIT_LEDGER_HASH_ALGORITHM
 });
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 function canonicalize3(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
@@ -48977,7 +50154,7 @@ function canonicalize3(value) {
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalize3(object[key])}`).join(",")}}`;
 }
 function hash(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function parsePayload3(value) {
   if (!value)
@@ -57693,7 +58870,7 @@ __export(exports_local_backups, {
   TODOS_LOCAL_BACKUP_KIND: () => TODOS_LOCAL_BACKUP_KIND,
   LOCAL_BACKUP_CHECKSUM_ALGORITHM: () => LOCAL_BACKUP_CHECKSUM_ALGORITHM
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve20 } from "path";
 import { mkdirSync as mkdirSync10 } from "fs";
@@ -57706,7 +58883,7 @@ function stableJson2(value) {
   return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson2(record[key])}`).join(",")}}`;
 }
 function sha2565(value) {
-  return createHash11("sha256").update(stableJson2(value)).digest("hex");
+  return createHash12("sha256").update(stableJson2(value)).digest("hex");
 }
 function sqliteIntegrity(db) {
   let quick = "unknown";
@@ -58387,7 +59564,7 @@ __export(exports_local_snapshots, {
   getLocalSnapshot: () => getLocalSnapshot,
   TODOS_LOCAL_SNAPSHOT_SCHEMA_VERSION: () => TODOS_LOCAL_SNAPSHOT_SCHEMA_VERSION
 });
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function source2(version) {
   return {
     packageName: "@hasna/todos",
@@ -58411,7 +59588,7 @@ function stable(value) {
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stable(item)]));
 }
 function sha2566(value) {
-  return createHash12("sha256").update(JSON.stringify(stable(value))).digest("hex");
+  return createHash13("sha256").update(JSON.stringify(stable(value))).digest("hex");
 }
 function latestTimestamp2(items, fallback) {
   const timestamps = [];
@@ -58983,7 +60160,7 @@ __export(exports_agent_replay_simulator, {
   simulateAgentReplay: () => simulateAgentReplay,
   renderAgentReplaySimulationMarkdown: () => renderAgentReplaySimulationMarkdown
 });
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { readFileSync as readFileSync15 } from "fs";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -59005,7 +60182,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable2(value[key])]));
 }
 function fingerprint2(value) {
-  return createHash13("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash14("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject2(input))
@@ -59323,7 +60500,7 @@ __export(exports_inbox, {
   deriveInboxTitle: () => deriveInboxTitle,
   createInboxItem: () => createInboxItem
 });
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function parseMetadata3(value) {
   if (!value)
     return {};
@@ -59343,7 +60520,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 createHash14("sha256").update(`${sourceType}
+  return createHash15("sha256").update(`${sourceType}
 ${input.source_url || ""}
 ${normalized}`).digest("hex");
 }
@@ -64555,13 +65732,13 @@ __export(exports_environment_snapshots, {
   compareEnvironmentSnapshotFiles: () => compareEnvironmentSnapshotFiles,
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { existsSync as existsSync21, readFileSync as readFileSync16, statSync as statSync10 } from "fs";
 import { hostname as hostname2, platform, arch } from "os";
 import { dirname as dirname10, join as join22, resolve as resolve21 } from "path";
 import { tmpdir as tmpdir4 } 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 = join22(root, relativePath);
@@ -64676,8 +65853,8 @@ function defaultSnapshotDir() {
   return join22(dirname10(resolve21(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 = resolve21(input.root || process.cwd());
@@ -69352,15 +70529,15 @@ __export(exports_task_route_sources, {
   TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION: () => TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION
 });
 import { Database as Database4 } from "bun:sqlite";
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { existsSync as existsSync25, readdirSync as readdirSync5, statSync as statSync11 } from "fs";
 import { basename as basename10, dirname as dirname14, join as join26, resolve as resolve22 } from "path";
 function normalizePath6(input) {
   return resolve22(input);
 }
 function sourceStoreId(sourceDbPath) {
-  const digest = createHash16("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
-  return `sqlite:${digest}`;
+  const digest2 = createHash17("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  return `sqlite:${digest2}`;
 }
 function inferSourceRepoPath(sourceDbPath) {
   const normalized = normalizePath6(sourceDbPath);
@@ -69691,7 +70868,7 @@ __export(exports_tester_issue_reports, {
   TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
   TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION
 });
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function asObject3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -69863,7 +71040,7 @@ function fingerprintTesterIssueReport(report) {
     normalizeText4(report.failure?.message || report.summary || report.title).slice(0, 240),
     normalizeText4(stackTop).slice(0, 160)
   ].join("::");
-  return `testers:${createHash17("sha256").update(raw).digest("hex").slice(0, 16)}`;
+  return `testers:${createHash18("sha256").update(raw).digest("hex").slice(0, 16)}`;
 }
 function priorityForSeverity(severity, fallback) {
   return PRIORITIES5.includes(severity) ? severity : fallback;
@@ -74498,7 +75675,7 @@ var init_dispatch3 = __esm(() => {
 });
 
 // src/lib/delegation-brief.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 function resolveDelegationBrief(input, sources) {
   const hasPath = typeof input.briefPath === "string" && input.briefPath.length > 0;
   const hasText = typeof input.briefText === "string" && input.briefText.length > 0;
@@ -74558,7 +75735,7 @@ function resolveDelegationBrief(input, sources) {
     ok: true,
     text: text2,
     source: source3,
-    sha256: createHash18("sha256").update(text2, "utf8").digest("hex"),
+    sha256: createHash19("sha256").update(text2, "utf8").digest("hex"),
     bytes: Buffer.byteLength(text2, "utf8")
   };
 }
@@ -81101,7 +82278,7 @@ var init_hybrid = __esm(() => {
 });
 
 // src/storage/s3-artifacts.ts
-import { createHash as createHash19, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash20, createHmac as createHmac2 } from "crypto";
 function createTodosS3ArtifactStore(options) {
   const requestFetch = options.fetch ?? fetch;
   const now4 = options.now ?? (() => new Date);
@@ -81273,7 +82450,7 @@ function toAmzDate(date) {
   return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
 }
 function sha256Hex(value) {
-  return createHash19("sha256").update(value).digest("hex");
+  return createHash20("sha256").update(value).digest("hex");
 }
 function hmac(key, value) {
   return createHmac2("sha256", key).update(value).digest();