@hasna/todos 0.13.1 → 0.13.3

package/dist/index.js

@@ -3424,7 +3424,10 @@ var init_machines = __esm(() => {
 });
 
 // src/types/index.ts
-var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+function isBlockingDependencyStatus(status) {
+  return status !== "completed" && status !== "cancelled";
+}
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -3464,6 +3467,22 @@ var init_types = __esm(() => {
       this.name = "TaskNotFoundError";
     }
   };
+  TaskReferenceAmbiguousError = class TaskReferenceAmbiguousError extends Error {
+    reference;
+    static code = "TASK_REFERENCE_AMBIGUOUS";
+    candidateTaskIds;
+    candidateProjectIds;
+    constructor(reference, candidates) {
+      const candidateTaskIds = [...new Set(candidates.map((candidate) => candidate.task_id))].sort();
+      const candidateProjectIds = [...new Set(candidates.map((candidate) => candidate.project_id).filter((projectId) => typeof projectId === "string" && projectId.length > 0))].sort();
+      const projectList = candidateProjectIds.length > 0 ? candidateProjectIds.join(", ") : "(unscoped)";
+      super(`Task reference is ambiguous: "${reference}". Candidate project IDs: ${projectList}. ` + "Use a full task UUID.");
+      this.reference = reference;
+      this.name = "TaskReferenceAmbiguousError";
+      this.candidateTaskIds = candidateTaskIds;
+      this.candidateProjectIds = candidateProjectIds;
+    }
+  };
   ProjectNotFoundError = class ProjectNotFoundError extends Error {
     projectId;
     static code = "PROJECT_NOT_FOUND";
@@ -3755,15 +3774,18 @@ var init_identity_mapping = __esm(() => {
 var exports_config = {};
 __export(exports_config, {
   parseStorageMode: () => parseStorageMode,
+  parseStorageBackend: () => parseStorageBackend,
   loadTodosStorageConfig: () => loadTodosStorageConfig,
   loadStorageConfig: () => loadStorageConfig,
   isTodosShadowEnabled: () => isTodosShadowEnabled,
   isTodosRemoteStorageEnabled: () => isTodosRemoteStorageEnabled,
+  isTodosPostgresBackend: () => isTodosPostgresBackend,
   getTodosStorageShadowEnvName: () => getTodosStorageShadowEnvName,
   getTodosStorageMode: () => getTodosStorageMode,
   getTodosStorageEnvName: () => getTodosStorageEnvName,
   getTodosStorageDatabaseUrl: () => getTodosStorageDatabaseUrl,
   getTodosStorageDatabaseEnv: () => getTodosStorageDatabaseEnv,
+  getTodosStorageBackend: () => getTodosStorageBackend,
   getStorageMode: () => getStorageMode,
   getStorageDatabaseUrl: () => getStorageDatabaseUrl,
   getStorageDatabaseEnv: () => getStorageDatabaseEnv,
@@ -3788,7 +3810,7 @@ function getCanonicalTodosRdsConfig(env = process.env) {
   };
 }
 function loadTodosStorageConfig(env = process.env) {
-  const mode = getTodosStorageMode(env);
+  const mode = getTodosStorageBackend(env);
   const databaseUrl = getTodosStorageDatabaseUrl(env);
   const bucket = readStorageEnv(env, "s3Bucket").value;
   const prefix = readStorageEnv(env, "s3Prefix").value ?? "todos/";
@@ -3825,29 +3847,41 @@ function loadTodosStorageConfig(env = process.env) {
 function loadStorageConfig(env = process.env) {
   return loadTodosStorageConfig(env);
 }
+function isTodosPostgresBackend(config) {
+  return config.mode === "postgres";
+}
 function isTodosRemoteStorageEnabled(config) {
-  return config.mode === "remote" || config.mode === "hybrid";
+  return isTodosPostgresBackend(config);
 }
 function assertTodosRemoteStorageConfig(config) {
-  if (!isTodosRemoteStorageEnabled(config))
+  if (!isTodosPostgresBackend(config))
     return;
   if (!config.database?.url) {
     throw new Error(`${TODOS_STORAGE_ENV.databaseUrl} is required when ${TODOS_STORAGE_ENV.mode}=${config.mode}`);
   }
 }
-function parseStorageMode(value) {
+function parseStorageBackend(value) {
   const normalized = clean(value)?.toLowerCase();
   if (!normalized)
-    return "local";
-  if (normalized === "local" || normalized === "remote" || normalized === "hybrid")
+    return "sqlite";
+  if (normalized === "sqlite" || normalized === "postgres")
     return normalized;
-  throw new Error(`${TODOS_STORAGE_ENV.mode} must be local, remote, or hybrid`);
+  const legacy = LEGACY_BACKEND_TOKENS[normalized];
+  if (legacy)
+    return legacy;
+  throw new Error(`${TODOS_STORAGE_ENV.mode} must be sqlite or postgres (legacy values local and remote are accepted)`);
+}
+function parseStorageMode(value) {
+  return parseStorageBackend(value);
+}
+function getTodosStorageBackend(env = process.env) {
+  return parseStorageBackend(readStorageEnv(env, "mode").value);
 }
 function getTodosStorageMode(env = process.env) {
-  return parseStorageMode(readStorageEnv(env, "mode").value);
+  return getTodosStorageBackend(env);
 }
 function getStorageMode(env = process.env) {
-  return getTodosStorageMode(env);
+  return getTodosStorageBackend(env);
 }
 function isTodosShadowEnabled(env = process.env) {
   return parseBoolean(readStorageEnv(env, "shadow").value, false);
@@ -3858,8 +3892,8 @@ function getTodosStorageShadowEnvName(env = process.env) {
 function assertTodosShadowConfig(config, env = process.env) {
   if (!isTodosShadowEnabled(env))
     return;
-  if (config.mode !== "local") {
-    throw new Error(`${readStorageEnv(env, "shadow").name} shadow mirror requires ${TODOS_STORAGE_ENV.mode}=local (got ${config.mode})`);
+  if (config.mode !== "sqlite") {
+    throw new Error(`${readStorageEnv(env, "shadow").name} shadow mirror requires the sqlite backend (got ${config.mode})`);
   }
   if (!config.database?.url) {
     throw new Error(`${TODOS_STORAGE_ENV.databaseUrl} is required when ${readStorageEnv(env, "shadow").name} is enabled`);
@@ -3915,7 +3949,7 @@ function parsePositiveInteger(value, fallback) {
   }
   return parsed;
 }
-var TODOS_STORAGE_TABLES, STORAGE_TABLES, TODOS_STORAGE_ENV, TODOS_STORAGE_FALLBACK_ENV, CANONICAL_TODOS_RDS_CLUSTER_ENV = "HASNA_TODOS_RDS_CLUSTER", CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV = "HASNA_TODOS_RDS_RUNTIME_PATH", CANONICAL_TODOS_RDS_DATABASE = "todos";
+var TODOS_STORAGE_TABLES, STORAGE_TABLES, TODOS_STORAGE_ENV, TODOS_STORAGE_FALLBACK_ENV, CANONICAL_TODOS_RDS_CLUSTER_ENV = "HASNA_TODOS_RDS_CLUSTER", CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV = "HASNA_TODOS_RDS_RUNTIME_PATH", CANONICAL_TODOS_RDS_DATABASE = "todos", LEGACY_BACKEND_TOKENS;
 var init_config = __esm(() => {
   TODOS_STORAGE_TABLES = [
     "todos_sync_records",
@@ -3956,6 +3990,14 @@ var init_config = __esm(() => {
     syncBatchSize: "TODOS_SYNC_BATCH_SIZE",
     syncDryRun: "TODOS_SYNC_DRY_RUN"
   };
+  LEGACY_BACKEND_TOKENS = {
+    local: "sqlite",
+    remote: "postgres",
+    postgresql: "postgres",
+    hybrid: "postgres",
+    self_hosted: "postgres",
+    cloud: "postgres"
+  };
 });
 
 // src/storage/shadow-outbox-schema.ts
@@ -4089,6 +4131,30 @@ function findGitRoot(startDir) {
   }
   return null;
 }
+function getGlobalDbPath() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".hasna", "todos", "todos.db");
+}
+function hasExplicitProjectArg(args = process.argv.slice(2)) {
+  return args.some((arg) => arg === "--project" || arg.startsWith("--project="));
+}
+function getCliCommand(args = process.argv.slice(2)) {
+  const globalOptionsWithValues = new Set(["--project", "--agent", "--session"]);
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (globalOptionsWithValues.has(arg)) {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-"))
+      continue;
+    return arg;
+  }
+  return null;
+}
+function canCreateScopedProjectDb(args = process.argv.slice(2)) {
+  return getCliCommand(args) === "project-bootstrap" && !args.some((arg) => arg === "--dry-run" || arg.startsWith("--dry-run="));
+}
 function getDbPath() {
   if (process.env["HASNA_TODOS_DB_PATH"]) {
     return process.env["HASNA_TODOS_DB_PATH"];
@@ -4096,18 +4162,19 @@ function getDbPath() {
   if (process.env["TODOS_DB_PATH"]) {
     return process.env["TODOS_DB_PATH"];
   }
+  if (hasExplicitProjectArg())
+    return getGlobalDbPath();
   const cwd = process.cwd();
   const nearest = findNearestProjectDb(cwd);
   if (nearest)
     return nearest;
   if (process.env["TODOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot(cwd);
-    if (gitRoot) {
+    if (gitRoot && canCreateScopedProjectDb()) {
       return join(gitRoot, ".hasna", "todos", "todos.db");
     }
   }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join(home, ".hasna", "todos", "todos.db");
+  return getGlobalDbPath();
 }
 function getDatabasePath() {
   return getDbPath();
@@ -4123,8 +4190,8 @@ function ensureDir(filePath) {
 function openDatabase(path) {
   ensureDir(path);
   const db = new Database(path);
-  db.run("PRAGMA journal_mode = WAL");
   db.run("PRAGMA busy_timeout = 5000");
+  db.run("PRAGMA journal_mode = WAL");
   db.run("PRAGMA foreign_keys = ON");
   runMigrations(db);
   ensureAgentIdentitySchema(db);
@@ -4210,10 +4277,13 @@ function resolvePartialId(db, table, partialId) {
     return null;
   }
   if (table === "tasks") {
-    const shortIdRows = db.query("SELECT id FROM tasks WHERE short_id = ?").all(partialId);
+    const shortIdRows = db.query("SELECT id, project_id FROM tasks WHERE LOWER(short_id) = LOWER(?) ORDER BY project_id, id").all(partialId);
     if (shortIdRows.length === 1) {
       return shortIdRows[0].id;
     }
+    if (shortIdRows.length > 1) {
+      throw new TaskReferenceAmbiguousError(partialId, shortIdRows.map((row) => ({ task_id: row.id, project_id: row.project_id })));
+    }
   }
   if (table === "task_lists") {
     const slugRow = db.query("SELECT id FROM task_lists WHERE slug = ?").get(partialId);
@@ -4955,11 +5025,15 @@ function secretPatterns() {
   return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
 }
 function isRedactionPlaceholderMatch(match) {
-  const placeholder = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
   const trimmed = match.trim();
-  return new RegExp(`^${placeholder}$`).test(trimmed) || new RegExp(`=\\s*['"]?${placeholder}['"]?$`).test(trimmed);
+  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(trimmed) || new RegExp(`=\\s*['"]?${REDACTION_PLACEHOLDER}['"]?$`).test(trimmed);
+}
+function isRedactionPlaceholderKey(key) {
+  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(key.trim());
 }
 function isSecretKey(key) {
+  if (isRedactionPlaceholderKey(key))
+    return false;
   if (NON_SECRET_USAGE_KEYS.has(key.toLowerCase()))
     return false;
   if (DEFAULT_SECRET_KEY_PATTERN.test(key))
@@ -5020,7 +5094,7 @@ function upsertSecretSafetyConfig(input) {
   saveConfig({ ...config, secret_safety: next });
   return next;
 }
-var DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS;
+var DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS, REDACTION_PLACEHOLDER;
 var init_redaction = __esm(() => {
   init_config2();
   DEFAULT_SECRET_PATTERNS = [
@@ -5044,6 +5118,7 @@ var init_redaction = __esm(() => {
     "completion_tokens",
     "cost_tokens"
   ]);
+  REDACTION_PLACEHOLDER = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
 });
 
 // src/lib/workspace-trust.ts
@@ -6683,7 +6758,7 @@ function scanTextForSecrets(text, options = {}) {
   };
 }
 function redactText(text, options = {}) {
-  const placeholder = options.placeholder ?? REDACTION_PLACEHOLDER;
+  const placeholder = options.placeholder ?? REDACTION_PLACEHOLDER2;
   let out = text;
   for (const { pattern, allowlist_ok } of DEFAULT_PATTERNS) {
     out = out.replace(new RegExp(pattern.source, pattern.flags), (match) => {
@@ -6744,7 +6819,7 @@ function redactExportRecord(record) {
 function getDefaultSecretPatterns() {
   return DEFAULT_PATTERNS.map((p) => ({ name: p.name, source: p.pattern.source }));
 }
-var SECRET_REDACTION_SCHEMA, REDACTION_PLACEHOLDER = "[REDACTED]", DEFAULT_PATTERNS, DEFAULT_ALLOWLIST, customRedactors;
+var SECRET_REDACTION_SCHEMA, REDACTION_PLACEHOLDER2 = "[REDACTED]", DEFAULT_PATTERNS, DEFAULT_ALLOWLIST, customRedactors;
 var init_secret_redaction = __esm(() => {
   init_redaction();
   SECRET_REDACTION_SCHEMA = ["todos", "secret_redaction", "v1"].join(".");
@@ -8801,10 +8876,11 @@ function getTaskWithRelations(id, db) {
        JOIN task_dependencies td ON td.depends_on = t.id
        WHERE td.task_id = ?`).all(id);
   const dependencies = depRows.map(rowToTask);
-  const blockedByRows = d.query(`SELECT t.* FROM tasks t
+  const blocked_by = dependencies.filter((dep) => isBlockingDependencyStatus(dep.status));
+  const blocksRows = d.query(`SELECT t.* FROM tasks t
        JOIN task_dependencies td ON td.task_id = t.id
        WHERE td.depends_on = ?`).all(id);
-  const blocked_by = blockedByRows.map(rowToTask);
+  const blocks = blocksRows.map(rowToTask);
   const comments = d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(id);
   const parent = task.parent_id ? getTask(task.parent_id, d) : null;
   const checklist = getChecklist(id, d);
@@ -8813,6 +8889,7 @@ function getTaskWithRelations(id, db) {
     subtasks,
     dependencies,
     blocked_by,
+    blocks,
     comments,
     parent,
     checklist
@@ -11936,7 +12013,7 @@ var init_dispatches = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.13.1",
+  version: "0.13.3",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -11970,6 +12047,10 @@ var package_default = {
     "./storage": {
       types: "./dist/storage.d.ts",
       import: "./dist/storage.js"
+    },
+    "./testing": {
+      types: "./dist/testing.d.ts",
+      import: "./dist/testing.js"
     }
   },
   workspaces: [
@@ -11982,13 +12063,13 @@ var package_default = {
     "README.md"
   ],
   scripts: {
-    build: "rm -rf dist dashboard/dist && cd dashboard && bun install --frozen-lockfile && bun run build && cd .. && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/server/index.ts --outdir dist/server --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/sdk/index.ts --outdir dist/sdk --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/index.ts src/mcp.ts src/registry.ts src/contracts.ts src/storage.ts --outdir dist --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && tsc --emitDeclarationOnly --outDir dist",
-    "build:server": "rm -rf dist && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/server/index.ts --outdir dist/server --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/sdk/index.ts --outdir dist/sdk --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/index.ts src/mcp.ts src/registry.ts src/contracts.ts src/storage.ts --outdir dist --target bun --external '@hasna/contracts' --external '@hasna/contracts/*'",
+    build: "rm -rf dist dashboard/dist && cd dashboard && bun install --frozen-lockfile && bun run build && cd .. && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/server/index.ts --outdir dist/server --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/sdk/index.ts --outdir dist/sdk --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/index.ts src/mcp.ts src/registry.ts src/contracts.ts src/storage.ts src/testing.ts --outdir dist --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && tsc --emitDeclarationOnly --outDir dist",
+    "build:server": "rm -rf dist && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/server/index.ts --outdir dist/server --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/sdk/index.ts --outdir dist/sdk --target bun --external '@hasna/contracts' --external '@hasna/contracts/*' && bun build src/index.ts src/mcp.ts src/registry.ts src/contracts.ts src/storage.ts src/testing.ts --outdir dist --target bun --external '@hasna/contracts' --external '@hasna/contracts/*'",
     migrate: "bun run src/server/index.ts migrate",
     "backfill:comment-redaction": "bun run src/server/index.ts redact-comments",
     "generate:sdk": "bun run scripts/generate-sdk.ts",
     "build:dashboard": "cd dashboard && bun install --frozen-lockfile && bun run build",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsc --noEmit -p tsconfig.typecheck.json",
     test: "bun test",
     "test:no-cloud": "bun test src/no-cloud-boundary.test.ts src/local-first.test.ts src/lib/public-release-gate.test.ts",
     "dev:cli": "bun run src/cli/index.tsx",
@@ -17730,11 +17811,12 @@ var DEFAULT_LIMITS = {
   verification_limit: 10,
   run_limit: 3,
   dependency_limit: 12,
-  plan_task_limit: 20,
+  plan_task_limit: 24,
   max_text_chars: 6000,
   summary_char_limit: 480,
   stale_after_hours: 72
 };
+var MAX_CONTEXT_TASKS = 24;
 var ALL_CONTEXT_SECTIONS = [
   "project",
   "plan",
@@ -17767,7 +17849,7 @@ function limits(input) {
     verification_limit: clamp(input.verification_limit, DEFAULT_LIMITS.verification_limit, 100),
     run_limit: clamp(input.run_limit, DEFAULT_LIMITS.run_limit, 20),
     dependency_limit: clamp(input.dependency_limit, DEFAULT_LIMITS.dependency_limit, 100),
-    plan_task_limit: clamp(input.plan_task_limit, DEFAULT_LIMITS.plan_task_limit, 100),
+    plan_task_limit: clamp(input.plan_task_limit, DEFAULT_LIMITS.plan_task_limit, MAX_CONTEXT_TASKS),
     max_text_chars: clamp(input.max_text_chars, DEFAULT_LIMITS.max_text_chars, 50000),
     summary_char_limit: clamp(input.summary_char_limit, DEFAULT_LIMITS.summary_char_limit, 4000),
     stale_after_hours: clamp(input.stale_after_hours, DEFAULT_LIMITS.stale_after_hours, 24 * 365)
@@ -17790,6 +17872,13 @@ function taskSummary(task2) {
     priority: task2.priority
   };
 }
+function latestPlanTasks(planId, limit, db) {
+  const rows = db.query(`SELECT * FROM tasks
+     WHERE plan_id = ? AND archived_at IS NULL
+     ORDER BY updated_at DESC, created_at DESC, id ASC
+     LIMIT ?`).all(planId, limit);
+  return rows.map(rowToTask);
+}
 function acceptanceCriteria(task2, maxText) {
   const metadata = task2.metadata || {};
   const raw = metadata["acceptance_criteria"] ?? metadata["acceptanceCriteria"] ?? metadata["criteria"];
@@ -17887,7 +17976,7 @@ function summarizeSection(pack, section, maxChars) {
       return "No plan was attached.";
     return summarizeStrings([
       `Plan ${pack.plan.name} is ${pack.plan.status}`,
-      `${pack.plan.tasks.length} listed plan tasks`,
+      `${pack.plan.tasks.length} of ${pack.plan.total_tasks} plan tasks listed; ${pack.plan.omitted_tasks} omitted`,
       ...pack.plan.tasks.slice(0, 4).map((task2) => `${task2.status} ${task2.short_id || task2.id.slice(0, 8)} ${task2.title}`)
     ], maxChars);
   }
@@ -18037,7 +18126,8 @@ function createAgentContextPack(input, db) {
   const limit = limits(input);
   const project = task2.project_id ? getProject(task2.project_id, d) : null;
   const plan = task2.plan_id ? getPlan(task2.plan_id, d) : null;
-  const planTasks = task2.plan_id ? listTasks({ plan_id: task2.plan_id, limit: limit.plan_task_limit + 1 }, d) : [];
+  const planTasks = task2.plan_id ? latestPlanTasks(task2.plan_id, limit.plan_task_limit, d) : [];
+  const totalPlanTasks = task2.plan_id ? countTasks({ plan_id: task2.plan_id }, d) : 0;
   const upstream = getTaskDependencies(task2.id, d).map((dep) => taskSummary(getTask(dep.depends_on, d))).filter((item) => Boolean(item));
   const downstream = getTaskDependents(task2.id, d).map((dep) => taskSummary(getTask(dep.task_id, d))).filter((item) => Boolean(item));
   const comments = listComments(task2.id, d);
@@ -18080,6 +18170,9 @@ function createAgentContextPack(input, db) {
     warnings.push(`${runs.length - selectedRuns.length} older runs omitted`);
   if (fileMap.size > relevantFiles.length)
     warnings.push(`${fileMap.size - relevantFiles.length} relevant files omitted`);
+  if (totalPlanTasks > planTasks.length && plan) {
+    warnings.push(`${totalPlanTasks - planTasks.length} plan tasks omitted (${totalPlanTasks} total); load more on demand with "todos plans --show ${plan.id}" and inspect task details with "todos show <task-id>" or "todos context-pack <task-id>"`);
+  }
   const contextTask = {
     id: task2.id,
     short_id: task2.short_id,
@@ -18111,8 +18204,9 @@ function createAgentContextPack(input, db) {
       description: truncate2(plan.description, limit.max_text_chars),
       status: plan.status,
       agent_id: plan.agent_id,
-      tasks: planTasks.slice(0, limit.plan_task_limit).map(taskSummary).filter((item) => Boolean(item)),
-      omitted_tasks: Math.max(0, planTasks.length - limit.plan_task_limit)
+      tasks: planTasks.map(taskSummary).filter((item) => Boolean(item)),
+      total_tasks: totalPlanTasks,
+      omitted_tasks: Math.max(0, totalPlanTasks - planTasks.length)
     } : null,
     acceptance_criteria: acceptanceCriteria(task2, limit.max_text_chars),
     dependencies: {
@@ -18222,6 +18316,8 @@ ${pack.task.description}` : null,
     "## Project And Plan",
     pack.project ? `- Project: ${pack.project.name} (${pack.project.path})` : "- Project: none",
     pack.plan ? `- Plan: ${pack.plan.name} (${pack.plan.status})` : "- Plan: none",
+    pack.plan ? `- Plan tasks: ${pack.plan.tasks.length} shown of ${pack.plan.total_tasks} total (${pack.plan.omitted_tasks} omitted)` : null,
+    pack.plan && pack.plan.omitted_tasks > 0 ? `- Load more on demand: \`todos plans --show ${pack.plan.id}\`; inspect one task with \`todos show <task-id>\` or \`todos context-pack <task-id>\`.` : null,
     pack.plan && pack.plan.tasks.length > 0 ? bullet(pack.plan.tasks.map((task2) => `${task2.status} ${task2.short_id || task2.id.slice(0, 8)} ${task2.title}`)) : null,
     "",
     "## Acceptance Criteria",
@@ -19890,7 +19986,7 @@ function createReleaseCompatibilityReport(options = {}) {
         "todos --help",
         "todos-mcp --help",
         "todos-serve --help",
-        "todos doctor"
+        "todos doctor --no-fail-on-findings"
       ],
       smoke_tests: [
         "command -v todos",
@@ -19898,7 +19994,7 @@ function createReleaseCompatibilityReport(options = {}) {
         "command -v todos-serve",
         "todos --version",
         "todos --help",
-        "todos doctor"
+        "todos doctor --no-fail-on-findings"
       ],
       rollback: [
         "npm view @hasna/todos versions --json",
@@ -20392,12 +20488,11 @@ ${task2.description || ""}`.split(/\r?\n/);
 function normalizeStackLocation(value) {
   return value.replace(/:\d+(?::\d+)?/g, "").replace(/^file:\/\//, "").toLowerCase().trim();
 }
-function fingerprint(task2) {
+function fingerprintContent(task2) {
   const body = task2.description || "";
   const text = `${task2.title}
 ${body}`;
   return {
-    task: task2,
     title: normalizeText(task2.title),
     body: normalizeText(body),
     text: normalizeText(text),
@@ -20406,6 +20501,9 @@ ${body}`;
     stackKeys: stackKeysFor(task2)
   };
 }
+function fingerprint(task2) {
+  return { task: task2, ...fingerprintContent(task2) };
+}
 function intersects(left, right) {
   for (const value of left)
     if (right.has(value))
@@ -23592,6 +23690,13 @@ var TODOS_PACKAGE_EXPORTS = [
     types: "./dist/storage.d.ts",
     description: "Storage and service adapter contracts for local SQLite implementations.",
     stability: "stable"
+  },
+  {
+    subpath: "./testing",
+    import: "./dist/testing.js",
+    types: "./dist/testing.d.ts",
+    description: "Test-store isolation helpers that keep a consumer's test suite off a shared todos store.",
+    stability: "stable"
   }
 ];
 function source8(version) {
@@ -23623,6 +23728,9 @@ var TODOS_REGISTRY = createTodosRegistry({
 // src/storage/index.ts
 init_config();
 
+// src/storage/local-sqlite.ts
+init_types();
+
 // src/lib/search.ts
 init_database();
 function rowToTask3(row) {
@@ -24439,6 +24547,267 @@ init_audit();
 init_comments();
 init_database();
 
+// src/db/integrity.ts
+init_database();
+
+// src/lib/integrity.ts
+init_types();
+var TODOS_INTEGRITY_SCHEMA_VERSION = "todos.integrity.v1";
+var TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled"];
+var OPEN_TASK_STATUSES = TASK_STATUSES.filter((status) => !TERMINAL_TASK_STATUSES.includes(status));
+var 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"
+  }
+];
+function integrityCondition(id) {
+  const spec = INTEGRITY_CONDITIONS.find((condition) => condition.id === id);
+  if (!spec)
+    throw new Error(`unknown integrity condition: ${id}`);
+  return spec;
+}
+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;
+}
+var ENTITY_LABEL = {
+  task: ["task", "tasks"],
+  task_list: ["task list", "task lists"]
+};
+function plural(entity, count2) {
+  const [one, many] = ENTITY_LABEL[entity];
+  return count2 === 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, source9) {
+  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: source9,
+    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((source9) => source9 !== "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 entry of raw.conditions) {
+      if (entry && typeof entry["id"] === "string")
+        received.set(entry["id"], entry);
+    }
+  }
+  const conditions = INTEGRITY_CONDITIONS.map((spec) => {
+    const entry = received.get(spec.id);
+    const count2 = entry?.["count"];
+    const verified = entry?.["verified"];
+    if (!entry || verified === false || typeof count2 !== "number" || !Number.isFinite(count2)) {
+      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: count2,
+      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;
+}
+var SQLITE_TABLE = {
+  task: "tasks",
+  task_list: "task_lists",
+  project: "projects"
+};
+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}`;
+}
+var RECORD_TYPE = {
+  task: "tasks",
+  task_list: "task_lists",
+  project: "projects"
+};
+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, field2) {
+  const raw = row[field2];
+  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 count2 = 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;
+    count2++;
+    if (spec.entity === "task") {
+      const status = row.status;
+      if (typeof status === "string" && OPEN_TASK_STATUSES.includes(status))
+        open++;
+    }
+  }
+  return { count: count2, open_count: spec.entity === "task" ? open : null };
+}
+
+// src/db/integrity.ts
+var REQUIRED_TABLES2 = { tasks: true, task_lists: true, projects: true };
+function tableExists(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_TABLES2).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());
+}
+
 // src/storage/sqlite-snapshot.ts
 init_database();
 init_audit();
@@ -24830,15 +25199,15 @@ function resolveTaskRefLocal(db, ref) {
     return null;
   if (TASK_UUID_RE.test(raw))
     return getTask(raw, db);
-  const prefixRows = db.query("SELECT id FROM tasks WHERE LOWER(id) LIKE ? ESCAPE '\\' LIMIT 2").all(`${raw.replace(/[\\%_]/g, (c) => `\\${c}`)}%`);
+  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 Error(`Task reference is ambiguous: "${ref}"`);
+    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 FROM tasks WHERE LOWER(short_id) = ? LIMIT 2").all(raw);
+  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 Error(`Task reference is ambiguous: "${ref}"`);
+    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);
@@ -24987,6 +25356,9 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       exportSnapshot: () => exportSqliteTodosStorageSnapshot(database()),
       importSnapshot: (snapshot) => importSqliteTodosStorageSnapshot(snapshot, database())
     },
+    integrity: {
+      report: () => scanSqliteIntegrity(database())
+    },
     transaction: (fn) => {
       const tx = database().transaction(() => fn(adapter));
       return tx();
@@ -24995,6 +25367,10 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
   return adapter;
 }
 
+// src/storage/postgres-adapter.ts
+init_types();
+import { randomUUID as randomUUID3 } from "crypto";
+
 // src/storage/postgres-sync.ts
 var DEFAULT_TODOS_POSTGRES_SYNC_TABLE = "todos_sync_records";
 var DEFAULT_TODOS_POSTGRES_CURSOR_TABLE = "todos_sync_cursors";
@@ -25384,54 +25760,7 @@ function assertSafeIdentifier(value) {
     throw new Error(`Unsafe Postgres identifier: ${value}`);
 }
 
-// src/storage/hybrid.ts
-function createHybridTodosStorageAdapter(options) {
-  const local = options.localAdapter ?? createLocalSqliteTodosStorageAdapter(options.local);
-  const syncStore = options.syncStore ?? (options.postgresClient ? createPostgresTodosSyncStore(options.postgresClient, { sourceMachineId: options.sourceMachineId }) : null);
-  if (!syncStore)
-    throw new Error("hybrid storage requires a Postgres sync store or query client");
-  if (!local.sync.exportSnapshot || !local.sync.importSnapshot) {
-    throw new Error("hybrid storage requires local snapshot export/import support");
-  }
-  const exportSnapshot = async (context) => await local.sync.exportSnapshot(context);
-  const importSnapshot = async (snapshot, context) => await local.sync.importSnapshot(snapshot, context);
-  const remote = {
-    ensureSchema: () => syncStore.ensureSchema(),
-    async pushSnapshot(context) {
-      const snapshot = await exportSnapshot(context);
-      return syncStore.pushSnapshot(snapshot, context);
-    },
-    async pullSnapshot(options2, context) {
-      const snapshot = await syncStore.pullSnapshot(options2);
-      return importSnapshot(snapshot, context);
-    },
-    async syncOnce(options2, context) {
-      const pulled = await remote.pullSnapshot(options2, context);
-      const pushed = await remote.pushSnapshot(context);
-      return { pulled, pushed };
-    }
-  };
-  return {
-    ...local,
-    kind: "hybrid",
-    capabilities: {
-      ...local.capabilities,
-      localPersistence: true,
-      remotePersistence: true,
-      sync: true
-    },
-    sync: {
-      ...local.sync,
-      exportSnapshot,
-      importSnapshot
-    },
-    remote
-  };
-}
-
 // src/storage/postgres-adapter.ts
-init_types();
-import { randomUUID as randomUUID3 } from "crypto";
 init_redaction();
 function createPostgresTodosStorageAdapter(options) {
   const store = new PostgresJsonRecordStore(options);
@@ -25559,6 +25888,9 @@ function createPostgresTodosStorageAdapter(options) {
       exportSnapshot: () => exportSnapshot(store),
       importSnapshot: (snapshot, context) => importSnapshot(snapshot, store, context)
     },
+    integrity: {
+      report: () => store.integrityReport()
+    },
     transaction: (fn) => fn(adapter)
   };
   return adapter;
@@ -25665,8 +25997,9 @@ class PostgresJsonRecordStore {
       conds.push(`payload->>'agent_id' = ${p(filter.agent_id)}`);
     if (filter.session_id !== undefined)
       conds.push(`payload->>'session_id' = ${p(filter.session_id)}`);
-    if (filter.tags?.length)
-      conds.push(`payload->'tags' @> ${p(filter.tags)}::jsonb`);
+    if (filter.tags?.length) {
+      conds.push(`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(payload->'tags', '[]'::jsonb)) AS task_tags(tag) ` + `WHERE ${inClause("task_tags.tag", filter.tags)})`);
+    }
     if (filter.has_recurrence !== undefined) {
       conds.push(`(COALESCE(payload->>'recurrence_rule', '') <> '') = ${p(filter.has_recurrence)}`);
     }
@@ -25727,7 +26060,8 @@ class PostgresJsonRecordStore {
             AND object_id COLLATE "C" >= $2 AND object_id COLLATE "C" < $3
           LIMIT 2`, [this.service, raw, upper]);
       if (prefixResult.rows.length > 1) {
-        throw new Error(`Task reference is ambiguous: "${ref}"`);
+        const candidates = prefixResult.rows.map((row) => payloadRecord2(row.payload));
+        throw new TaskReferenceAmbiguousError(ref, candidates.map((task2) => ({ task_id: task2.id, project_id: task2.project_id })));
       }
       if (prefixResult.rows.length === 1) {
         return payloadRecord2(prefixResult.rows[0].payload);
@@ -25738,7 +26072,8 @@ class PostgresJsonRecordStore {
           AND LOWER(payload->>'short_id') = $2
         LIMIT 2`, [this.service, raw]);
     if (shortIdResult.rows.length > 1) {
-      throw new Error(`Task reference is ambiguous: "${ref}"`);
+      const candidates = shortIdResult.rows.map((row) => payloadRecord2(row.payload));
+      throw new TaskReferenceAmbiguousError(ref, candidates.map((task2) => ({ task_id: task2.id, project_id: task2.project_id })));
     }
     if (shortIdResult.rows.length === 1) {
       return payloadRecord2(shortIdResult.rows[0].payload);
@@ -25752,6 +26087,24 @@ class PostgresJsonRecordStore {
     const result = await this.options.client.query(sql, params);
     return Number(result.rows[0]?.count ?? 0);
   }
+  async integrityReport() {
+    await this.ensureSchema();
+    const conditions = [];
+    for (const spec of INTEGRITY_CONDITIONS) {
+      const { sql, params } = buildPostgresIntegritySql(spec, { table: this.tableName, service: this.service });
+      try {
+        const result = await this.options.client.query(sql, params);
+        const row = result.rows[0];
+        conditions.push(measuredCondition(spec, {
+          count: Number(row?.count ?? 0),
+          open_count: spec.entity === "task" ? Number(row?.open_count ?? 0) : null
+        }, "postgres"));
+      } catch (error) {
+        conditions.push(unverifiedCondition(spec, error instanceof Error ? error.message : String(error)));
+      }
+    }
+    return buildIntegrityReport(conditions, new Date().toISOString());
+  }
   async listTombstones() {
     await this.ensureSchema();
     const result = await this.options.client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version
@@ -26227,7 +26580,7 @@ async function startTask2(id, agentId, store) {
   if (task2.status !== "pending" && task2.status !== "in_progress") {
     throw new Error(`Task is ${task2.status} and cannot be started by ${agentId}`);
   }
-  return patchTask(task2, {
+  const started = await patchTask(task2, {
     status: "in_progress",
     assigned_to: task2.assigned_to ?? agentId,
     agent_id: task2.agent_id ?? agentId,
@@ -26235,6 +26588,8 @@ async function startTask2(id, agentId, store) {
     locked_at: new Date().toISOString(),
     started_at: task2.started_at ?? new Date().toISOString()
   }, store);
+  await logTaskChange2(task2.id, "start", "status", task2.status, "in_progress", agentId, store);
+  return started;
 }
 async function completeTask2(id, agentId, options, store) {
   const task2 = await store.completeTask(id, agentId, options);
@@ -26352,9 +26707,11 @@ async function removeDependency2(taskId, dependsOn, store) {
 }
 async function listDependencies(taskId, store) {
   const edges = await store.list("dependencies");
+  const incoming = edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }));
   return {
     dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
-    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+    blocks: incoming,
+    blocked_by: incoming
   };
 }
 async function addVerification(input, store, context) {
@@ -27341,17 +27698,17 @@ function createTodosCloudQueryClientFromEnv(env = process.env, options = {}) {
 init_config();
 function createTodosStorageAdapter(options = {}) {
   const config = options.config ?? loadTodosStorageConfig(options.env);
-  if (config.mode === "local") {
+  if (config.mode === "sqlite") {
     if (isTodosShadowEnabled(options.env))
       return createShadowAdapter(options, config);
     return createLocalSqliteTodosStorageAdapter(options.local);
   }
   assertTodosRemoteStorageConfig(config);
-  const adapter = config.mode === "hybrid" ? options.hybridAdapter ?? createImplicitHybridAdapter(options) ?? options.remoteAdapter : options.remoteAdapter ?? createImplicitPostgresAdapter(options);
+  const adapter = options.remoteAdapter ?? createImplicitPostgresAdapter(options);
   if (!adapter) {
-    throw new Error(`${config.mode} storage requires a repo-native remote adapter. ` + "Pass remoteAdapter/hybridAdapter after wiring Postgres RDS and S3 support.");
+    throw new Error("postgres storage requires a repo-native Postgres adapter. " + "Pass remoteAdapter or postgresClient after wiring Postgres RDS support.");
   }
-  assertRemoteAdapterCapabilities(adapter, config.mode);
+  assertPostgresAdapterCapabilities(adapter);
   return adapter;
 }
 function createShadowAdapter(options, config) {
@@ -27365,7 +27722,7 @@ function createShadowAdapter(options, config) {
     ...options.local ? { local: options.local } : {},
     ...options.postgresSyncStore ? { syncStore: options.postgresSyncStore } : {},
     ...postgresClient ? { postgresClient } : {},
-    ...options.hybrid?.sourceMachineId ? { sourceMachineId: options.hybrid.sourceMachineId } : {}
+    ...options.sourceMachineId ? { sourceMachineId: options.sourceMachineId } : {}
   });
 }
 function createImplicitPostgresAdapter(options) {
@@ -27373,25 +27730,12 @@ function createImplicitPostgresAdapter(options) {
     return null;
   return createPostgresTodosStorageAdapter({
     client: options.postgresClient,
-    ...options.hybrid?.sourceMachineId ? { sourceMachineId: options.hybrid.sourceMachineId } : {}
-  });
-}
-function createImplicitHybridAdapter(options) {
-  if (!options.postgresClient && !options.postgresSyncStore)
-    return null;
-  return createHybridTodosStorageAdapter({
-    ...options.hybrid ?? {},
-    local: options.local,
-    postgresClient: options.postgresClient,
-    syncStore: options.postgresSyncStore
+    ...options.sourceMachineId ? { sourceMachineId: options.sourceMachineId } : {}
   });
 }
-function assertRemoteAdapterCapabilities(adapter, mode) {
+function assertPostgresAdapterCapabilities(adapter) {
   if (!adapter.capabilities.remotePersistence) {
-    throw new Error(`${mode} storage adapter must set capabilities.remotePersistence=true`);
-  }
-  if (mode === "hybrid" && !adapter.capabilities.localPersistence) {
-    throw new Error("hybrid storage adapter must also set capabilities.localPersistence=true");
+    throw new Error("postgres storage adapter must set capabilities.remotePersistence=true");
   }
 }
 // src/storage/shadow-outbox.ts
@@ -27718,6 +28062,50 @@ async function closeRuntimeShadowCloud() {
     await cloud.close().catch(() => {});
   }
 }
+// src/storage/hybrid.ts
+function createHybridTodosStorageAdapter(options) {
+  const local = options.localAdapter ?? createLocalSqliteTodosStorageAdapter(options.local);
+  const syncStore = options.syncStore ?? (options.postgresClient ? createPostgresTodosSyncStore(options.postgresClient, { sourceMachineId: options.sourceMachineId }) : null);
+  if (!syncStore)
+    throw new Error("hybrid storage requires a Postgres sync store or query client");
+  if (!local.sync.exportSnapshot || !local.sync.importSnapshot) {
+    throw new Error("hybrid storage requires local snapshot export/import support");
+  }
+  const exportSnapshot2 = async (context) => await local.sync.exportSnapshot(context);
+  const importSnapshot2 = async (snapshot, context) => await local.sync.importSnapshot(snapshot, context);
+  const remote = {
+    ensureSchema: () => syncStore.ensureSchema(),
+    async pushSnapshot(context) {
+      const snapshot = await exportSnapshot2(context);
+      return syncStore.pushSnapshot(snapshot, context);
+    },
+    async pullSnapshot(options2, context) {
+      const snapshot = await syncStore.pullSnapshot(options2);
+      return importSnapshot2(snapshot, context);
+    },
+    async syncOnce(options2, context) {
+      const pulled = await remote.pullSnapshot(options2, context);
+      const pushed = await remote.pushSnapshot(context);
+      return { pulled, pushed };
+    }
+  };
+  return {
+    ...local,
+    kind: "hybrid",
+    capabilities: {
+      ...local.capabilities,
+      localPersistence: true,
+      remotePersistence: true,
+      sync: true
+    },
+    sync: {
+      ...local.sync,
+      exportSnapshot: exportSnapshot2,
+      importSnapshot: importSnapshot2
+    },
+    remote
+  };
+}
 // src/storage/comment-redaction-backfill.ts
 init_redaction();
 var COMMENT_REDACTION_BACKFILL_CONFIRMATION = "REDACT_STORED_TODOS_COMMENTS";
@@ -31296,10 +31684,10 @@ function getNativeStorageStatus(env = process.env) {
   } catch (error) {
     issues.push(error instanceof Error ? error.message : String(error));
   }
-  const remoteEnabled = isTodosRemoteStorageEnabled(config);
+  const remoteEnabled = isTodosPostgresBackend(config);
   const remoteFieldsConfigured = Boolean(config.database || config.objectStorage);
   if (!remoteEnabled && remoteFieldsConfigured) {
-    warnings.push(`${TODOS_STORAGE_ENV.mode}=local ignores configured remote storage fields`);
+    warnings.push(`the sqlite backend (${TODOS_STORAGE_ENV.mode}) ignores configured remote storage fields`);
   }
   if (remoteEnabled && !config.objectStorage) {
     warnings.push(`${TODOS_STORAGE_ENV.s3Bucket} is not configured, so artifact sync will stay local`);
@@ -31308,7 +31696,7 @@ function getNativeStorageStatus(env = process.env) {
     ok: issues.length === 0,
     service: "todos",
     mode: config.mode,
-    local_default: config.mode === "local",
+    local_default: config.mode === "sqlite",
     remote_enabled: remoteEnabled,
     database: {
       configured: Boolean(config.database),
@@ -31390,8 +31778,12 @@ function storageEnvStatus(env) {
   ]));
 }
 function fallbackConfig(env) {
-  const modeValue = clean2(env[TODOS_STORAGE_ENV.mode]);
-  const mode = modeValue === "remote" || modeValue === "hybrid" ? modeValue : "local";
+  let mode;
+  try {
+    mode = parseStorageBackend(clean2(env[TODOS_STORAGE_ENV.mode]));
+  } catch {
+    mode = "sqlite";
+  }
   return {
     service: "todos",
     mode,
@@ -41733,6 +42125,8 @@ init_database();
 init_tasks();
 init_task_graph();
 init_task_lifecycle();
+init_types();
+init_types();
 var DEPENDENCY_GRAPH_SCHEMA = "todos.dependency_graph.v1";
 var TASK_DEPENDENCY_EDGES_SCHEMA = "todos.task_dependency_edges.v1";
 var PROJECT_DEPENDENCY_GRAPH_SCHEMA = "todos.project_dependency_graph.v1";
@@ -41988,13 +42382,14 @@ function getBlockers(taskId, db) {
     missing_dependencies: missing
   };
 }
-function buildTaskDependencyEdges(task2, dependencies, blocked_by) {
+function buildTaskDependencyEdges(task2, dependencies, blocks) {
   return {
     schema_version: TASK_DEPENDENCY_EDGES_SCHEMA,
     task_id: task2.id,
     short_id: task2.short_id,
     dependencies: dependencies.map(toNode),
-    blocked_by: blocked_by.map(toNode)
+    blocked_by: dependencies.filter((dep) => isBlockingDependencyStatus(dep.status)).map(toNode),
+    blocks: blocks.map(toNode)
   };
 }
 function getTaskDependencyEdges(taskId, db) {
@@ -42003,8 +42398,8 @@ function getTaskDependencyEdges(taskId, db) {
   if (!task2)
     return null;
   const dependencies = getTaskDependencies(taskId, d).map((edge) => getTask(edge.depends_on, d)).filter((t) => Boolean(t));
-  const blocked_by = getTaskDependents(taskId, d).map((edge) => getTask(edge.task_id, d)).filter((t) => Boolean(t));
-  return buildTaskDependencyEdges(task2, dependencies, blocked_by);
+  const blocks = getTaskDependents(taskId, d).map((edge) => getTask(edge.task_id, d)).filter((t) => Boolean(t));
+  return buildTaskDependencyEdges(task2, dependencies, blocks);
 }
 function buildProjectDependencyGraph(projectId, tasks, edges, generatedAt = new Date().toISOString()) {
   const nodeIds = new Set(tasks.map((t) => t.id));
@@ -50567,7 +50962,7 @@ function parseObject4(value) {
 function normalizeKey(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9._:/-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function normalizeFingerprint(value) {
+function normalizeTaskFindingFingerprint(value) {
   const normalized = normalizeKey(value);
   if (!normalized)
     throw new Error("finding fingerprint is required");
@@ -50676,7 +51071,7 @@ function assertTask(taskId, db) {
     throw new TaskNotFoundError(taskId);
 }
 function nextFinding(input, db) {
-  const fingerprint4 = normalizeFingerprint(input.fingerprint);
+  const fingerprint4 = normalizeTaskFindingFingerprint(input.fingerprint);
   const title = redactOptional(input.title, 300);
   if (!title)
     throw new Error("finding title is required");
@@ -50824,7 +51219,7 @@ function resolveMissingTaskFindings(input, db) {
   const timestamp3 = input.resolved_at || now();
   const status = normalizeResolutionStatus(input.status);
   const runId = resolveRunForTask(input.run_id, input.task_id, d);
-  const present = new Set(input.fingerprints.map(normalizeFingerprint));
+  const present = new Set(input.fingerprints.map(normalizeTaskFindingFingerprint));
   const warnings = [];
   const conditions = ["task_id = ?", "status = 'open'"];
   const params = [input.task_id];
@@ -51351,12 +51746,12 @@ init_artifact_store();
 
 // src/lib/doctor.ts
 init_database();
+import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync22, statSync as statSync12 } from "fs";
+import { basename as basename7, dirname as dirname18, join as join27 } from "path";
 init_migrations();
 init_schema();
 init_recurrence();
-import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync22, statSync as statSync12 } from "fs";
-import { basename as basename7, dirname as dirname18, join as join27 } from "path";
-var REQUIRED_TABLES2 = [
+var REQUIRED_TABLES3 = [
   "_migrations",
   "projects",
   "tasks",
@@ -51369,7 +51764,7 @@ var REQUIRED_TABLES2 = [
   "task_run_commands",
   "task_run_artifacts"
 ];
-function tableExists(db, table) {
+function tableExists2(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
 function quoteIdent(identifier) {
@@ -51453,7 +51848,7 @@ function findDuplicateIndexes(db) {
   return duplicates;
 }
 function findMissingProjectRoots(db) {
-  if (!tableExists(db, "projects"))
+  if (!tableExists2(db, "projects"))
     return 0;
   let missing = 0;
   const rows = db.query("SELECT path FROM projects WHERE path IS NOT NULL AND path != ''").all();
@@ -51468,7 +51863,7 @@ function findMissingProjectRoots(db) {
   return missing;
 }
 function addTaskStateChecks(db, checks) {
-  if (!tableExists(db, "tasks"))
+  if (!tableExists2(db, "tasks"))
     return;
   const columns = getTableColumns(db, "tasks");
   const staleCutoff = new Date(Date.now() - 30 * 60 * 1000).toISOString();
@@ -51540,15 +51935,42 @@ function createBackup(dbPath) {
 function pushRepair(repairs, type, message, applied, count3) {
   repairs.push({ type, message, applied, count: count3 });
 }
-function summarize3(checks, repairs) {
+function summarize3(checks, repairs, integrity) {
   return {
     errors: checks.filter((check) => check.severity === "error").length,
     warnings: checks.filter((check) => check.severity === "warn").length,
     infos: checks.filter((check) => check.severity === "info").length,
     repairable: checks.filter((check) => check.repairable).length,
-    applied: repairs.filter((repair) => repair.applied).length
+    applied: repairs.filter((repair) => repair.applied).length,
+    integrity_findings: integrity.summary.findings,
+    integrity_rows: integrity.summary.rows,
+    integrity_unverified: integrity.summary.unverified
   };
 }
+function addIntegrityChecks(integrity, checks) {
+  for (const condition of integrity.conditions) {
+    if (!condition.verified) {
+      addCheck(checks, {
+        severity: "warn",
+        type: `${condition.id}_unverified`,
+        message: condition.message,
+        repairable: false,
+        integrity: true
+      });
+      continue;
+    }
+    if ((condition.count ?? 0) === 0)
+      continue;
+    addCheck(checks, {
+      severity: condition.severity ?? "warn",
+      type: condition.id,
+      message: `${condition.message} \u2014 ${condition.impact}`,
+      count: condition.count ?? undefined,
+      repairable: false,
+      integrity: true
+    });
+  }
+}
 function deleteOrphans(db, table, where) {
   const before = countQuery2(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
   if (before > 0)
@@ -51577,7 +51999,7 @@ function runTodosDoctor(options = {}) {
       message: `Schema at migration ${migrationCurrent}`
     });
   }
-  const missingTables = REQUIRED_TABLES2.filter((table) => !tableExists(db, table));
+  const missingTables = REQUIRED_TABLES3.filter((table) => !tableExists2(db, table));
   if (missingTables.length > 0) {
     addCheck(checks, {
       severity: "error",
@@ -51587,7 +52009,7 @@ function runTodosDoctor(options = {}) {
       repairable: true
     });
   }
-  const orphanedParents = tableExists(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM tasks t WHERE t.parent_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks p WHERE p.id = t.parent_id)") : 0;
+  const orphanedParents = tableExists2(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM tasks t WHERE t.parent_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks p WHERE p.id = t.parent_id)") : 0;
   if (orphanedParents > 0) {
     addCheck(checks, {
       severity: "error",
@@ -51597,7 +52019,7 @@ function runTodosDoctor(options = {}) {
       repairable: true
     });
   }
-  const orphanedDependencies = tableExists(db, "task_dependencies") && tableExists(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM task_dependencies d WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.depends_on)") : 0;
+  const orphanedDependencies = tableExists2(db, "task_dependencies") && tableExists2(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM task_dependencies d WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.depends_on)") : 0;
   if (orphanedDependencies > 0) {
     addCheck(checks, {
       severity: "error",
@@ -51616,7 +52038,7 @@ function runTodosDoctor(options = {}) {
   ];
   let orphanedRows2 = 0;
   for (const [table, where] of orphanTables) {
-    if (!tableExists(db, table))
+    if (!tableExists2(db, table))
       continue;
     orphanedRows2 += countQuery2(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
   }
@@ -51630,6 +52052,8 @@ function runTodosDoctor(options = {}) {
     });
   }
   addTaskStateChecks(db, checks);
+  const integrity = scanSqliteIntegrity(db);
+  addIntegrityChecks(integrity, checks);
   const corruptJson = findCorruptJsonMetadata(db);
   if (corruptJson.length > 0) {
     addCheck(checks, {
@@ -51688,12 +52112,12 @@ function runTodosDoctor(options = {}) {
       db.run("UPDATE tasks SET parent_id = NULL WHERE parent_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks p WHERE p.id = tasks.parent_id)");
       pushRepair(repairs, "orphaned_task_parents", "Cleared missing parent references", true, orphanedParents);
     }
-    if (orphanedDependencies > 0 && tableExists(db, "task_dependencies")) {
+    if (orphanedDependencies > 0 && tableExists2(db, "task_dependencies")) {
       const count3 = deleteOrphans(db, "task_dependencies", "NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.depends_on)");
       pushRepair(repairs, "orphaned_task_dependencies", "Deleted dependency rows referencing missing tasks", true, count3);
     }
     for (const [table, where] of orphanTables) {
-      if (!tableExists(db, table))
+      if (!tableExists2(db, table))
         continue;
       const count3 = deleteOrphans(db, table, where);
       if (count3 > 0)
@@ -51722,16 +52146,19 @@ function runTodosDoctor(options = {}) {
       }
     }
   }
-  const finalChecks = apply && hasRepairableIssue ? runTodosDoctor({ db, dbPath, apply: false }).checks : checks;
-  const summary = summarize3(finalChecks, repairs);
+  const reread = apply && hasRepairableIssue ? runTodosDoctor({ db, dbPath, apply: false }) : undefined;
+  const finalChecks = reread?.checks ?? checks;
+  const finalIntegrity = reread?.integrity ?? integrity;
+  const summary = summarize3(finalChecks, repairs, finalIntegrity);
   return {
-    ok: !finalChecks.some((check) => check.severity === "error"),
+    ok: !finalChecks.some((check) => check.severity === "error") && finalIntegrity.summary.ok,
     dry_run: !apply,
     database_path: dbPath,
     migration: { current: getMigrationLevel(db), expected: migrationExpected },
     backup,
     checks: finalChecks,
     repairs,
+    integrity: finalIntegrity,
     summary
   };
 }
@@ -52277,6 +52704,7 @@ export {
   updateArtifactRedaction,
   updateAgentActivity,
   updateAgent,
+  unverifiedCondition,
   unsubscribeResource,
   unlockTask,
   unlinkTaskCommit,
@@ -52297,6 +52725,7 @@ export {
   summarizeTaskRun,
   summarizeRoadmap,
   summarizeMilestone,
+  summarizeIntegrity,
   suggestAgentNames,
   subscribeResource,
   storeArtifactContent,
@@ -52337,6 +52766,7 @@ export {
   scorePlanHealth,
   scheduleTask,
   scanTextForSecrets,
+  scanSqliteIntegrity,
   scanSourceForForbiddenWebPatterns,
   scanReminders,
   scanPreWriteText,
@@ -52384,6 +52814,7 @@ export {
   resolvePartialId,
   resolveMissingTaskFindings,
   resolveMentions,
+  resolveIntegritySeverity,
   resolveGitRoot,
   resolveCommandQuery,
   resolveAccessProfile,
@@ -52498,6 +52929,7 @@ export {
   patrolTasks,
   parseTmuxTarget,
   parseStorageMode,
+  parseStorageBackend,
   parseRecurrenceRule,
   parseQuietHours,
   parsePlanArtifactMarkdown,
@@ -52526,6 +52958,8 @@ export {
   migrationDryRun,
   migrateWorkflowStates,
   mergeDuplicateTask,
+  measuredCondition,
+  measureIntegrityRows,
   materializePlanSteps,
   matchCapabilities,
   looksSensitiveKey,
@@ -52644,12 +53078,14 @@ export {
   isWorktreePath,
   isValidRecurrenceRule,
   isTodosRemoteStorageEnabled,
+  isTodosPostgresBackend,
   isSnapshotStale,
   isEncryptedValue,
   isEncryptedBridgeBundle,
   isArtifactExpired,
   isAllowedLocalApiUrl,
   isAgentConflict,
+  integrityCondition,
   installTemplateLibrary,
   installLocalExtension,
   inspectPlanArtifact,
@@ -52692,6 +53128,7 @@ export {
   getTodosStorageEnvName,
   getTodosStorageDatabaseUrl,
   getTodosStorageDatabaseEnv,
+  getTodosStorageBackend,
   getTimeReport,
   getTimeLogs,
   getTerminalNotificationRule,
@@ -52899,6 +53336,7 @@ export {
   formatLockConflict,
   formatKnowledgeSnapshotMarkdown,
   formatIssueImportPreviewText,
+  formatIntegrityMessage,
   formatIntakePreviewText,
   formatHandoffPacket,
   formatGoalHandoff,
@@ -53129,16 +53567,19 @@ export {
   bulkAddTaskFiles,
   buildTaskDependencyEdges,
   buildTaskBoardSnapshot,
+  buildSqliteIntegritySql,
   buildS3ObjectUrl,
   buildS3ObjectKey,
   buildRunReplayBundle,
   buildResourceSnapshot,
   buildReportExportData,
   buildProjectDependencyGraph,
+  buildPostgresIntegritySql,
   buildPlanArtifactSnapshot,
   buildMcpToolGroups,
   buildMachineTopologyReport,
   buildKnowledgeSnapshotPayload,
+  buildIntegrityReport,
   buildHandoffPacket,
   buildFeatureManifest,
   buildFailureTriageReport,
@@ -53173,6 +53614,7 @@ export {
   appendRunCommand,
   analyzeDependencyGraph,
   agentClaimNextSafe,
+  adoptRemoteIntegrityReport,
   addTemplateTasks,
   addTaskRunFile,
   addTaskRunEvent,
@@ -53219,6 +53661,7 @@ export {
   TODOS_LOCAL_BACKUP_KIND,
   TODOS_JSON_CONTRACTS_MANIFEST,
   TODOS_JSON_CONTRACTS,
+  TODOS_INTEGRITY_SCHEMA_VERSION,
   TODOS_ERROR_CODES,
   TODOS_ENCRYPTION_SCHEMA_VERSION,
   TODOS_ENCRYPTED_VALUE_KIND,
@@ -53261,7 +53704,7 @@ export {
   REMINDER_STATUSES,
   RELEASE_CHECK_SCHEMA,
   RELATIONSHIP_TYPES,
-  REDACTION_PLACEHOLDER,
+  REDACTION_PLACEHOLDER2 as REDACTION_PLACEHOLDER,
   ProjectNotFoundError,
   PreWriteSecretError,
   PrGroupLedgerError,
@@ -53275,6 +53718,7 @@ export {
   PLAN_EXECUTION_SCHEMA,
   PLAN_EXECUTION_MODES,
   PARITY_SCHEMA_VERSION,
+  OPEN_TASK_STATUSES,
   NOTIFICATION_REMINDERS_SCHEMA,
   NL_INTAKE_SCHEMA,
   NESTED_SUBCOMMANDS,
@@ -53303,6 +53747,7 @@ export {
   JSON_OUTPUT_CONTRACT,
   ISSUE_SOURCES,
   ISSUE_IMPORT_SCHEMA,
+  INTEGRITY_CONDITIONS,
   INTAKE_TRIAGE_STATUSES,
   INTAKE_SOURCE_TYPES,
   INBOX_INTAKE_SCHEMA,