@hasna/todos 0.11.73 → 0.11.75

package/dist/cli/index.js

@@ -12874,6 +12874,7 @@ __export(exports_task_routing, {
   setTaskWorkflowPointers: () => setTaskWorkflowPointers,
   getTaskRouteState: () => getTaskRouteState
 });
+import { existsSync as existsSync8, statSync as statSync3 } from "fs";
 function machineLocalPath(project, db) {
   const machineId = process.env["TODOS_MACHINE_ID"];
   if (!machineId)
@@ -12911,7 +12912,33 @@ function routeConcurrencyKey(task, project, taskList, projectPath) {
     return `path:${projectPath}`;
   return `task:${task.id}`;
 }
-function getTaskRouteState(taskOrId, db) {
+function directoryExists(path) {
+  try {
+    return existsSync8(path) && statSync3(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function classifyRoute(input) {
+  if (input.terminal)
+    return "terminal";
+  if (input.notPending)
+    return "in_progress";
+  if (input.blocked)
+    return "blocked";
+  if (input.locked)
+    return "locked";
+  if (input.missingProjectRoot)
+    return "missing_metadata";
+  if (!input.eligible)
+    return "unroutable";
+  if (input.workflowPointerActive)
+    return "deduped_active";
+  if (input.workflowPointerTerminal)
+    return "terminal_requeue_needed";
+  return "eligible";
+}
+function getTaskRouteState(taskOrId, db, options = {}) {
   const d = db || getDatabase();
   const task = typeof taskOrId === "string" ? getTask(taskOrId, d) : taskOrId;
   if (!task)
@@ -12919,8 +12946,10 @@ function getTaskRouteState(taskOrId, db) {
   const { project, projectPath } = resolveProject(task, d);
   const taskList = resolveTaskList(task, project, d);
   const automation = routingAutomationMetadata(task, taskList) ?? {};
-  const routeEnabled = routeEnabledForTask(task, taskList) === true;
+  const explicitRouteEnabled = routeEnabledForTask(task, taskList);
   const tagOptIn = task.tags.includes("auto:route") || task.tags.includes("route:enabled");
+  const routeEnabled = explicitRouteEnabled === undefined ? tagOptIn : explicitRouteEnabled;
+  const tagNoAuto = task.tags.includes("no-auto") || task.tags.includes("noauto") || task.tags.includes("no:auto");
   const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
   const locked = Boolean(task.locked_by && !isLockExpired(task.locked_at));
   const blockers = getBlockingDeps(task.id, d);
@@ -12929,10 +12958,21 @@ function getTaskRouteState(taskOrId, db) {
   const requiresApproval = automation.requires_approval === true || task.requires_approval === true;
   const approvalRequired = automation.approval_required === true;
   const approved = Boolean(task.approved_by);
+  const pointers = workflowPointersFromMetadata(task.metadata);
+  const workflowState = (pointers.workflow_state ?? "").trim().toLowerCase();
+  const hasWorkflowPointer = Boolean(pointers.current_workflow_invocation_id || pointers.current_run_id || workflowState);
+  const workflowPointerTerminal = hasWorkflowPointer && TERMINAL_WORKFLOW_STATES.has(workflowState);
+  const workflowPointerActive = hasWorkflowPointer && !workflowPointerTerminal;
+  const verifyProjectRoot = options.verifyProjectRoot === true;
+  let projectRootExists = null;
+  if (verifyProjectRoot) {
+    projectRootExists = projectPath ? directoryExists(projectPath) : false;
+  }
+  const missingProjectRoot = verifyProjectRoot && projectRootExists !== true;
   const gates = {
     route_enabled: routeEnabled,
     tag_opt_in: tagOptIn,
-    no_auto: automation.no_auto === true,
+    no_auto: automation.no_auto === true || tagNoAuto,
     manual: automation.manual === true,
     manual_required: automation.manual_required === true,
     requires_approval: requiresApproval,
@@ -12940,7 +12980,10 @@ function getTaskRouteState(taskOrId, db) {
     approved,
     locked,
     blocked,
-    terminal
+    terminal,
+    missing_project_root: missingProjectRoot,
+    workflow_pointer_active: workflowPointerActive,
+    workflow_pointer_terminal: workflowPointerTerminal
   };
   const reasons = [];
   if (task.status !== "pending")
@@ -12965,12 +13008,44 @@ function getTaskRouteState(taskOrId, db) {
     reasons.push("approval_required");
   if (automation.allowed === false)
     reasons.push("automation_disallowed");
+  if (missingProjectRoot)
+    reasons.push("missing_project_root");
+  const eligible = reasons.length === 0;
+  const staleAfterMs = options.staleInProgressAfterMs ?? DEFAULT_STALE_IN_PROGRESS_MS;
+  const updatedAtMs = Date.parse(task.updated_at);
+  const ageMs = Number.isNaN(updatedAtMs) ? 0 : Math.max(0, Date.now() - updatedAtMs);
+  const evidence = {
+    owner: task.assigned_to ?? task.locked_by ?? null,
+    assigned_to: task.assigned_to ?? null,
+    locked_by: task.locked_by ?? null,
+    locked_at: task.locked_at ?? null,
+    updated_at: task.updated_at,
+    age_ms: ageMs,
+    stale: task.status === "in_progress" && ageMs > staleAfterMs,
+    stale_after_ms: staleAfterMs,
+    current_run_id: pointers.current_run_id ?? null,
+    current_workflow_invocation_id: pointers.current_workflow_invocation_id ?? null,
+    workflow_state: pointers.workflow_state ?? null,
+    project_root_verified: verifyProjectRoot,
+    project_root_exists: projectRootExists
+  };
+  const route_class = classifyRoute({
+    terminal,
+    notPending: task.status !== "pending",
+    blocked,
+    locked,
+    missingProjectRoot,
+    eligible,
+    workflowPointerActive,
+    workflowPointerTerminal
+  });
   return {
     schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
     task_id: task.id,
     task_short_id: task.short_id,
     status: task.status,
-    eligible: reasons.length === 0,
+    eligible,
+    route_class,
     reasons,
     blockers: blockers.map((blocker) => ({
       id: blocker.id,
@@ -12990,7 +13065,8 @@ function getTaskRouteState(taskOrId, db) {
       task_list_name: taskList?.name ?? null,
       concurrency_key: routeConcurrencyKey(task, project, taskList, projectPath)
     },
-    pointers: workflowPointersFromMetadata(task.metadata)
+    pointers,
+    evidence
   };
 }
 function setTaskWorkflowPointers(taskId, input, db) {
@@ -13036,12 +13112,28 @@ function pointerPatch(previous, input, key) {
     return previous;
   return typeof value === "string" && value.trim() ? value : undefined;
 }
+var DEFAULT_STALE_IN_PROGRESS_MS, TERMINAL_WORKFLOW_STATES;
 var init_task_routing = __esm(() => {
   init_database();
   init_projects();
   init_task_crud();
   init_task_lifecycle();
   init_task_lists();
+  DEFAULT_STALE_IN_PROGRESS_MS = 3 * 24 * 60 * 60 * 1000;
+  TERMINAL_WORKFLOW_STATES = new Set([
+    "failed",
+    "cancelled",
+    "canceled",
+    "completed",
+    "complete",
+    "done",
+    "error",
+    "errored",
+    "timeout",
+    "timed_out",
+    "aborted",
+    "superseded"
+  ]);
 });
 
 // src/cli/commands/task-commands.ts
@@ -13185,6 +13277,19 @@ function buildExpectationMetadata(opts) {
     metadata["acceptance"] = parseJsonValue(String(acceptance));
   return metadata;
 }
+function resolveTaskListRef(ref, projectId) {
+  const db = getDatabase();
+  const exact = getTaskList(ref, db);
+  if (exact)
+    return { id: exact.id };
+  const partial = resolvePartialId(db, "task_lists", ref);
+  if (partial)
+    return { id: partial };
+  const bySlug = getTaskListBySlug(ref, projectId ?? undefined, db);
+  if (bySlug)
+    return { id: bySlug.id };
+  return { error: `Could not resolve task list "${ref}" to a UUID${projectId ? " within the task's project" : ""}. Pass an exact task-list UUID.` };
+}
 function registerTaskCommands(program2) {
   program2.command("add <title>").description("Create a new task").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("--parent <id>", "Parent task ID").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--plan <id>", "Assign to a plan").option("--assign <agent>", "Assign to agent").option("--status <status>", "Initial status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("--estimated <minutes>", "Estimated time in minutes").option("--sla-minutes <minutes>", "SLA minutes before unfinished work is escalated").option("--sla <minutes>", "Alias for --sla-minutes").option("--approval", "Require approval before completion").option("--recurrence <rule>", "Recurrence rule, e.g. 'every day', 'every weekday', 'every 2 weeks'").option("--due <date>", "Due date (ISO string or YYYY-MM-DD)").option("--reason <text>", "Why this task exists").option("--project <id>", "Assign to project by ID or slug (overrides auto-detect)").action((title, opts) => {
     const globalOpts = program2.opts();
@@ -13277,13 +13382,13 @@ function registerTaskCommands(program2) {
       console.log(formatTaskLine(result.task));
     }
   });
-  task.command("route-state <id>").description("Show deterministic routing eligibility and workflow pointers for a task").action(async (id) => {
+  task.command("route-state <id>").description("Show deterministic routing eligibility and workflow pointers for a task").option("--verify-project-root", "Filesystem-check the resolved project root and surface missing_project_root before admission").action(async (id, opts) => {
     const globalOpts = program2.opts();
     const resolvedId = resolveTaskId(id);
     const { getTaskRouteState: getTaskRouteState2 } = await Promise.resolve().then(() => (init_task_routing(), exports_task_routing));
     let state;
     try {
-      state = getTaskRouteState2(resolvedId);
+      state = getTaskRouteState2(resolvedId, undefined, { verifyProjectRoot: Boolean(opts.verifyProjectRoot) });
     } catch (e) {
       handleError(e);
     }
@@ -13294,8 +13399,12 @@ function registerTaskCommands(program2) {
     console.log(chalk2.bold("Task route state"));
     console.log(`  ${chalk2.dim("Task:")}       ${state.task_short_id || state.task_id.slice(0, 8)}`);
     console.log(`  ${chalk2.dim("Eligible:")}   ${state.eligible ? chalk2.green("yes") : chalk2.yellow("no")}`);
+    console.log(`  ${chalk2.dim("Class:")}      ${state.route_class}`);
     console.log(`  ${chalk2.dim("Reasons:")}    ${state.reasons.length > 0 ? state.reasons.join(", ") : "none"}`);
     console.log(`  ${chalk2.dim("Route:")}      ${state.route.concurrency_key}`);
+    if (state.evidence.owner) {
+      console.log(`  ${chalk2.dim("Owner:")}      ${state.evidence.owner}${state.evidence.stale ? chalk2.yellow(" (stale)") : ""}`);
+    }
     if (state.pointers.current_workflow_invocation_id) {
       console.log(`  ${chalk2.dim("Invocation:")} ${state.pointers.current_workflow_invocation_id}`);
     }
@@ -13734,7 +13843,7 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.log(`  ${chalk2.dim(h.created_at)} ${chalk2.bold(h.action)}${field}${change}${agent}`);
     }
   });
-  program2.command("update <id>").description("Update a task").option("--title <text>", "New title").option("-d, --description <text>", "New description").option("-s, --status <status>", "New status").option("-p, --priority <priority>", "New priority").option("--assign <agent>", "Assign to agent").option("--tags <tags>", "New tags (comma-separated)").option("--tag <tags>", "New tags (alias for --tags)").option("--list <id>", "Move to a task list").option("--task-list <id>", "Move to a task list (alias for --list)").option("--plan <id>", "Move to a plan").option("--clear-plan", "Remove from its current plan").option("--estimated <minutes>", "Estimated time in minutes").option("--sla-minutes <minutes>", "SLA minutes before unfinished work is escalated").option("--sla <minutes>", "Alias for --sla-minutes").option("--due <date>", "Due date (ISO string or YYYY-MM-DD), empty to clear").option("--recurrence <rule>", "Recurrence rule, empty to clear").option("--approval", "Require approval before completion").option("--clear-approval", "Remove the approval requirement").action((id, opts) => {
+  program2.command("update <id>").description("Update a task").option("--title <text>", "New title").option("-d, --description <text>", "New description").option("-s, --status <status>", "New status").option("-p, --priority <priority>", "New priority").option("--assign <agent>", "Assign to agent").option("--tags <tags>", "New tags (comma-separated)").option("--tag <tags>", "New tags (alias for --tags)").option("--list <id>", "Move to a task list (UUID authoritative; project-scoped slug accepted)").option("--task-list <id>", "Move to a task list (alias for --list)").option("--clear-list", "Detach from its task list (reset task_list_id to null)").option("--working-dir <path>", "Repair the task's working_dir to a specific path (routing metadata)").option("--clear-working-dir", "Reset the task's working_dir to null (undo path for routing repairs)").option("--plan <id>", "Move to a plan").option("--clear-plan", "Remove from its current plan").option("--estimated <minutes>", "Estimated time in minutes").option("--sla-minutes <minutes>", "SLA minutes before unfinished work is escalated").option("--sla <minutes>", "Alias for --sla-minutes").option("--due <date>", "Due date (ISO string or YYYY-MM-DD), empty to clear").option("--recurrence <rule>", "Recurrence rule, empty to clear").option("--approval", "Require approval before completion").option("--clear-approval", "Remove the approval requirement").action((id, opts) => {
     const globalOpts = program2.opts();
     opts.tags = opts.tags || opts.tag;
     opts.list = opts.list || opts.taskList;
@@ -13752,15 +13861,22 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.error(chalk2.red("Use either --approval or --clear-approval, not both."));
       process.exit(1);
     }
+    if (opts.list && opts.clearList) {
+      console.error(chalk2.red("Use either --list or --clear-list, not both."));
+      process.exit(1);
+    }
+    if (opts.workingDir !== undefined && opts.clearWorkingDir) {
+      console.error(chalk2.red("Use either --working-dir or --clear-working-dir, not both."));
+      process.exit(1);
+    }
     const taskListId = opts.list ? (() => {
-      const db = getDatabase();
-      const resolved = resolvePartialId(db, "task_lists", opts.list);
-      if (!resolved) {
-        console.error(chalk2.red(`Could not resolve task list ID: ${opts.list}`));
+      const resolved = resolveTaskListRef(opts.list, current.project_id);
+      if ("error" in resolved) {
+        console.error(chalk2.red(resolved.error));
         process.exit(1);
       }
-      return resolved;
-    })() : undefined;
+      return resolved.id;
+    })() : opts.clearList ? null : undefined;
     const planId = opts.plan ? resolvePlanId(opts.plan) : opts.clearPlan ? null : undefined;
     let task2;
     try {
@@ -13774,6 +13890,7 @@ ${chalk2.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
         tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : undefined,
         plan_id: planId,
         task_list_id: taskListId,
+        working_dir: opts.workingDir ? resolve9(opts.workingDir) : opts.clearWorkingDir ? null : undefined,
         estimated_minutes: opts.estimated !== undefined ? parseIntOption(opts.estimated, "--estimated") : undefined,
         sla_minutes: opts.slaMinutes !== undefined || opts.sla !== undefined ? parseIntOption(opts.slaMinutes ?? opts.sla, "--sla-minutes") : undefined,
         due_at: opts.due !== undefined ? opts.due === "" ? null : opts.due.length === 10 ? opts.due + "T00:00:00.000Z" : opts.due : undefined,
@@ -13973,12 +14090,13 @@ var init_task_commands = __esm(() => {
   init_database();
   init_projects();
   init_tasks();
+  init_task_lists();
   init_helpers();
   init_types();
 });
 
 // src/lib/plan-artifacts.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7, resolve as resolve10 } from "path";
 function assertSafePathSegment(value, label) {
   const trimmed = value.trim();
@@ -14214,7 +14332,7 @@ function readPlanArtifact(plan, db) {
     return null;
   const d = db || getDatabase();
   const paths = resolvePlanArtifactCandidatePaths(plan, d);
-  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  const path = existsSync9(paths.primary.file_path) ? paths.primary.file_path : existsSync9(paths.legacy.file_path) ? paths.legacy.file_path : null;
   if (!path)
     return null;
   const markdown = readFileSync4(path, "utf8");
@@ -14229,7 +14347,7 @@ function inspectPlanArtifact(plan, db) {
     return null;
   const d = db || getDatabase();
   const paths = resolvePlanArtifactCandidatePaths(plan, d);
-  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  const path = existsSync9(paths.primary.file_path) ? paths.primary.file_path : existsSync9(paths.legacy.file_path) ? paths.legacy.file_path : null;
   if (!path) {
     return {
       path: paths.primary.file_path,
@@ -15705,7 +15823,7 @@ var init_saved_search_views = __esm(() => {
 });
 
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
 import { join as join9 } from "path";
 function getTaskListDir(taskListId) {
   return join9(HOME, ".claude", "tasks", taskListId);
@@ -15727,7 +15845,7 @@ function toSqliteStatus(status) {
 }
 function readPrefixCounter(dir) {
   const path = join9(dir, ".prefix-counter");
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return 0;
   const val = parseInt(readFileSync5(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
@@ -15760,7 +15878,7 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -15856,7 +15974,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync9(dir)) {
+  if (!existsSync10(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync2(dir).filter((f) => f.endsWith(".json"));
@@ -15949,7 +16067,7 @@ var init_claude_tasks = __esm(() => {
 });
 
 // src/lib/agent-tasks.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { join as join10 } from "path";
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
@@ -15987,7 +16105,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -16070,7 +16188,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -16242,11 +16360,11 @@ __export(exports_project_bootstrap, {
   discoverProjectWorkspace: () => discoverProjectWorkspace,
   bootstrapProject: () => bootstrapProject
 });
-import { existsSync as existsSync11, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
 import { basename as basename4, dirname as dirname6, resolve as resolve11 } from "path";
 function safeStat(path) {
   try {
-    return statSync3(path);
+    return statSync4(path);
   } catch {
     return null;
   }
@@ -16261,7 +16379,7 @@ function canonicalPath(input) {
 function findUp(start, marker) {
   let current = canonicalPath(start);
   while (true) {
-    if (existsSync11(resolve11(current, marker)))
+    if (existsSync12(resolve11(current, marker)))
       return current;
     const parent = dirname6(current);
     if (parent === current)
@@ -16273,7 +16391,7 @@ function readPackageJson(path) {
   if (!path)
     return null;
   const file = resolve11(path, "package.json");
-  if (!existsSync11(file))
+  if (!existsSync12(file))
     return null;
   try {
     const parsed = JSON.parse(readFileSync6(file, "utf-8"));
@@ -16295,7 +16413,7 @@ function workspaceMarker(root, rootPackage) {
   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 (existsSync11(resolve11(root, marker)))
+    if (existsSync12(resolve11(root, marker)))
       markers.push(marker);
   }
   const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
@@ -21818,7 +21936,7 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync12, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
 import { createHash as createHash3 } from "crypto";
 import { relative as relative3, resolve as resolve12, join as join11 } from "path";
 function stableHash(value) {
@@ -21828,9 +21946,9 @@ function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readGitignorePatterns(basePath) {
-  const root = statSync4(basePath).isFile() ? resolve12(basePath, "..") : basePath;
+  const root = statSync5(basePath).isFile() ? resolve12(basePath, "..") : basePath;
   const gitignorePath = join11(root, ".gitignore");
-  if (!existsSync12(gitignorePath))
+  if (!existsSync13(gitignorePath))
     return [];
   try {
     return readFileSync7(gitignorePath, "utf-8").split(`
@@ -21939,7 +22057,7 @@ function extractFromSource(source, filePath, tags = [...EXTRACT_TAGS]) {
   return results;
 }
 function collectFiles(basePath, extensions, excludes, respectGitignore) {
-  const stat = statSync4(basePath);
+  const stat = statSync5(basePath);
   if (stat.isFile()) {
     return [basePath];
   }
@@ -21972,10 +22090,10 @@ function buildCodebaseIndex(options) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const indexed = [];
   for (const file of files) {
-    const fullPath = statSync4(basePath).isFile() ? basePath : join11(basePath, file);
+    const fullPath = statSync5(basePath).isFile() ? basePath : join11(basePath, file);
     try {
       const source = readFileSync7(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
+      const relPath = statSync5(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
         checksum: stableHash(source).slice(0, 24),
@@ -22003,10 +22121,10 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync4(basePath).isFile() ? basePath : join11(basePath, file);
+    const fullPath = statSync5(basePath).isFile() ? basePath : join11(basePath, file);
     try {
       const source = readFileSync7(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
+      const relPath = statSync5(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source, relPath, tags);
       allComments.push(...comments);
     } catch {}
@@ -25133,7 +25251,7 @@ __export(exports_retention_cleanup, {
   applyRetentionCleanup: () => applyRetentionCleanup,
   RETENTION_CLEANUP_CONFIRMATION: () => RETENTION_CLEANUP_CONFIRMATION
 });
-import { existsSync as existsSync13, unlinkSync } from "fs";
+import { existsSync as existsSync14, unlinkSync } from "fs";
 function normalizeScopes(scopes) {
   if (!scopes || scopes.length === 0)
     return [...ALL_SCOPES];
@@ -25336,7 +25454,7 @@ function applyRetentionCleanup(input, db) {
   for (const artifact of report.candidates.artifact_files) {
     try {
       const path = artifactStorePath(artifact.relative_path);
-      if (!existsSync13(path)) {
+      if (!existsSync14(path)) {
         report.warnings.push(`stored artifact already missing: ${artifact.relative_path}`);
         continue;
       }
@@ -26012,7 +26130,7 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash5, createVerify } from "crypto";
-import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
 import { basename as basename6, join as join12, resolve as resolve14 } from "path";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -26272,10 +26390,10 @@ function verifyExtensionSignature(input) {
 }
 function inspectExtensionSource(source2) {
   const resolved = resolve14(source2);
-  if (!existsSync14(resolved))
+  if (!existsSync15(resolved))
     throw new Error(`extension source not found: ${source2}`);
-  const stat = statSync5(resolved);
-  const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync14) : resolved;
+  const stat = statSync6(resolved);
+  const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync15) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source2} is missing todos.extension.json`);
   const raw = readFileSync8(manifestPath);
@@ -26375,16 +26493,16 @@ function projectExtensionSources(projectPath) {
     join12(root, ".todos", "todos.extension.json")
   ];
   const extensionDir = join12(root, ".todos", "extensions");
-  if (existsSync14(extensionDir)) {
+  if (existsSync15(extensionDir)) {
     for (const entry of readdirSync3(extensionDir)) {
       if (entry.startsWith("."))
         continue;
       const full = join12(extensionDir, entry);
-      if (statSync5(full).isDirectory() || entry.endsWith(".json"))
+      if (statSync6(full).isDirectory() || entry.endsWith(".json"))
         candidates.push(full);
     }
   }
-  return candidates.filter(existsSync14);
+  return candidates.filter(existsSync15);
 }
 function discoverLocalExtensions(options = {}) {
   const config = loadConfig();
@@ -27684,7 +27802,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync, copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync7, statSync as statSync6 } from "fs";
+import { chmodSync, copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync7, statSync as statSync7 } from "fs";
 import { basename as basename7, dirname as dirname7, join as join13 } from "path";
 function tableExists(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
@@ -27779,7 +27897,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync15(row.path))
+    if (!existsSync16(row.path))
       missing++;
   }
   return missing;
@@ -27831,7 +27949,7 @@ function databasePermissionsAreUnsafe(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return false;
   try {
-    return (statSync6(dbPath).mode & 63) !== 0;
+    return (statSync7(dbPath).mode & 63) !== 0;
   } catch {
     return false;
   }
@@ -27839,14 +27957,14 @@ function databasePermissionsAreUnsafe(dbPath) {
 function createBackup(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return;
-  if (!existsSync15(dbPath))
+  if (!existsSync16(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
   const backupDir = join13(dirname7(dbPath), `${basename7(dbPath)}.backup-${stamp}`);
   const files = [];
   mkdirSync7(backupDir, { recursive: true });
   for (const source2 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync15(source2))
+    if (!existsSync16(source2))
       continue;
     const target = join13(backupDir, basename7(source2));
     copyFileSync(source2, target);
@@ -33872,7 +33990,7 @@ var exports_mention_resolver = {};
 __export(exports_mention_resolver, {
   resolveMentions: () => resolveMentions
 });
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync7 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync8 } from "fs";
 import { basename as basename8, isAbsolute, join as join15, relative as relative5, resolve as resolve17, sep as sep3 } from "path";
 function blankResolution(parsed) {
   return {
@@ -33971,11 +34089,11 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   resolution.path = relPath;
-  if (!existsSync16(absolutePath)) {
+  if (!existsSync17(absolutePath)) {
     resolution.warnings.push("file does not exist in the local workspace");
     return resolution;
   }
-  const stats = statSync7(absolutePath);
+  const stats = statSync8(absolutePath);
   if (!stats.isFile()) {
     resolution.warnings.push("path exists but is not a file");
     return resolution;
@@ -34013,7 +34131,7 @@ function walkSourceFiles(root, current = root, files = []) {
     if (!entry.isFile())
       continue;
     const extension = `.${basename8(entry.name).split(".").pop() || ""}`;
-    if (SOURCE_EXTENSIONS.has(extension) && statSync7(absolutePath).size <= 512 * 1024) {
+    if (SOURCE_EXTENSIONS.has(extension) && statSync8(absolutePath).size <= 512 * 1024) {
       files.push(absolutePath);
     }
   }
@@ -42461,7 +42579,7 @@ __export(exports_verification_providers, {
   getVerificationRecord: () => getVerificationRecord,
   discoverVerificationProviderCapabilities: () => discoverVerificationProviderCapabilities
 });
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
 function normalizeName6(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -42613,7 +42731,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync17(input.log_path) ? readFileSync11(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync18(input.log_path) ? readFileSync11(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -42625,7 +42743,7 @@ function runBrowserProvider(input) {
   if (!input.artifact_path) {
     return { status: "unknown", attempts: 1, exit_code: null, output_summary: "browser provider needs a screenshot or artifact path" };
   }
-  if (!existsSync17(input.artifact_path)) {
+  if (!existsSync18(input.artifact_path)) {
     return { status: "failed", attempts: 1, exit_code: null, output_summary: `artifact not found: ${input.artifact_path}` };
   }
   return {
@@ -51716,7 +51834,7 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash12 } from "crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync14, statSync as statSync8 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync14, statSync as statSync9 } from "fs";
 import { hostname as hostname2, platform, arch } from "os";
 import { dirname as dirname9, join as join18, resolve as resolve20 } from "path";
 import { tmpdir as tmpdir3 } from "os";
@@ -51725,9 +51843,9 @@ function sha2566(value) {
 }
 function fileRecord(root, relativePath) {
   const path = join18(root, relativePath);
-  if (!existsSync18(path))
+  if (!existsSync19(path))
     return null;
-  const stat = statSync8(path);
+  const stat = statSync9(path);
   if (!stat.isFile())
     return null;
   const content = readFileSync14(path);
@@ -52428,7 +52546,7 @@ __export(exports_serve, {
   SECURITY_HEADERS: () => SECURITY_HEADERS,
   MIME_TYPES: () => MIME_TYPES
 });
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join19, dirname as dirname10, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
@@ -52445,7 +52563,7 @@ function resolveDashboardDir() {
   }
   candidates.push(join19(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync19(candidate))
+    if (existsSync20(candidate))
       return candidate;
   }
   return join19(process.cwd(), "dashboard", "dist");
@@ -52507,7 +52625,7 @@ function json(data, status = 200, headers) {
   });
 }
 function serveStaticFile(filePath) {
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -52588,7 +52706,7 @@ data: ${data}
       filteredSseClients.delete(client);
   }
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync19(dashboardDir);
+  const dashboardExists = existsSync20(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -54421,7 +54539,7 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk6 from "chalk";
-import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname11, join as join20 } from "path";
 function registerConfigServeCommands(program2) {
   program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
@@ -54463,7 +54581,7 @@ function registerConfigServeCommands(program2) {
       }
       obj[keys[keys.length - 1]] = parsedValue;
       const dir = dirname11(configPath);
-      if (!existsSync20(dir))
+      if (!existsSync21(dir))
         mkdirSync10(dir, { recursive: true });
       writeFileSync8(configPath, JSON.stringify(config2, null, 2));
       if (globalOpts.json) {
@@ -55495,6 +55613,523 @@ var init_config_serve_commands = __esm(() => {
   init_helpers();
 });
 
+// src/lib/routing-doctor.ts
+var exports_routing_doctor = {};
+__export(exports_routing_doctor, {
+  runRoutingDoctor: () => runRoutingDoctor,
+  routingShardOf: () => routingShardOf,
+  routingRepairUndoCommand: () => routingRepairUndoCommand,
+  detectCrossRepoIntent: () => detectCrossRepoIntent,
+  classifyTaskRouting: () => classifyTaskRouting,
+  TODOS_ROUTING_DOCTOR_SCHEMA_VERSION: () => TODOS_ROUTING_DOCTOR_SCHEMA_VERSION
+});
+import { copyFileSync as copyFileSync2, existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename9, dirname as dirname12, join as join21 } from "path";
+function normalizePath5(path) {
+  if (!path)
+    return null;
+  const trimmed = path.replace(/\/+$/, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function looksLikeRemoteUri(path) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(path);
+}
+function looksLikeLocalAbsolutePath(path) {
+  return path.startsWith("/") && !looksLikeRemoteUri(path);
+}
+function looksLikeMacHomePath(path) {
+  return /^\/Users\//.test(path);
+}
+function stableHash2(key) {
+  let hash2 = 2166136261;
+  for (let i = 0;i < key.length; i++) {
+    hash2 ^= key.charCodeAt(i);
+    hash2 = Math.imul(hash2, 16777619);
+  }
+  return hash2 >>> 0;
+}
+function routingShardOf(task2, total) {
+  if (total <= 1)
+    return 0;
+  const key = task2.project_id ?? task2.id;
+  return stableHash2(key) % total;
+}
+function repoSlugForProject(project) {
+  const fromPath = project.path && looksLikeLocalAbsolutePath(project.path) ? basename9(normalizePath5(project.path) ?? "") : "";
+  if (fromPath)
+    return fromPath.toLowerCase();
+  return project.name.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function detectCrossRepoIntent(task2, project, knownRepoSlugs) {
+  if (!project)
+    return null;
+  const ownSlug = repoSlugForProject(project);
+  const named = new Set;
+  for (const match of task2.title.matchAll(REPO_NAME_RE))
+    named.add(match[0].toLowerCase());
+  for (const tag of task2.tags) {
+    const m = /^repo:(.+)$/i.exec(tag);
+    if (m && m[1])
+      named.add(m[1].trim().toLowerCase());
+  }
+  if (named.size === 0)
+    return null;
+  if (named.has(ownSlug))
+    return null;
+  for (const candidate of named) {
+    if (candidate !== ownSlug && knownRepoSlugs.has(candidate))
+      return candidate;
+  }
+  return null;
+}
+function bump(map, key) {
+  map[key] = (map[key] ?? 0) + 1;
+}
+function resolveCanonicalTaskList(project, db) {
+  if (!project?.task_list_id)
+    return null;
+  return getTaskList(project.task_list_id, db) ?? getTaskListBySlug(project.task_list_id, project.id, db);
+}
+function taskListState(task2, project, db) {
+  if (!task2.task_list_id)
+    return "null";
+  const resolved = getTaskList(task2.task_list_id, db) ?? (project ? getTaskListBySlug(task2.task_list_id, project.id, db) : null);
+  return resolved ? "ok" : "unresolvable";
+}
+function classifyTaskRouting(ctx) {
+  return evaluateTaskRouting(ctx).findings;
+}
+function evaluateTaskRouting(ctx) {
+  const { task: task2, project, db, knownRepoSlugs, verifyProjectRoot } = ctx;
+  const rs = getTaskRouteState(task2, db, { verifyProjectRoot });
+  const findings = [];
+  const projectPath = normalizePath5(rs.route.project_path);
+  const workingDir = task2.working_dir ? normalizePath5(task2.working_dir) : null;
+  const projectRootExists = rs.evidence.project_root_exists;
+  const routeOptIn = rs.gates.tag_opt_in || rs.gates.route_enabled;
+  const crossRepoForeign = detectCrossRepoIntent(task2, project, knownRepoSlugs);
+  const base = {
+    task_id: task2.id,
+    task_short_id: task2.short_id,
+    title: task2.title,
+    status: task2.status,
+    project_id: rs.route.project_id,
+    project_name: project?.name ?? null,
+    project_path: rs.route.project_path,
+    working_dir: task2.working_dir,
+    task_list_id: task2.task_list_id,
+    route_eligible: rs.eligible,
+    route_class: rs.route_class,
+    route_reasons: rs.reasons
+  };
+  const listState = taskListState(task2, project, db);
+  const pathIsLocal = projectPath ? looksLikeLocalAbsolutePath(projectPath) : false;
+  const pathInvalidOnMachine = verifyProjectRoot && pathIsLocal && projectRootExists === false;
+  const projectMissingPath = project !== null && (!projectPath || pathIsLocal === false && !looksLikeRemoteUri(projectPath ?? ""));
+  if (!project && !task2.project_id) {
+    if (routeOptIn && !workingDir) {
+      findings.push({
+        ...base,
+        category: "missing_project",
+        severity: "warn",
+        repair_class: "unsupported",
+        expected_working_dir: null,
+        task_list_state: listState,
+        detail: "Route-opted-in task has no project and no working_dir; cannot derive an owning repo path.",
+        suggested_repair: null
+      });
+    }
+  } else if (pathInvalidOnMachine || projectMissingPath) {
+    const macHome = projectPath ? looksLikeMacHomePath(projectPath) : false;
+    findings.push({
+      ...base,
+      category: "invalid_project_path",
+      severity: "warn",
+      repair_class: "blocker_invalid_path",
+      expected_working_dir: null,
+      task_list_state: listState,
+      detail: projectMissingPath ? "Owning project has no usable local/remote path." : `Owning project path does not exist on this machine${macHome ? " (macOS home path \u2014 likely valid on its home Mac)" : ""}. Reported, not rewritten.`,
+      suggested_repair: null
+    });
+  }
+  const haveGoodProjectPath = Boolean(projectPath && pathIsLocal && projectRootExists === true);
+  if (project && projectPath) {
+    if (!workingDir) {
+      if (crossRepoForeign) {
+        findings.push({
+          ...base,
+          category: "null_working_dir",
+          severity: "warn",
+          repair_class: "blocker_cross_repo",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: `working_dir is empty and title names a different repo (${crossRepoForeign}); resolve project ownership before setting a path.`,
+          suggested_repair: null
+        });
+      } else if (haveGoodProjectPath) {
+        findings.push({
+          ...base,
+          category: "null_working_dir",
+          severity: "error",
+          repair_class: "safe_auto",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: "working_dir is empty; set it to the owning project path.",
+          suggested_repair: {
+            field: "working_dir",
+            from: null,
+            to: rs.route.project_path,
+            command: `todos update ${task2.id} --working-dir ${rs.route.project_path}`
+          }
+        });
+      } else if (pathInvalidOnMachine) {
+        findings.push({
+          ...base,
+          category: "null_working_dir",
+          severity: "warn",
+          repair_class: "blocker_invalid_path",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: "working_dir is empty but the owning project path is not present on this machine; cannot safely set it here.",
+          suggested_repair: null
+        });
+      }
+    } else if (!isWorktreePath(task2.working_dir) && workingDir !== projectPath) {
+      if (crossRepoForeign) {
+        findings.push({
+          ...base,
+          category: "wrong_working_dir",
+          severity: "warn",
+          repair_class: "blocker_cross_repo",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: `working_dir (${task2.working_dir}) differs from the owning project and the title names a different repo (${crossRepoForeign}); resolve ownership first.`,
+          suggested_repair: null
+        });
+      } else if (haveGoodProjectPath) {
+        findings.push({
+          ...base,
+          category: "wrong_working_dir",
+          severity: "error",
+          repair_class: "safe_auto",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: `working_dir (${task2.working_dir}) does not match the owning project path; repoint it.`,
+          suggested_repair: {
+            field: "working_dir",
+            from: task2.working_dir,
+            to: rs.route.project_path,
+            command: `todos update ${task2.id} --working-dir ${rs.route.project_path}`
+          }
+        });
+      } else if (pathInvalidOnMachine) {
+        findings.push({
+          ...base,
+          category: "wrong_working_dir",
+          severity: "warn",
+          repair_class: "blocker_invalid_path",
+          expected_working_dir: rs.route.project_path,
+          task_list_state: listState,
+          detail: `working_dir (${task2.working_dir}) differs from the owning project, but that project path is absent on this machine; reported, not rewritten.`,
+          suggested_repair: null
+        });
+      }
+    }
+  }
+  if (listState === "null") {
+    const canonical = resolveCanonicalTaskList(project, db);
+    if (canonical) {
+      findings.push({
+        ...base,
+        category: "null_task_list_id",
+        severity: "error",
+        repair_class: "safe_auto",
+        expected_working_dir: rs.route.project_path,
+        task_list_state: listState,
+        detail: `task_list_id is null; link to the owning project's task list (${canonical.slug ?? canonical.id}) by UUID.`,
+        suggested_repair: {
+          field: "task_list_id",
+          from: null,
+          to: canonical.id,
+          command: `todos update ${task2.id} --list ${canonical.id}`
+        }
+      });
+    } else if (project) {
+      findings.push({
+        ...base,
+        category: "null_task_list_id",
+        severity: "warn",
+        repair_class: "unsupported",
+        expected_working_dir: rs.route.project_path,
+        task_list_state: listState,
+        detail: `task_list_id is null and the owning project has no resolvable task list${project.task_list_id ? ` (slug ${project.task_list_id} resolves to no row)` : ""}; create the list before linking.`,
+        suggested_repair: null
+      });
+    }
+  } else if (listState === "unresolvable") {
+    const canonical = resolveCanonicalTaskList(project, db);
+    if (canonical && canonical.id !== task2.task_list_id) {
+      findings.push({
+        ...base,
+        category: "unresolvable_task_list",
+        severity: "error",
+        repair_class: "safe_auto",
+        expected_working_dir: rs.route.project_path,
+        task_list_state: listState,
+        detail: `task_list_id (${task2.task_list_id}) resolves to no task list; relink to the owning project's list (${canonical.slug ?? canonical.id}) by UUID.`,
+        suggested_repair: {
+          field: "task_list_id",
+          from: task2.task_list_id,
+          to: canonical.id,
+          command: `todos update ${task2.id} --list ${canonical.id}`
+        }
+      });
+    } else {
+      findings.push({
+        ...base,
+        category: "unresolvable_task_list",
+        severity: "warn",
+        repair_class: "blocker_human",
+        expected_working_dir: rs.route.project_path,
+        task_list_state: listState,
+        detail: `task_list_id (${task2.task_list_id}) resolves to no task list and no canonical project list is available to relink to; reported without guessing.`,
+        suggested_repair: null
+      });
+    }
+  }
+  if (rs.gates.tag_opt_in && rs.gates.no_auto) {
+    findings.push({
+      ...base,
+      category: "no_auto_conflict",
+      severity: "warn",
+      repair_class: "blocker_human",
+      expected_working_dir: rs.route.project_path,
+      task_list_state: listState,
+      detail: "Task carries both an auto:route/route:enabled tag and a no-auto deny signal; a triage decision is required (doctor does not guess).",
+      suggested_repair: null
+    });
+  }
+  if (rs.gates.tag_opt_in && !rs.eligible && rs.reasons.includes("route_not_enabled")) {
+    findings.push({
+      ...base,
+      category: "route_not_enabled",
+      severity: "warn",
+      repair_class: "blocker_human",
+      expected_working_dir: rs.route.project_path,
+      task_list_state: listState,
+      detail: "Task is tag-opted-in to routing but an explicit route_enabled:false denies it; reconcile the contradiction (doctor does not override an explicit deny).",
+      suggested_repair: null
+    });
+  }
+  return { findings, eligible: rs.eligible };
+}
+function createBackup2(dbPath, generatedAt) {
+  if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
+    return;
+  if (!existsSync22(dbPath))
+    return;
+  const stamp = generatedAt.replace(/[:.]/g, "-");
+  const backupDir = join21(dirname12(dbPath), `${basename9(dbPath)}.routing-doctor-backup-${stamp}`);
+  const files = [];
+  mkdirSync11(backupDir, { recursive: true });
+  for (const source3 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (!existsSync22(source3))
+      continue;
+    const target = join21(backupDir, basename9(source3));
+    copyFileSync2(source3, target);
+    files.push(target);
+  }
+  return files.length > 0 ? { path: backupDir, files } : undefined;
+}
+function routingRepairUndoCommand(repair) {
+  if (repair.field === "working_dir") {
+    return repair.from === null ? `todos update ${repair.task_id} --clear-working-dir` : `todos update ${repair.task_id} --working-dir ${repair.from}`;
+  }
+  return repair.from === null ? `todos update ${repair.task_id} --clear-list` : `todos update ${repair.task_id} --list ${repair.from}`;
+}
+function applySafeRepair(finding2, actor, generatedAt, db) {
+  const repair = finding2.suggested_repair;
+  const record = {
+    task_id: finding2.task_id,
+    task_short_id: finding2.task_short_id,
+    category: finding2.category,
+    field: repair.field,
+    from: repair.from,
+    to: repair.to,
+    command: repair.command,
+    applied: false
+  };
+  try {
+    const current = getTask(finding2.task_id, db);
+    if (!current)
+      throw new Error("task not found");
+    const patch = repair.field === "working_dir" ? { version: current.version, working_dir: repair.to } : { version: current.version, task_list_id: repair.to };
+    updateTask(finding2.task_id, patch, db);
+    const recheck = getTaskRouteState(finding2.task_id, db, { verifyProjectRoot: true });
+    addComment({
+      task_id: finding2.task_id,
+      agent_id: actor,
+      type: "comment",
+      content: `[routing-doctor] repaired ${repair.field}: from=${repair.from ?? "(null)"} to=${repair.to}; ` + `source_project=${finding2.project_id ?? "(none)"}${finding2.project_name ? ` (${finding2.project_name})` : ""}` + `${finding2.project_path ? ` path=${finding2.project_path}` : ""}; command="${repair.command}"; ` + `doctor_run=${generatedAt}; route_recheck=eligible:${recheck.eligible} class:${recheck.route_class}`
+    }, db);
+    record.applied = true;
+  } catch (error) {
+    record.error = error instanceof Error ? error.message : String(error);
+  }
+  return record;
+}
+function runRoutingDoctor(options = {}) {
+  const db = options.db ?? getDatabase();
+  const dbPath = options.dbPath ?? getDatabasePath();
+  const clock = options.now ?? now;
+  const generatedAt = clock();
+  const apply = options.apply === true;
+  const statuses = options.statuses && options.statuses.length > 0 ? options.statuses : DEFAULT_STATUSES;
+  const verifyProjectRoot = options.verifyProjectRoot !== false;
+  const shardTotal = options.shardTotal && options.shardTotal > 1 ? Math.floor(options.shardTotal) : 1;
+  const shardIndex = shardTotal > 1 ? Math.max(0, Math.floor(options.shardIndex ?? 0)) % shardTotal : 0;
+  const actor = options.actor ?? "routing-doctor";
+  const knownRepoSlugs = new Set;
+  const projectCache = new Map;
+  for (const project of listProjects(db)) {
+    projectCache.set(project.id, project);
+    knownRepoSlugs.add(repoSlugForProject(project));
+  }
+  const resolveProjectCached = (id) => {
+    if (!id)
+      return null;
+    if (projectCache.has(id))
+      return projectCache.get(id) ?? null;
+    const project = getProject(id, db);
+    projectCache.set(id, project);
+    return project;
+  };
+  const filter = {
+    status: statuses,
+    include_archived: options.includeArchived === true
+  };
+  if (options.projectId)
+    filter.project_id = options.projectId;
+  if (options.tag)
+    filter.tags = [options.tag];
+  let tasks = listTasks(filter, db);
+  if (shardTotal > 1)
+    tasks = tasks.filter((task2) => routingShardOf(task2, shardTotal) === shardIndex);
+  if (options.limit && options.limit > 0)
+    tasks = tasks.slice(0, options.limit);
+  const findings = [];
+  let eligible = 0;
+  for (const task2 of tasks) {
+    const project = resolveProjectCached(task2.project_id);
+    const evaluation = evaluateTaskRouting({ task: task2, project, db, knownRepoSlugs, verifyProjectRoot });
+    if (evaluation.findings.length > 0)
+      findings.push(...evaluation.findings);
+    if (evaluation.eligible)
+      eligible++;
+  }
+  const repairs = [];
+  let backup;
+  let undoRecordPath;
+  if (apply) {
+    const safeFindings = findings.filter((f) => f.repair_class === "safe_auto" && f.suggested_repair);
+    if (safeFindings.length > 0) {
+      backup = createBackup2(dbPath, generatedAt);
+      for (const finding2 of safeFindings) {
+        repairs.push(applySafeRepair(finding2, actor, generatedAt, db));
+      }
+      const applied = repairs.filter((r) => r.applied);
+      if (applied.length > 0) {
+        const undoPath = options.undoRecordPath ?? join21(process.cwd(), `todos-routing-doctor-undo-${generatedAt.replace(/[:.]/g, "-")}.json`);
+        const undoRecord = {
+          schema_version: TODOS_ROUTING_DOCTOR_SCHEMA_VERSION,
+          purpose: "Undo record for routing-doctor --apply. Restore each field with the prior value below.",
+          generated_at: generatedAt,
+          actor,
+          database_path: dbPath,
+          backup: backup ?? null,
+          repairs: applied.map((r) => ({
+            task_id: r.task_id,
+            field: r.field,
+            from: r.from,
+            to: r.to,
+            command: r.command,
+            undo_command: routingRepairUndoCommand(r)
+          }))
+        };
+        try {
+          writeFileSync9(undoPath, `${JSON.stringify(undoRecord, null, 2)}
+`);
+          undoRecordPath = undoPath;
+        } catch {
+          undoRecordPath = undefined;
+        }
+      }
+    }
+  }
+  const residualFindings = apply && repairs.some((r) => r.applied) ? runRoutingDoctor({
+    ...options,
+    apply: false,
+    db,
+    dbPath,
+    now: () => generatedAt
+  }).findings : findings;
+  const byCategory = {};
+  const byRepairClass = {};
+  for (const f of residualFindings) {
+    bump(byCategory, f.category);
+    bump(byRepairClass, f.repair_class);
+  }
+  const safeAuto = residualFindings.filter((f) => f.repair_class === "safe_auto").length;
+  const unsupported = residualFindings.filter((f) => f.repair_class === "unsupported").length;
+  const blockers = residualFindings.filter((f) => f.repair_class.startsWith("blocker_")).length;
+  const repaired = repairs.filter((r) => r.applied).length;
+  const repairFailed = repairs.filter((r) => !r.applied).length;
+  const summary = {
+    inspected: tasks.length,
+    eligible,
+    findings_total: residualFindings.length,
+    by_category: byCategory,
+    by_repair_class: byRepairClass,
+    safe_auto: safeAuto,
+    blockers,
+    unsupported,
+    repaired,
+    repair_failed: repairFailed
+  };
+  return {
+    schema_version: TODOS_ROUTING_DOCTOR_SCHEMA_VERSION,
+    generated_at: generatedAt,
+    ok: residualFindings.length === 0,
+    dry_run: !apply,
+    database_path: dbPath,
+    scope: {
+      statuses,
+      project_id: options.projectId ?? null,
+      tag: options.tag ?? null,
+      shard: shardTotal > 1 ? { index: shardIndex, total: shardTotal } : null,
+      include_archived: options.includeArchived === true,
+      verify_project_root: verifyProjectRoot,
+      limit: options.limit && options.limit > 0 ? options.limit : null
+    },
+    summary,
+    findings: apply ? residualFindings : findings,
+    repairs,
+    backup,
+    undo_record_path: undoRecordPath
+  };
+}
+var TODOS_ROUTING_DOCTOR_SCHEMA_VERSION = "todos.routing_doctor.v1", DEFAULT_STATUSES, REPO_NAME_RE;
+var init_routing_doctor = __esm(() => {
+  init_database();
+  init_comments();
+  init_projects();
+  init_task_lists();
+  init_tasks();
+  init_task_routing();
+  DEFAULT_STATUSES = ["pending", "in_progress"];
+  REPO_NAME_RE = /\bopen-[a-z0-9][a-z0-9-]{1,48}\b/gi;
+});
+
 // src/lib/task-route-sources.ts
 var exports_task_route_sources = {};
 __export(exports_task_route_sources, {
@@ -55503,9 +56138,9 @@ __export(exports_task_route_sources, {
 });
 import { Database as Database3 } from "bun:sqlite";
 import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync21, readdirSync as readdirSync5, statSync as statSync9 } from "fs";
-import { basename as basename9, dirname as dirname12, join as join21, resolve as resolve21 } from "path";
-function normalizePath5(input) {
+import { existsSync as existsSync23, readdirSync as readdirSync5, statSync as statSync10 } from "fs";
+import { basename as basename10, dirname as dirname13, join as join22, resolve as resolve21 } from "path";
+function normalizePath6(input) {
   return resolve21(input);
 }
 function sourceStoreId(sourceDbPath) {
@@ -55513,14 +56148,14 @@ function sourceStoreId(sourceDbPath) {
   return `sqlite:${digest}`;
 }
 function inferSourceRepoPath(sourceDbPath) {
-  const normalized = normalizePath5(sourceDbPath);
+  const normalized = normalizePath6(sourceDbPath);
   if (normalized.endsWith(TODO_STORE_RELATIVE_PATH)) {
-    return dirname12(dirname12(dirname12(normalized)));
+    return dirname13(dirname13(dirname13(normalized)));
   }
-  return dirname12(normalized);
+  return dirname13(normalized);
 }
 function createStoreRef(sourceDbPath) {
-  const normalized = normalizePath5(sourceDbPath);
+  const normalized = normalizePath6(sourceDbPath);
   return {
     source_store_id: sourceStoreId(normalized),
     source_repo_path: inferSourceRepoPath(normalized),
@@ -55557,7 +56192,7 @@ function storeMatchesAny(ref, patterns) {
   if (patterns.length === 0)
     return false;
   const paths = [ref.source_db_path, ref.source_repo_path].filter((value) => Boolean(value));
-  const values = paths.flatMap((value) => [value, basename9(value)]);
+  const values = paths.flatMap((value) => [value, basename10(value)]);
   return patterns.some((pattern) => values.some((value) => matchesPattern4(value, pattern)));
 }
 function shouldIncludeStore(ref, include, exclude) {
@@ -55565,11 +56200,11 @@ function shouldIncludeStore(ref, include, exclude) {
   return included && !storeMatchesAny(ref, exclude);
 }
 function discoverStoresUnderRoot(sourceRoot) {
-  const rootPath = normalizePath5(sourceRoot);
+  const rootPath = normalizePath6(sourceRoot);
   const errors2 = [];
   const stores = [];
-  if (!existsSync21(rootPath)) {
-    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+  if (!existsSync23(rootPath)) {
+    const ref = createStoreRef(join22(rootPath, TODO_STORE_RELATIVE_PATH));
     errors2.push({
       ...ref,
       code: "SOURCE_ROOT_MISSING",
@@ -55579,9 +56214,9 @@ function discoverStoresUnderRoot(sourceRoot) {
   }
   let rootStat;
   try {
-    rootStat = statSync9(rootPath);
+    rootStat = statSync10(rootPath);
   } catch (error) {
-    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+    const ref = createStoreRef(join22(rootPath, TODO_STORE_RELATIVE_PATH));
     errors2.push({
       ...ref,
       code: "SOURCE_ROOT_UNREADABLE",
@@ -55594,8 +56229,8 @@ function discoverStoresUnderRoot(sourceRoot) {
     return { stores, errors: errors2 };
   }
   function scanDirectory(dir, depth) {
-    const candidate = join21(dir, TODO_STORE_RELATIVE_PATH);
-    if (existsSync21(candidate)) {
+    const candidate = join22(dir, TODO_STORE_RELATIVE_PATH);
+    if (existsSync23(candidate)) {
       stores.push(createStoreRef(candidate));
     }
     if (depth >= ROOT_SCAN_MAX_DEPTH)
@@ -55615,7 +56250,7 @@ function discoverStoresUnderRoot(sourceRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory() || SKIPPED_SCAN_DIRS.has(entry.name))
         continue;
-      scanDirectory(join21(dir, entry.name), depth + 1);
+      scanDirectory(join22(dir, entry.name), depth + 1);
     }
   }
   scanDirectory(rootPath, 0);
@@ -55641,7 +56276,7 @@ function collectStoreRefs(input) {
   };
 }
 function openReadonlyStore(ref) {
-  if (!existsSync21(ref.source_db_path)) {
+  if (!existsSync23(ref.source_db_path)) {
     throw Object.assign(new Error(`Store does not exist: ${ref.source_db_path}`), { code: "STORE_MISSING" });
   }
   return new Database3(ref.source_db_path, { readonly: true, create: false });
@@ -55750,8 +56385,8 @@ function errorCode(error) {
 function discoverTaskRouteSources(input) {
   const include = normalizePatterns(input.include);
   const exclude = normalizePatterns(input.exclude);
-  const sourceRoots = (input.sourceRoots ?? []).map(normalizePath5).sort();
-  const sourceStores = (input.sourceStores ?? []).map(normalizePath5).sort();
+  const sourceRoots = (input.sourceRoots ?? []).map(normalizePath6).sort();
+  const sourceStores = (input.sourceStores ?? []).map(normalizePath6).sort();
   const limit = Number.isFinite(input.limit ?? NaN) && (input.limit ?? 0) >= 0 ? Math.floor(input.limit ?? 0) : null;
   const collected = collectStoreRefs(input);
   const stores = [];
@@ -55814,7 +56449,7 @@ var init_task_route_sources = __esm(() => {
   init_task_crud();
   init_redaction();
   init_task_routing();
-  TODO_STORE_RELATIVE_PATH = join21(".hasna", "todos", "todos.db");
+  TODO_STORE_RELATIVE_PATH = join22(".hasna", "todos", "todos.db");
   SKIPPED_SCAN_DIRS = new Set([
     ".git",
     ".hg",
@@ -56311,7 +56946,7 @@ __export(exports_query_commands, {
   registerQueryCommands: () => registerQueryCommands
 });
 import chalk7 from "chalk";
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
 function parseJsonObjectOption2(value, label) {
   if (!value)
     return;
@@ -56955,7 +57590,7 @@ No task claimed (nothing available).`));
     console.log(lines.join(`
 `));
   });
-  program2.command("doctor").description("Diagnose and optionally repair local task data issues").option("--apply", "Apply safe repairs. Defaults to dry-run.").option("--fix", "Alias for --apply").option("-j, --json", "Output as JSON").action(async (opts) => {
+  const doctor = program2.command("doctor").description("Diagnose and optionally repair local task data issues").option("--apply", "Apply safe repairs. Defaults to dry-run.").option("--fix", "Alias for --apply").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const { runTodosDoctor: runTodosDoctor2 } = await Promise.resolve().then(() => (init_doctor(), exports_doctor));
     const result = runTodosDoctor2({ apply: Boolean(opts.apply || opts.fix) });
@@ -56995,19 +57630,140 @@ Repairs`));
       console.log(chalk7[errors2 > 0 ? "red" : "yellow"](`
   ${errors2} error(s), ${warnings} warning(s) remain after repair.`));
   });
+  doctor.command("routing").description("Diagnose (and with --apply, safely repair) task routing-metadata drift: working_dir, task_list_id linkage, invalid paths, cross-repo intent").option("--apply", "Apply safe auto-repairs (working_dir, task_list_id UUID relink) with per-task comments, a DB backup, and an undo record. Defaults to dry-run.").option("--fix", "Alias for --apply").option("--project <id>", "Scope to a single project (id, slug, or path)").option("--tag <tag>", "Scope to tasks carrying this tag").option("--status <statuses>", "Comma-separated statuses to inspect (default: pending,in_progress)").option("--shard <index/total>", "Deterministic project-stable shard, e.g. 0/6").option("--include-archived", "Include archived tasks").option("--no-verify-project-root", "Skip machine-local project-root existence checks").option("--limit <n>", "Cap the number of tasks inspected").option("--undo-record <path>", "Where to write the undo record when --apply mutates").option("-j, --json", "Emit the machine-consumable JSON contract (todos.routing_doctor.v1)").addHelpText("after", `
+Exit codes (for OpenLoops / deterministic consumers):
+  0  no findings (clean)
+  1  routing-metadata findings present (drift detected)
+  2  invalid invocation (bad --shard/--status/--project/--limit)
+
+JSON contract: --json emits { schema_version, generated_at, ok, dry_run, scope,
+summary{inspected,eligible,findings_total,by_category,by_repair_class,safe_auto,
+blockers,unsupported,repaired,repair_failed}, findings[], repairs[] }. Each finding
+carries repair_class: safe_auto | blocker_human | blocker_cross_repo |
+blocker_invalid_path | unsupported. Only safe_auto findings are ever mutated by --apply.`).action(async (opts) => {
+    const globalOpts = program2.opts();
+    const parentOpts = doctor.opts();
+    const applyRequested = Boolean(opts.apply || opts.fix || parentOpts.apply || parentOpts.fix);
+    const { runRoutingDoctor: runRoutingDoctor2 } = await Promise.resolve().then(() => (init_routing_doctor(), exports_routing_doctor));
+    let shardIndex;
+    let shardTotal;
+    if (opts.shard) {
+      const m = /^(\d+)\/(\d+)$/.exec(String(opts.shard).trim());
+      if (!m) {
+        console.error(chalk7.red("--shard must be <index>/<total>, e.g. 0/6"));
+        process.exit(2);
+      }
+      shardIndex = parseInt(m[1], 10);
+      shardTotal = parseInt(m[2], 10);
+      if (shardTotal < 1 || shardIndex >= shardTotal) {
+        console.error(chalk7.red("--shard: index must be < total and total >= 1"));
+        process.exit(2);
+      }
+    }
+    let statuses;
+    if (opts.status) {
+      statuses = String(opts.status).split(",").map((s2) => s2.trim()).filter(Boolean);
+      const invalid = statuses.filter((s2) => !TASK_STATUSES.includes(s2));
+      if (invalid.length > 0) {
+        console.error(chalk7.red(`Invalid status(es): ${invalid.join(", ")}. Valid: ${TASK_STATUSES.join(", ")}`));
+        process.exit(2);
+      }
+    }
+    const projectInput = opts.project || globalOpts.project;
+    let projectId;
+    if (projectInput) {
+      try {
+        projectId = resolveExplicitProject(projectInput).id;
+      } catch {
+        console.error(chalk7.red(`Could not resolve project: ${projectInput}`));
+        process.exit(2);
+      }
+    }
+    let limit;
+    if (opts.limit !== undefined) {
+      limit = parseInt(opts.limit, 10);
+      if (!Number.isFinite(limit) || limit < 1) {
+        console.error(chalk7.red("--limit must be a positive integer"));
+        process.exit(2);
+      }
+    }
+    const result = runRoutingDoctor2({
+      apply: applyRequested,
+      statuses,
+      projectId,
+      tag: opts.tag,
+      shardIndex,
+      shardTotal,
+      includeArchived: Boolean(opts.includeArchived),
+      verifyProjectRoot: opts.verifyProjectRoot !== false,
+      undoRecordPath: opts.undoRecord,
+      limit,
+      actor: globalOpts.agent || "routing-doctor"
+    });
+    if (opts.json || globalOpts.json) {
+      output(result, true);
+      process.exitCode = result.ok ? 0 : 1;
+      return;
+    }
+    const s = result.summary;
+    console.log(chalk7.bold(`todos doctor routing
+`));
+    console.log(`  ${chalk7.dim("Mode:")}   ${result.dry_run ? "dry-run" : "apply"}`);
+    const scopeBits = [
+      `statuses=${result.scope.statuses.join(",")}`,
+      result.scope.project_id ? `project=${result.scope.project_id}` : null,
+      result.scope.tag ? `tag=${result.scope.tag}` : null,
+      result.scope.shard ? `shard=${result.scope.shard.index}/${result.scope.shard.total}` : null,
+      result.scope.include_archived ? "archived=included" : null,
+      result.scope.verify_project_root ? null : "verify-project-root=off"
+    ].filter(Boolean);
+    console.log(`  ${chalk7.dim("Scope:")}  ${scopeBits.join(" \xB7 ")}`);
+    console.log(`  ${chalk7.dim("Tasks:")}  ${s.inspected} inspected \xB7 ${s.eligible} route-eligible`);
+    console.log(`  ${chalk7.dim("Findings:")} ${s.findings_total} (${chalk7.yellow(`${s.safe_auto} safe_auto`)} \xB7 ${chalk7.red(`${s.blockers} blockers`)} \xB7 ${s.unsupported} unsupported)`);
+    const cats = Object.entries(s.by_category).sort((a, b) => b[1] - a[1]);
+    for (const [cat, n] of cats)
+      console.log(`    ${chalk7.dim("\xB7")} ${cat}: ${n}`);
+    if (!result.dry_run) {
+      console.log(`  ${chalk7.dim("Repaired:")} ${s.repaired}${s.repair_failed ? chalk7.red(` (${s.repair_failed} failed)`) : ""}`);
+      if (result.backup)
+        console.log(`  ${chalk7.dim("Backup:")}  ${result.backup.path}`);
+      if (result.undo_record_path)
+        console.log(`  ${chalk7.dim("Undo:")}    ${result.undo_record_path}`);
+    }
+    if (result.findings.length > 0) {
+      console.log(chalk7.bold(`
+Findings`));
+      const shown = result.findings.slice(0, 50);
+      for (const f of shown) {
+        const id = f.task_short_id || f.task_id.slice(0, 8);
+        const icon = f.severity === "error" ? chalk7.red("x") : chalk7.yellow("!");
+        console.log(`  ${icon} ${chalk7.bold(id)} ${f.category} [${f.repair_class}]${f.suggested_repair ? chalk7.dim(` \u2192 ${f.suggested_repair.command}`) : ""}`);
+        console.log(`      ${chalk7.dim(f.detail)}`);
+      }
+      if (result.findings.length > shown.length)
+        console.log(chalk7.dim(`  \u2026 +${result.findings.length - shown.length} more (use --json for the full set)`));
+    }
+    if (result.ok)
+      console.log(chalk7.green(`
+  No routing-metadata drift detected.`));
+    else
+      console.log(chalk7.yellow(`
+  ${s.findings_total} finding(s). ${result.dry_run ? "Re-run with --apply to fix the safe_auto set; blockers need a human/owning repo." : "Remaining findings need a human/owning repo."}`));
+    process.exitCode = result.ok ? 0 : 1;
+  });
   program2.command("health").description("Check todos system health \u2014 database, config, connectivity").option("-j, --json", "Output as JSON").action(async (opts) => {
     const globalOpts = program2.opts();
     const checks = [];
     try {
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
-      const { statSync: statSync10 } = await import("fs");
-      const { join: join22 } = await import("path");
+      const { statSync: statSync11 } = await import("fs");
+      const { join: join23 } = await import("path");
       const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join22(home, ".hasna", "todos", "todos.db");
+      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join23(home, ".hasna", "todos", "todos.db");
       let size = "unknown";
       try {
-        size = `${(statSync10(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
+        size = `${(statSync11(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
       } catch {}
       checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk7.dim(dbPath)}` });
     } catch (e) {
@@ -57671,7 +58427,7 @@ Repairs`));
         const bundle = exportHandoffBundle(opts.export, db);
         const json2 = JSON.stringify(bundle, null, 2);
         if (opts.output) {
-          writeFileSync9(opts.output, `${json2}
+          writeFileSync10(opts.output, `${json2}
 `);
           if (opts.json || globalOpts.json) {
             console.log(JSON.stringify({ path: opts.output, handoff_id: bundle.handoff.id }));
@@ -57902,7 +58658,7 @@ Repairs`));
       });
       const content = format === "json" ? JSON.stringify(document, null, 2) : renderReleaseNotesMarkdown2(document);
       if (opts.out) {
-        writeFileSync9(opts.out, content);
+        writeFileSync10(opts.out, content);
         if (format !== "json")
           console.log(chalk7.green(`Wrote release notes to ${opts.out}`));
         return;
@@ -58017,7 +58773,7 @@ Repairs`));
         redact: Boolean(opts.redact)
       });
       if (opts.out) {
-        writeFileSync9(opts.out, exported.content);
+        writeFileSync10(opts.out, exported.content);
         if (!(opts.json || globalOpts.json))
           console.log(chalk7.green(`Wrote ${exported.events.length} events to ${opts.out}`));
       }
@@ -58172,7 +58928,7 @@ Repairs`));
       const bundle = exportTaskBoardBundle(boardId);
       const json2 = JSON.stringify(bundle, null, 2);
       if (opts.out) {
-        writeFileSync9(opts.out, json2);
+        writeFileSync10(opts.out, json2);
         if (!(opts.json || program2.opts().json))
           console.log(chalk7.green(`Wrote ${bundle.boards.length} board(s) to ${opts.out}`));
       }
@@ -58845,6 +59601,7 @@ var init_query_commands = __esm(() => {
   init_workflow_states();
   init_local_reports();
   init_helpers();
+  init_types();
 });
 
 // src/cli/commands/mcp-hooks-commands.ts
@@ -58854,21 +59611,21 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname13, join as join22 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname14, join as join23 } from "path";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join22(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync22(bunBin))
+  const bunBin = join23(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync24(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync22(path))
+  if (!existsSync24(path))
     return {};
   try {
     return JSON.parse(readFileSync17(path, "utf-8"));
@@ -58877,22 +59634,22 @@ function readJsonFile2(path) {
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname13(path);
-  if (!existsSync22(dir))
-    mkdirSync11(dir, { recursive: true });
-  writeFileSync10(path, JSON.stringify(data, null, 2) + `
+  const dir = dirname14(path);
+  if (!existsSync24(dir))
+    mkdirSync12(dir, { recursive: true });
+  writeFileSync11(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync22(path))
+  if (!existsSync24(path))
     return "";
   return readFileSync17(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname13(path);
-  if (!existsSync22(dir))
-    mkdirSync11(dir, { recursive: true });
-  writeFileSync10(path, content);
+  const dir = dirname14(path);
+  if (!existsSync24(dir))
+    mkdirSync12(dir, { recursive: true });
+  writeFileSync11(path, content);
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -58956,7 +59713,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join22(HOME2, ".codex", "config.toml");
+  const configPath = join23(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -58970,7 +59727,7 @@ args = ["--stdio"]
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join22(HOME2, ".codex", "config.toml");
+  const configPath = join23(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk8.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -58982,7 +59739,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join22(HOME2, ".gemini", "settings.json");
+  const configPath = join23(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -58996,7 +59753,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join22(HOME2, ".gemini", "settings.json");
+  const configPath = join23(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -59053,9 +59810,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join22(process.cwd(), ".claude", "hooks");
-    if (!existsSync22(hooksDir))
-      mkdirSync11(hooksDir, { recursive: true });
+    const hooksDir = join23(process.cwd(), ".claude", "hooks");
+    if (!existsSync24(hooksDir))
+      mkdirSync12(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
@@ -59079,11 +59836,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join22(hooksDir, "todos-sync.sh");
-    writeFileSync10(hookPath, hookScript);
+    const hookPath = join23(hooksDir, "todos-sync.sh");
+    writeFileSync11(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join22(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join23(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -59956,18 +60713,18 @@ Artifacts:`));
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (existsSync22(hookPath)) {
+      if (existsSync24(hookPath)) {
         const existing = readFileSync17(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk8.yellow("Hook already installed."));
           return;
         }
-        writeFileSync10(hookPath, existing + `
+        writeFileSync11(hookPath, existing + `
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
       } else {
-        writeFileSync10(hookPath, `#!/usr/bin/env bash
+        writeFileSync11(hookPath, `#!/usr/bin/env bash
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
@@ -59984,7 +60741,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (!existsSync22(hookPath)) {
+      if (!existsSync24(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
@@ -59999,7 +60756,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       if (cleaned === "#!/usr/bin/env bash" || cleaned === "") {
         (await import("fs")).unlinkSync(hookPath);
       } else {
-        writeFileSync10(hookPath, cleaned + `
+        writeFileSync11(hookPath, cleaned + `
 `);
       }
       console.log(chalk8.green("Post-commit hook removed."));
@@ -60168,9 +60925,9 @@ __export(exports_machines, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -60208,7 +60965,7 @@ function remoteTempPath(sshAddress) {
 }
 function readRemoteBridgeBundle(sshAddress) {
   const remotePath = remoteTempPath(sshAddress);
-  const localPath = join23(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
+  const localPath = join24(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
   try {
     runSsh(sshAddress, `todos export --format bridge --allow-plaintext-sensitive --output ${shellQuote(remotePath)}`, 120000);
     scpFromRemote(sshAddress, remotePath, localPath);
@@ -60223,8 +60980,8 @@ function readRemoteBridgeBundle(sshAddress) {
   }
 }
 function writeLocalBridgeBundle() {
-  const localPath = join23(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
-  writeFileSync11(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
+  const localPath = join24(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
+  writeFileSync12(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
   return localPath;
 }
 function pushLocalBridgeBundle(sshAddress, dryRun) {
@@ -64747,8 +65504,8 @@ __export(exports_sdk_integration_fixtures, {
   TODOS_SDK_INTEGRATION_FIXTURE_SCHEMA_VERSION: () => TODOS_SDK_INTEGRATION_FIXTURE_SCHEMA_VERSION,
   TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT: () => TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT
 });
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "fs";
+import { join as join25 } from "path";
 function source5(version) {
   return {
     packageName: "@hasna/todos",
@@ -64844,7 +65601,7 @@ function createSdkIntegrationFixturePack(options = {}) {
   };
 }
 function writeSdkIntegrationFixtures(directory, options = {}) {
-  mkdirSync12(directory, { recursive: true });
+  mkdirSync13(directory, { recursive: true });
   const pack = createSdkIntegrationFixturePack(options);
   const bundle = getOnboardingFixtureBundle("agent-project-demo");
   const files = [
@@ -64855,8 +65612,8 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   ];
   const written = [];
   for (const [name, payload] of files) {
-    const file = join24(directory, name);
-    writeFileSync12(file, `${JSON.stringify(payload, null, 2)}
+    const file = join25(directory, name);
+    writeFileSync13(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
   }
@@ -65120,7 +65877,7 @@ var exports_roadmap_commands = {};
 __export(exports_roadmap_commands, {
   registerRoadmapCommands: () => registerRoadmapCommands
 });
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "fs";
 import chalk21 from "chalk";
 function splitList3(value) {
   return value?.split(";").flatMap((part) => part.split(",")).map((item) => item.trim()).filter(Boolean);
@@ -65331,7 +66088,7 @@ function registerRoadmapCommands(program2) {
       const { exportRoadmapBundle: exportRoadmapBundle2, renderRoadmapMarkdown: renderRoadmapMarkdown2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const content = opts.format === "markdown" ? renderRoadmapMarkdown2(roadmap) : JSON.stringify(exportRoadmapBundle2(roadmap), null, 2);
       if (opts.out) {
-        writeFileSync13(opts.out, content);
+        writeFileSync14(opts.out, content);
         if (!globalOpts.json)
           console.log(chalk21.green(`Wrote roadmap export to ${opts.out}`));
       }