@hasna/todos 0.11.74 → 0.11.75

package/dist/cli/index.js

@@ -13277,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();
@@ -13830,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;
@@ -13848,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 {
@@ -13870,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,
@@ -14069,6 +14090,7 @@ var init_task_commands = __esm(() => {
   init_database();
   init_projects();
   init_tasks();
+  init_task_lists();
   init_helpers();
   init_types();
 });
@@ -55591,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, {
@@ -55599,9 +56138,9 @@ __export(exports_task_route_sources, {
 });
 import { Database as Database3 } from "bun:sqlite";
 import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync22, readdirSync as readdirSync5, statSync as statSync10 } 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) {
@@ -55609,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),
@@ -55653,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) {
@@ -55661,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 (!existsSync22(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",
@@ -55677,7 +56216,7 @@ function discoverStoresUnderRoot(sourceRoot) {
   try {
     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",
@@ -55690,8 +56229,8 @@ function discoverStoresUnderRoot(sourceRoot) {
     return { stores, errors: errors2 };
   }
   function scanDirectory(dir, depth) {
-    const candidate = join21(dir, TODO_STORE_RELATIVE_PATH);
-    if (existsSync22(candidate)) {
+    const candidate = join22(dir, TODO_STORE_RELATIVE_PATH);
+    if (existsSync23(candidate)) {
       stores.push(createStoreRef(candidate));
     }
     if (depth >= ROOT_SCAN_MAX_DEPTH)
@@ -55711,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);
@@ -55737,7 +56276,7 @@ function collectStoreRefs(input) {
   };
 }
 function openReadonlyStore(ref) {
-  if (!existsSync22(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 });
@@ -55846,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 = [];
@@ -55910,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",
@@ -56407,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;
@@ -57051,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) });
@@ -57091,6 +57630,127 @@ 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 = [];
@@ -57098,9 +57758,9 @@ Repairs`));
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
       const { statSync: statSync11 } = await import("fs");
-      const { join: join22 } = await import("path");
+      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 = `${(statSync11(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
@@ -57767,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 }));
@@ -57998,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;
@@ -58113,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}`));
       }
@@ -58268,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}`));
       }
@@ -58941,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
@@ -58950,21 +59611,21 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync23, 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 (existsSync23(bunBin))
+  const bunBin = join23(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync24(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync23(path))
+  if (!existsSync24(path))
     return {};
   try {
     return JSON.parse(readFileSync17(path, "utf-8"));
@@ -58973,22 +59634,22 @@ function readJsonFile2(path) {
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname13(path);
-  if (!existsSync23(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 (!existsSync23(path))
+  if (!existsSync24(path))
     return "";
   return readFileSync17(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname13(path);
-  if (!existsSync23(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(`
@@ -59052,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 = `
@@ -59066,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}`));
@@ -59078,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"] = {};
@@ -59092,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)) {
@@ -59149,9 +59810,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join22(process.cwd(), ".claude", "hooks");
-    if (!existsSync23(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.
@@ -59175,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"] = {};
@@ -60052,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 (existsSync23(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
 `);
@@ -60080,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 (!existsSync23(hookPath)) {
+      if (!existsSync24(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
@@ -60095,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."));
@@ -60264,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";
 }
@@ -60304,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);
@@ -60319,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) {
@@ -64843,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",
@@ -64940,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 = [
@@ -64951,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);
   }
@@ -65216,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);
@@ -65427,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}`));
       }