@hasna/todos 0.11.70 → 0.11.72

package/dist/index.js

@@ -1198,6 +1198,11 @@ var init_migrations = __esm(() => {
   CREATE INDEX IF NOT EXISTS idx_storage_tombstones_object ON storage_tombstones(object_type, object_id);
   CREATE INDEX IF NOT EXISTS idx_storage_tombstones_updated ON storage_tombstones(updated_at);
   INSERT OR IGNORE INTO _migrations (id) VALUES (63);
+  `,
+    `
+  ALTER TABLE plans ADD COLUMN slug TEXT;
+  CREATE INDEX IF NOT EXISTS idx_plans_slug ON plans(slug);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (64);
   `
   ];
 });
@@ -1221,6 +1226,29 @@ function runMigrations(db) {
   }
   ensureSchema(db);
 }
+function planSlugBase(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "plan";
+}
+function backfillPlanSlugs(db) {
+  try {
+    const rows = db.query("SELECT id, project_id, name, slug FROM plans ORDER BY created_at ASC, id ASC").all();
+    const used = new Set;
+    for (const row of rows) {
+      const scope = row.project_id ?? "__global__";
+      const base = planSlugBase(row.slug || row.name);
+      let candidate = base;
+      let suffix = 2;
+      while (used.has(`${scope}:${candidate}`)) {
+        candidate = `${base}-${suffix}`;
+        suffix += 1;
+      }
+      used.add(`${scope}:${candidate}`);
+      if (row.slug !== candidate) {
+        db.run("UPDATE plans SET slug = ? WHERE id = ?", [candidate, row.id]);
+      }
+    }
+  } catch {}
+}
 function ensureSchema(db) {
   const ensureColumn = (table, column, type) => {
     try {
@@ -1270,7 +1298,8 @@ function ensureSchema(db) {
     )`);
   ensureTable("plans", `
     CREATE TABLE plans (
-      id TEXT PRIMARY KEY, project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+      id TEXT PRIMARY KEY, slug TEXT,
+      project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
       task_list_id TEXT, agent_id TEXT,
       name TEXT NOT NULL, description TEXT,
       status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
@@ -1785,8 +1814,10 @@ function ensureSchema(db) {
   ensureColumn("agents", "org_id", "TEXT");
   ensureColumn("agents", "capabilities", "TEXT DEFAULT '[]'");
   ensureColumn("projects", "org_id", "TEXT");
+  ensureColumn("plans", "slug", "TEXT");
   ensureColumn("plans", "task_list_id", "TEXT");
   ensureColumn("plans", "agent_id", "TEXT");
+  backfillPlanSlugs(db);
   ensureColumn("task_templates", "variables", "TEXT DEFAULT '[]'");
   ensureColumn("task_templates", "version", "INTEGER NOT NULL DEFAULT 1");
   ensureColumn("template_tasks", "condition", "TEXT");
@@ -1901,6 +1932,8 @@ function ensureSchema(db) {
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_slug ON plans(slug)");
+  ensureIndex("CREATE UNIQUE INDEX IF NOT EXISTS idx_plans_scope_slug ON plans(COALESCE(project_id, ''), slug) WHERE slug IS NOT NULL");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_task_list ON plans(task_list_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_plans_agent ON plans(agent_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_history_task ON task_history(task_id)");
@@ -2734,6 +2767,9 @@ function clearExpiredLocks(db) {
   const cutoff = lockExpiryCutoff();
   db.run("UPDATE tasks SET locked_by = NULL, locked_at = NULL WHERE locked_at IS NOT NULL AND locked_at < ?", [cutoff]);
 }
+function slugifyRef(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
 function resolvePartialId(db, table, partialId) {
   if (!ALLOWED_TABLES.has(table)) {
     throw new Error(`Invalid table name: ${table}`);
@@ -2760,6 +2796,16 @@ function resolvePartialId(db, table, partialId) {
     if (slugRow)
       return slugRow.id;
   }
+  if (table === "plans") {
+    const slug = slugifyRef(partialId);
+    if (slug) {
+      const slugRows = db.query("SELECT id FROM plans WHERE slug = ?").all(slug);
+      if (slugRows.length === 1)
+        return slugRows[0].id;
+      if (slugRows.length > 1)
+        return null;
+    }
+  }
   if (table === "projects") {
     const nameRow = db.query("SELECT id FROM projects WHERE lower(name) = ?").get(partialId.toLowerCase());
     if (nameRow)
@@ -7985,8 +8031,6 @@ function routeEnabledForTask(task, taskList) {
   const explicit = booleanField(task.metadata.route_enabled);
   if (explicit !== undefined)
     return explicit;
-  if (task.tags.includes("auto:route") || task.tags.includes("route:enabled"))
-    return true;
   const taskListDefault = taskList ? booleanField(taskList.metadata.route_enabled) : undefined;
   if (taskListDefault !== undefined)
     return taskListDefault;
@@ -8008,8 +8052,26 @@ function workflowPointersFromMetadata(metadata) {
 function compactWorkflowPointers(pointers) {
   return Object.fromEntries(Object.entries(pointers).filter(([, value]) => typeof value === "string" && value.length > 0));
 }
-function classifyProjectKind(path) {
-  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
+function metadataStringField(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return;
+}
+function projectKindFromMetadata(...records) {
+  for (const record of records) {
+    const value = metadataStringField(record ?? undefined, ["project_kind", "projectKind", "source_kind", "sourceKind"]);
+    if (value)
+      return value;
+  }
+  return null;
+}
+function classifyProjectKind(_path, metadata) {
+  return projectKindFromMetadata(metadata);
 }
 function isWorktreePath(path) {
   return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
@@ -8082,7 +8144,6 @@ function taskEventMetadata(task) {
       metadata.project_canonical_path = projectPath;
     }
     if (projectPath) {
-      metadata.project_kind = classifyProjectKind(projectPath);
       metadata.project_is_worktree = isWorktreePath(projectPath);
       metadata.working_dir = task.working_dir ?? projectPath;
     }
@@ -8094,6 +8155,10 @@ function taskEventMetadata(task) {
       metadata.task_list_project_id = taskList.project_id;
       metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
     }
+    const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
+    if (projectKind) {
+      metadata.project_kind = classifyProjectKind(projectPath ?? "", { project_kind: projectKind });
+    }
     const routeEnabled = routeEnabledForTask(task, taskList);
     if (routeEnabled !== undefined) {
       metadata.route_enabled = routeEnabled;
@@ -10736,15 +10801,59 @@ init_database();
 // src/db/plans.ts
 init_types();
 init_database();
+function planSlugBase2(value) {
+  return slugify(value) || "plan";
+}
+function normalizePlanSlug(value) {
+  const slug = slugify(value);
+  if (!slug)
+    throw new Error("Invalid plan slug");
+  return slug;
+}
+function plansBySlug(slug, db, projectId) {
+  if (projectId !== undefined) {
+    if (projectId === null) {
+      return db.query("SELECT * FROM plans WHERE slug = ? AND project_id IS NULL ORDER BY created_at ASC, id ASC").all(slug);
+    }
+    return db.query("SELECT * FROM plans WHERE slug = ? AND project_id = ? ORDER BY created_at ASC, id ASC").all(slug, projectId);
+  }
+  return db.query("SELECT * FROM plans WHERE slug = ? ORDER BY created_at ASC, id ASC").all(slug);
+}
+function planSlugExists(slug, projectId, db, excludeId) {
+  const rows = plansBySlug(slug, db, projectId);
+  return rows.some((plan) => plan.id !== excludeId);
+}
+function nextPlanSlug(base, projectId, db, excludeId) {
+  let candidate = base;
+  let suffix = 2;
+  while (planSlugExists(candidate, projectId, db, excludeId)) {
+    candidate = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  return candidate;
+}
+function resolveCreateSlug(input, projectId, db) {
+  if (input.slug !== undefined) {
+    const slug = normalizePlanSlug(input.slug);
+    if (planSlugExists(slug, projectId, db)) {
+      throw new Error(`Plan slug already exists in this scope: ${slug}`);
+    }
+    return slug;
+  }
+  return nextPlanSlug(planSlugBase2(input.name), projectId, db);
+}
 function createPlan(input, db) {
   const d = db || getDatabase();
   const id = uuid();
   const timestamp = now();
+  const projectId = input.project_id || null;
+  const slug = resolveCreateSlug(input, projectId, d);
   const machineId = currentStorageMachineId(d);
-  d.run(`INSERT INTO plans (id, project_id, task_list_id, agent_id, name, description, status, created_at, updated_at, machine_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO plans (id, slug, project_id, task_list_id, agent_id, name, description, status, created_at, updated_at, machine_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
-    input.project_id || null,
+    slug,
+    projectId,
     input.task_list_id || null,
     input.agent_id || null,
     input.name,
@@ -10779,6 +10888,14 @@ function updatePlan(id, input, db) {
     sets.push("name = ?");
     params.push(input.name);
   }
+  if (input.slug !== undefined) {
+    const slug = normalizePlanSlug(input.slug);
+    if (planSlugExists(slug, plan.project_id, d, id)) {
+      throw new Error(`Plan slug already exists in this scope: ${slug}`);
+    }
+    sets.push("slug = ?");
+    params.push(slug);
+  }
   if (input.description !== undefined) {
     sets.push("description = ?");
     params.push(input.description);
@@ -12632,7 +12749,7 @@ var dataKeys = [
 var insertColumns = {
   projects: ["id", "name", "path", "description", "task_list_id", "task_prefix", "task_counter", "created_at", "updated_at", "machine_id", "synced_at"],
   task_lists: ["id", "project_id", "slug", "name", "description", "metadata", "created_at", "updated_at", "machine_id", "synced_at"],
-  plans: ["id", "project_id", "task_list_id", "agent_id", "name", "description", "status", "created_at", "updated_at", "machine_id", "synced_at"],
+  plans: ["id", "slug", "project_id", "task_list_id", "agent_id", "name", "description", "status", "created_at", "updated_at", "machine_id", "synced_at"],
   tasks: [
     "id",
     "short_id",
@@ -12924,6 +13041,36 @@ function prepareValue(column, value) {
     return JSON.stringify(value ?? (column === "tags" || column === "files_changed" ? [] : {}));
   return value === undefined ? null : value;
 }
+function slugifyPlanValue(value) {
+  return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") : "";
+}
+function planSlugBase3(plan) {
+  return slugifyPlanValue(plan.slug) || slugifyPlanValue(plan.name) || "plan";
+}
+function planSlugScope(projectId) {
+  return typeof projectId === "string" && projectId ? projectId : "__global__";
+}
+function planSlugKey(projectId, slug) {
+  return `${planSlugScope(projectId)}:${slug}`;
+}
+function normalizeBridgePlanSlugs(plans, db) {
+  const existingRows = db.query("SELECT id, project_id, slug FROM plans WHERE slug IS NOT NULL").all();
+  const existingIds = new Set(existingRows.map((row) => row.id));
+  const used = new Set(existingRows.filter((row) => row.slug).map((row) => planSlugKey(row.project_id, row.slug)));
+  return plans.map((plan) => {
+    if (existingIds.has(plan.id))
+      return plan;
+    const base = planSlugBase3(plan);
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(planSlugKey(plan.project_id, candidate))) {
+      candidate = `${base}-${suffix}`;
+      suffix += 1;
+    }
+    used.add(planSlugKey(plan.project_id, candidate));
+    return { ...plan, slug: candidate };
+  });
+}
 function insertRecord(db, tableKey, row) {
   const table = tableByKey[tableKey];
   const columns = insertColumns[tableKey];
@@ -13060,6 +13207,7 @@ function importLocalBridgeBundle(bundle, options = {}, db) {
   const conflictStrategy = options.conflictStrategy ?? "skip";
   const data = {
     ...bundle.data,
+    plans: normalizeBridgePlanSlugs(bundle.data.plans, d),
     tasks: sortedTasks(bundle.data.tasks),
     saved_views: bundle.data.saved_views ?? [],
     task_boards: bundle.data.task_boards ?? [],
@@ -13253,6 +13401,7 @@ function createAgentProjectDemoBundle() {
   });
   data.plans.push({
     id: ids.plan,
+    slug: "ship-local-demo-workflow",
     project_id: ids.project,
     task_list_id: ids.list,
     agent_id: "demo-agent",
@@ -23380,9 +23529,17 @@ async function updateProject2(id, input, store) {
 }
 async function createPlan2(input, store, context) {
   const timestamp2 = new Date().toISOString();
+  const projectId = input.project_id ?? context?.projectId ?? null;
+  const slug = await resolvePostgresPlanSlug({
+    name: input.name,
+    slug: input.slug,
+    projectId,
+    store
+  });
   return store.upsert("plans", {
     id: randomUUID3(),
-    project_id: input.project_id ?? context?.projectId ?? null,
+    slug,
+    project_id: projectId,
     task_list_id: input.task_list_id ?? context?.taskListId ?? null,
     agent_id: input.agent_id ?? context?.agentId ?? null,
     name: input.name,
@@ -23396,7 +23553,17 @@ async function createPlan2(input, store, context) {
 }
 async function updatePlan2(id, input, store) {
   const plan = await requireRecord("plans", id, store);
-  return store.upsert("plans", { ...plan, ...definedPatch(input), updated_at: new Date().toISOString() });
+  const patch = definedPatch(input);
+  if (input.slug !== undefined) {
+    patch.slug = await resolvePostgresPlanSlug({
+      name: plan.name,
+      slug: input.slug,
+      projectId: plan.project_id,
+      store,
+      excludeId: id
+    });
+  }
+  return store.upsert("plans", { ...plan, ...patch, updated_at: new Date().toISOString() });
 }
 async function registerAgent2(input, store, context) {
   const existing = (await store.list("agents")).find((agent2) => agent2.name === input.name && agent2.status !== "archived");
@@ -23649,8 +23816,38 @@ function matchesOne(value, expected) {
 function priorityRank(priority) {
   return { critical: 0, high: 1, medium: 2, low: 3 }[priority];
 }
+function slugifyRaw(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
 function slugify2(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "todos";
+  return slugifyRaw(value) || "todos";
+}
+function normalizePlanSlug2(value) {
+  const slug = slugifyRaw(value);
+  if (!slug)
+    throw new Error("Invalid plan slug");
+  return slug;
+}
+function planSlugBase4(value) {
+  return slugifyRaw(value) || "plan";
+}
+async function resolvePostgresPlanSlug(options) {
+  const plans = await options.store.list("plans");
+  const used = new Set(plans.filter((plan) => plan.project_id === options.projectId && plan.id !== options.excludeId && plan.slug).map((plan) => plan.slug));
+  if (options.slug !== undefined) {
+    const slug = normalizePlanSlug2(options.slug);
+    if (used.has(slug))
+      throw new Error(`Plan slug already exists in this scope: ${slug}`);
+    return slug;
+  }
+  const base = planSlugBase4(options.name);
+  let candidate = base;
+  let suffix = 2;
+  while (used.has(candidate)) {
+    candidate = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  return candidate;
 }
 function definedPatch(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined));
@@ -24826,6 +25023,496 @@ function clean2(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : undefined;
 }
+// src/lib/task-route-sources.ts
+init_database();
+import { Database as Database3 } from "bun:sqlite";
+import { createHash as createHash10 } from "crypto";
+import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { basename as basename2, dirname as dirname7, join as join10, resolve as resolve10 } from "path";
+init_redaction();
+
+// src/lib/task-routing.ts
+init_database();
+function machineLocalPath(project, db) {
+  const machineId = process.env["TODOS_MACHINE_ID"];
+  if (!machineId)
+    return null;
+  try {
+    const row = db.query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
+    return row?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveProject(task2, db) {
+  const project = task2.project_id ? getProject(task2.project_id, db) : null;
+  const projectPath = project ? machineLocalPath(project, db) ?? project.path : task2.working_dir;
+  return { project, projectPath: projectPath ?? null };
+}
+function resolveTaskList(task2, project, db) {
+  if (task2.task_list_id) {
+    return getTaskList(task2.task_list_id, db) ?? (project ? getTaskListBySlug(task2.task_list_id, project.id, db) : null);
+  }
+  if (project?.task_list_id) {
+    return getTaskListBySlug(project.task_list_id, project.id, db);
+  }
+  return null;
+}
+function isTerminal2(status) {
+  return status === "completed" || status === "cancelled" || status === "failed";
+}
+function routeConcurrencyKey(task2, project, taskList, projectPath) {
+  if (project?.id)
+    return `project:${project.id}`;
+  if (taskList?.id)
+    return `task-list:${taskList.id}`;
+  if (projectPath)
+    return `path:${projectPath}`;
+  return `task:${task2.id}`;
+}
+function getTaskRouteState(taskOrId, db) {
+  const d = db || getDatabase();
+  const task2 = typeof taskOrId === "string" ? getTask(taskOrId, d) : taskOrId;
+  if (!task2)
+    throw new Error(`Task not found: ${taskOrId}`);
+  const { project, projectPath } = resolveProject(task2, d);
+  const taskList = resolveTaskList(task2, project, d);
+  const automation = routingAutomationMetadata(task2, taskList) ?? {};
+  const routeEnabled = routeEnabledForTask(task2, taskList) === true;
+  const tagOptIn = task2.tags.includes("auto:route") || task2.tags.includes("route:enabled");
+  const projectKind = projectKindFromMetadata(task2.metadata, taskList?.metadata);
+  const locked = Boolean(task2.locked_by && !isLockExpired(task2.locked_at));
+  const blockers = getBlockingDeps(task2.id, d);
+  const blocked = blockers.length > 0;
+  const terminal = isTerminal2(task2.status);
+  const requiresApproval = automation.requires_approval === true || task2.requires_approval === true;
+  const approvalRequired = automation.approval_required === true;
+  const approved = Boolean(task2.approved_by);
+  const gates = {
+    route_enabled: routeEnabled,
+    tag_opt_in: tagOptIn,
+    no_auto: automation.no_auto === true,
+    manual: automation.manual === true,
+    manual_required: automation.manual_required === true,
+    requires_approval: requiresApproval,
+    approval_required: approvalRequired,
+    approved,
+    locked,
+    blocked,
+    terminal
+  };
+  const reasons = [];
+  if (task2.status !== "pending")
+    reasons.push("task_not_pending");
+  if (terminal)
+    reasons.push("task_terminal");
+  if (!routeEnabled)
+    reasons.push("route_not_enabled");
+  if (locked)
+    reasons.push("task_locked");
+  if (blocked)
+    reasons.push("task_blocked");
+  if (gates.no_auto)
+    reasons.push("no_auto");
+  if (gates.manual)
+    reasons.push("manual");
+  if (gates.manual_required)
+    reasons.push("manual_required");
+  if (requiresApproval && !approved)
+    reasons.push("requires_approval");
+  if (approvalRequired && !approved)
+    reasons.push("approval_required");
+  if (automation.allowed === false)
+    reasons.push("automation_disallowed");
+  return {
+    schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
+    task_id: task2.id,
+    task_short_id: task2.short_id,
+    status: task2.status,
+    eligible: reasons.length === 0,
+    reasons,
+    blockers: blockers.map((blocker) => ({
+      id: blocker.id,
+      short_id: blocker.short_id,
+      title: blocker.title,
+      status: blocker.status
+    })),
+    gates,
+    automation: Object.keys(automation).length > 0 ? automation : null,
+    route: {
+      project_id: project?.id ?? task2.project_id,
+      project_path: projectPath,
+      working_dir: task2.working_dir ?? projectPath,
+      project_kind: projectKind,
+      task_list_id: taskList?.id ?? task2.task_list_id,
+      task_list_slug: taskList?.slug ?? null,
+      task_list_name: taskList?.name ?? null,
+      concurrency_key: routeConcurrencyKey(task2, project, taskList, projectPath)
+    },
+    pointers: workflowPointersFromMetadata(task2.metadata)
+  };
+}
+function setTaskWorkflowPointers(taskId, input, db) {
+  const d = db || getDatabase();
+  const task2 = getTask(taskId, d);
+  if (!task2)
+    throw new Error(`Task not found: ${taskId}`);
+  const previous = workflowPointersFromMetadata(task2.metadata);
+  const next = compactWorkflowPointers({
+    current_workflow_invocation_id: pointerPatch(previous.current_workflow_invocation_id, input, "current_workflow_invocation_id"),
+    current_run_id: pointerPatch(previous.current_run_id, input, "current_run_id"),
+    latest_manifest_path: pointerPatch(previous.latest_manifest_path, input, "latest_manifest_path"),
+    latest_evaluation_path: pointerPatch(previous.latest_evaluation_path, input, "latest_evaluation_path"),
+    workflow_state: pointerPatch(previous.workflow_state, input, "workflow_state")
+  });
+  const timestamp2 = now();
+  const {
+    current_workflow_invocation_id,
+    current_run_id,
+    latest_manifest_path,
+    latest_evaluation_path,
+    workflow_state,
+    workflow_invocation,
+    ...baseMetadata
+  } = task2.metadata;
+  const metadata = {
+    ...baseMetadata,
+    ...next,
+    workflow_invocation: {
+      schema_version: TASK_WORKFLOW_POINTER_SCHEMA_VERSION,
+      ...next,
+      updated_at: timestamp2,
+      updated_by: input.actor ?? null
+    }
+  };
+  return updateTask(task2.id, { version: task2.version, metadata }, d);
+}
+function pointerPatch(previous, input, key) {
+  if (!Object.prototype.hasOwnProperty.call(input, key))
+    return previous;
+  const value = input[key];
+  if (value === undefined)
+    return previous;
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+// src/lib/task-route-sources.ts
+var TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION = "todos.task_route_sources.v1";
+var TODO_STORE_RELATIVE_PATH = join10(".hasna", "todos", "todos.db");
+var ROOT_SCAN_MAX_DEPTH = 5;
+var SKIPPED_SCAN_DIRS = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache"
+]);
+function normalizePath3(input) {
+  return resolve10(input);
+}
+function sourceStoreId(sourceDbPath) {
+  const digest = createHash10("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  return `sqlite:${digest}`;
+}
+function inferSourceRepoPath(sourceDbPath) {
+  const normalized = normalizePath3(sourceDbPath);
+  if (normalized.endsWith(TODO_STORE_RELATIVE_PATH)) {
+    return dirname7(dirname7(dirname7(normalized)));
+  }
+  return dirname7(normalized);
+}
+function createStoreRef(sourceDbPath) {
+  const normalized = normalizePath3(sourceDbPath);
+  return {
+    source_store_id: sourceStoreId(normalized),
+    source_repo_path: inferSourceRepoPath(normalized),
+    source_db_path: normalized
+  };
+}
+function normalizePatterns(patterns) {
+  return (patterns ?? []).map((pattern) => pattern.trim()).filter(Boolean);
+}
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globPatternToRegExp(pattern) {
+  let source9 = "";
+  for (const char of pattern) {
+    if (char === "*")
+      source9 += ".*";
+    else if (char === "?")
+      source9 += ".";
+    else
+      source9 += escapeRegExp(char);
+  }
+  return new RegExp(`^${source9}$`);
+}
+function matchesPattern3(value, pattern) {
+  const normalizedValue = value.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (normalizedPattern.includes("*") || normalizedPattern.includes("?")) {
+    return globPatternToRegExp(normalizedPattern).test(normalizedValue);
+  }
+  return normalizedValue.includes(normalizedPattern);
+}
+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, basename2(value)]);
+  return patterns.some((pattern) => values.some((value) => matchesPattern3(value, pattern)));
+}
+function shouldIncludeStore(ref, include, exclude) {
+  const included = include.length === 0 || storeMatchesAny(ref, include);
+  return included && !storeMatchesAny(ref, exclude);
+}
+function discoverStoresUnderRoot(sourceRoot) {
+  const rootPath = normalizePath3(sourceRoot);
+  const errors = [];
+  const stores = [];
+  if (!existsSync9(rootPath)) {
+    const ref = createStoreRef(join10(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors.push({
+      ...ref,
+      code: "SOURCE_ROOT_MISSING",
+      message: `Source root does not exist: ${rootPath}`
+    });
+    return { stores, errors };
+  }
+  let rootStat;
+  try {
+    rootStat = statSync3(rootPath);
+  } catch (error) {
+    const ref = createStoreRef(join10(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors.push({
+      ...ref,
+      code: "SOURCE_ROOT_UNREADABLE",
+      message: error instanceof Error ? error.message : `Unable to read source root: ${rootPath}`
+    });
+    return { stores, errors };
+  }
+  if (rootStat.isFile()) {
+    stores.push(createStoreRef(rootPath));
+    return { stores, errors };
+  }
+  function scanDirectory(dir, depth) {
+    const candidate = join10(dir, TODO_STORE_RELATIVE_PATH);
+    if (existsSync9(candidate)) {
+      stores.push(createStoreRef(candidate));
+    }
+    if (depth >= ROOT_SCAN_MAX_DEPTH)
+      return;
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      const ref = createStoreRef(candidate);
+      errors.push({
+        ...ref,
+        code: "SOURCE_ROOT_UNREADABLE",
+        message: error instanceof Error ? error.message : `Unable to read source root: ${dir}`
+      });
+      return;
+    }
+    for (const entry2 of entries) {
+      if (!entry2.isDirectory() || SKIPPED_SCAN_DIRS.has(entry2.name))
+        continue;
+      scanDirectory(join10(dir, entry2.name), depth + 1);
+    }
+  }
+  scanDirectory(rootPath, 0);
+  return { stores, errors };
+}
+function collectStoreRefs(input) {
+  const byPath = new Map;
+  const errors = [];
+  for (const storePath of input.sourceStores ?? []) {
+    const ref = createStoreRef(storePath);
+    byPath.set(ref.source_db_path, ref);
+  }
+  for (const sourceRoot of input.sourceRoots ?? []) {
+    const discovered = discoverStoresUnderRoot(sourceRoot);
+    for (const ref of discovered.stores) {
+      byPath.set(ref.source_db_path, ref);
+    }
+    errors.push(...discovered.errors);
+  }
+  return {
+    stores: [...byPath.values()].sort((a, b) => a.source_db_path.localeCompare(b.source_db_path)),
+    errors: errors.sort((a, b) => a.source_db_path.localeCompare(b.source_db_path))
+  };
+}
+function openReadonlyStore(ref) {
+  if (!existsSync9(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 });
+}
+function hasTable2(db, tableName) {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+  return Boolean(row);
+}
+function tableColumns2(db, tableName) {
+  const rows = db.query(`PRAGMA table_info(${tableName})`).all();
+  return new Set(rows.map((row) => row.name));
+}
+function listPendingTasksReadonly(db) {
+  if (!hasTable2(db, "tasks")) {
+    throw Object.assign(new Error("Store does not contain a tasks table"), { code: "STORE_INVALID" });
+  }
+  const columns = tableColumns2(db, "tasks");
+  const conditions = ["status = 'pending'"];
+  if (columns.has("archived_at"))
+    conditions.push("archived_at IS NULL");
+  const rows = db.query(`SELECT * FROM tasks WHERE ${conditions.join(" AND ")}
+       ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END, created_at DESC`).all();
+  return rows.map(rowToTask);
+}
+function isReadyTask(task2, db) {
+  if (task2.locked_by && !isLockExpired(task2.locked_at))
+    return false;
+  return getBlockingDeps(task2.id, db).length === 0;
+}
+function metadataFingerprint(metadata) {
+  const value = metadata.fingerprint;
+  if (typeof value === "string" && value.trim())
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return null;
+}
+function boundedMetadataValue(value, depth = 0) {
+  if (depth > 6)
+    return "[TRUNCATED]";
+  if (typeof value === "string") {
+    return value.length > 2000 ? `${value.slice(0, 2000)}[TRUNCATED]` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map((item) => boundedMetadataValue(item, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, child] of Object.entries(value).slice(0, 80)) {
+      const normalized = key.toLowerCase();
+      if (normalized === "comment" || normalized === "comments" || normalized === "task_comments") {
+        result[key] = "[REDACTED_COMMENT]";
+        continue;
+      }
+      result[key] = boundedMetadataValue(child, depth + 1);
+    }
+    return result;
+  }
+  return value;
+}
+function discoveryMetadata(metadata) {
+  return redactValue(boundedMetadataValue(metadata));
+}
+function sourceCandidate(ref, task2, db) {
+  const routeState = getTaskRouteState(task2, db);
+  const autoRoute = task2.tags.includes("auto:route") || task2.tags.includes("route:enabled");
+  return {
+    source_store_id: ref.source_store_id,
+    source_repo_path: ref.source_repo_path,
+    source_db_path: ref.source_db_path,
+    source_task_key: `${ref.source_store_id}:${task2.id}`,
+    source_selected_by_input: true,
+    task_id: task2.id,
+    task_short_id: task2.short_id,
+    title: task2.title,
+    status: task2.status,
+    priority: task2.priority,
+    project_path: routeState.route.project_path ?? task2.working_dir ?? ref.source_repo_path,
+    task_version: task2.version,
+    task_updated_at: task2.updated_at,
+    task_fingerprint: metadataFingerprint(task2.metadata),
+    tags: task2.tags,
+    task_intent: {
+      auto_route: autoRoute
+    },
+    metadata: discoveryMetadata(task2.metadata),
+    route_state: routeState
+  };
+}
+function discoveryError(ref, code, error) {
+  return {
+    ...ref,
+    code,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function errorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "STORE_MISSING") {
+    return "STORE_MISSING";
+  }
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "STORE_INVALID") {
+    return "STORE_INVALID";
+  }
+  return "STORE_UNREADABLE";
+}
+function discoverTaskRouteSources(input) {
+  const include = normalizePatterns(input.include);
+  const exclude = normalizePatterns(input.exclude);
+  const sourceRoots = (input.sourceRoots ?? []).map(normalizePath3).sort();
+  const sourceStores = (input.sourceStores ?? []).map(normalizePath3).sort();
+  const limit = Number.isFinite(input.limit ?? NaN) && (input.limit ?? 0) >= 0 ? Math.floor(input.limit ?? 0) : null;
+  const collected = collectStoreRefs(input);
+  const stores = [];
+  const errors = [...collected.errors];
+  const candidates = [];
+  let totalCandidateCount = 0;
+  for (const ref of collected.stores) {
+    if (!shouldIncludeStore(ref, include, exclude))
+      continue;
+    const storeErrors = [];
+    let db = null;
+    try {
+      db = openReadonlyStore(ref);
+      const readyTasks = listPendingTasksReadonly(db).filter((task2) => isReadyTask(task2, db));
+      totalCandidateCount += readyTasks.length;
+      const remaining = limit === null ? readyTasks.length : Math.max(0, limit - candidates.length);
+      const selectedTasks = limit === null ? readyTasks : readyTasks.slice(0, remaining);
+      candidates.push(...selectedTasks.map((task2) => sourceCandidate(ref, task2, db)));
+      stores.push({
+        ...ref,
+        status: "ok",
+        candidate_count: readyTasks.length,
+        returned_candidate_count: selectedTasks.length,
+        errors: []
+      });
+    } catch (error) {
+      const storeError = discoveryError(ref, errorCode(error), error);
+      storeErrors.push(storeError);
+      errors.push(storeError);
+      stores.push({
+        ...ref,
+        status: storeError.code === "STORE_MISSING" ? "missing" : "error",
+        candidate_count: 0,
+        returned_candidate_count: 0,
+        errors: storeErrors
+      });
+    } finally {
+      db?.close();
+    }
+  }
+  return {
+    schema_version: TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION,
+    sourceRoots,
+    sourceStores,
+    include,
+    exclude,
+    limit,
+    total_candidate_count: totalCandidateCount,
+    returned_candidate_count: candidates.length,
+    truncated: limit !== null && totalCandidateCount > candidates.length,
+    stores,
+    candidates,
+    errors
+  };
+}
 
 // src/index.ts
 init_database();
@@ -24963,8 +25650,8 @@ function listCyclesWithStats(options = {}, db) {
 }
 // src/lib/plan-artifacts.ts
 init_database();
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10, resolve as resolve10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11, resolve as resolve11 } from "path";
 var PLAN_MARKDOWN_SCHEMA = "hasna.todos.plan/v1";
 function assertSafePathSegment(value, label) {
   const trimmed = value.trim();
@@ -25000,12 +25687,15 @@ function projectSlugMatches(project, ref) {
   const normalized = slugify(ref);
   return Boolean(normalized) && (project.task_list_id === normalized || slugify(project.name) === normalized);
 }
+function planArtifactSlug(plan) {
+  return slugify(plan.slug || plan.name) || "plan";
+}
 function resolvePlanArtifactProject(input) {
   const db = input.db || getDatabase();
   const ref = input.project_id || input.project_ref;
   if (!ref)
     throw new Error("Plan artifacts require a project id or project reference");
-  const byPath = getProjectByPath(resolve10(ref), db);
+  const byPath = getProjectByPath(resolve11(ref), db);
   if (byPath)
     return byPath;
   const resolvedId = resolvePartialId(db, "projects", ref);
@@ -25022,14 +25712,27 @@ function resolvePlanArtifactProject(input) {
 function resolvePlanArtifactPaths(input) {
   const project = resolvePlanArtifactProject(input);
   const projectId = assertSafePathSegment(project.id, "project id");
-  const projectRoot = resolve10(project.path);
-  const directory = join10(projectRoot, ".hasna", "todos", "plans", projectId);
+  const projectRoot = resolve11(project.path);
+  const directory = join11(projectRoot, ".hasna", "todos", "plans", projectId);
   const planId = input.plan_id ? assertSafePathSegment(input.plan_id, "plan id") : null;
+  const planSlug = input.plan_slug ? assertSafePathSegment(slugify(input.plan_slug), "plan slug") : null;
+  const fileName = planId ? planSlug ? `${planSlug}--${planId.slice(0, 8)}.md` : `${planId}.md` : null;
   return {
     project_id: project.id,
     project_root: projectRoot,
     directory,
-    file_path: planId ? join10(directory, `${planId}.md`) : directory
+    file_path: fileName ? join11(directory, fileName) : directory
+  };
+}
+function resolvePlanArtifactCandidatePaths(plan, db) {
+  return {
+    primary: resolvePlanArtifactPaths({
+      project_id: plan.project_id,
+      plan_id: plan.id,
+      plan_slug: planArtifactSlug(plan),
+      db
+    }),
+    legacy: resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db })
   };
 }
 function buildPlanArtifactSnapshot(plan, tasks = [], artifactUpdatedAt = new Date().toISOString()) {
@@ -25046,6 +25749,7 @@ function buildPlanArtifactSnapshot(plan, tasks = [], artifactUpdatedAt = new Dat
     metadata: {
       schema: PLAN_MARKDOWN_SCHEMA,
       plan_id: plan.id,
+      plan_slug: plan.slug ?? null,
       project_id: plan.project_id,
       task_list_id: plan.task_list_id ?? null,
       agent_id: plan.agent_id ?? null,
@@ -25085,6 +25789,7 @@ function renderPlanArtifactMarkdown(snapshot) {
     "---",
     `schema: ${frontmatterScalar(metadata.schema)}`,
     `plan_id: ${frontmatterScalar(metadata.plan_id)}`,
+    `plan_slug: ${frontmatterScalar(metadata.plan_slug)}`,
     `project_id: ${frontmatterScalar(metadata.project_id)}`,
     `task_list_id: ${frontmatterScalar(metadata.task_list_id)}`,
     `agent_id: ${frontmatterScalar(metadata.agent_id)}`,
@@ -25130,6 +25835,7 @@ function parsePlanArtifactMarkdown(markdown) {
     metadata: {
       schema: PLAN_MARKDOWN_SCHEMA,
       plan_id: rawMetadata.plan_id,
+      plan_slug: rawMetadata.plan_slug ?? null,
       project_id: rawMetadata.project_id,
       task_list_id: rawMetadata.task_list_id ?? null,
       agent_id: rawMetadata.agent_id ?? null,
@@ -25170,7 +25876,7 @@ function writePlanArtifact(plan, db) {
     return null;
   const d = db || getDatabase();
   const tasks = listTasks({ plan_id: plan.id, include_archived: true }, d);
-  const paths = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
+  const paths = resolvePlanArtifactCandidatePaths(plan, d).primary;
   const snapshot = buildPlanArtifactSnapshot(plan, tasks);
   mkdirSync8(paths.directory, { recursive: true });
   writeFileSync6(paths.file_path, renderPlanArtifactMarkdown(snapshot), "utf8");
@@ -25180,12 +25886,13 @@ function readPlanArtifact(plan, db) {
   if (!plan.project_id)
     return null;
   const d = db || getDatabase();
-  const paths = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
-  if (!existsSync9(paths.file_path))
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync10(paths.primary.file_path) ? paths.primary.file_path : existsSync10(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path)
     return null;
-  const markdown = readFileSync7(paths.file_path, "utf8");
+  const markdown = readFileSync7(path, "utf8");
   return {
-    path: paths.file_path,
+    path,
     markdown,
     ...parsePlanArtifactMarkdown(markdown)
   };
@@ -25194,10 +25901,11 @@ function inspectPlanArtifact(plan, db) {
   if (!plan.project_id)
     return null;
   const d = db || getDatabase();
-  const paths = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
-  if (!existsSync9(paths.file_path)) {
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync10(paths.primary.file_path) ? paths.primary.file_path : existsSync10(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path) {
     return {
-      path: paths.file_path,
+      path: paths.primary.file_path,
       exists: false,
       parse_error: null,
       metadata: null,
@@ -25206,9 +25914,9 @@ function inspectPlanArtifact(plan, db) {
     };
   }
   try {
-    const artifact = parsePlanArtifactMarkdown(readFileSync7(paths.file_path, "utf8"));
+    const artifact = parsePlanArtifactMarkdown(readFileSync7(path, "utf8"));
     return {
-      path: paths.file_path,
+      path,
       exists: true,
       parse_error: null,
       metadata: artifact.metadata,
@@ -25217,7 +25925,7 @@ function inspectPlanArtifact(plan, db) {
     };
   } catch (error) {
     return {
-      path: paths.file_path,
+      path,
       exists: true,
       parse_error: error instanceof Error ? error.message : String(error),
       metadata: null,
@@ -25229,6 +25937,9 @@ function inspectPlanArtifact(plan, db) {
 function comparePlanArtifact(plan, artifact, tasks) {
   const conflicts = [];
   compare("plan_id", plan.id, artifact.metadata.plan_id, conflicts);
+  if (artifact.metadata.plan_slug !== null) {
+    compare("plan_slug", plan.slug ?? null, artifact.metadata.plan_slug, conflicts);
+  }
   compare("project_id", plan.project_id ?? null, artifact.metadata.project_id, conflicts);
   compare("name", plan.name, artifact.metadata.name, conflicts);
   compare("status", plan.status, artifact.metadata.status, conflicts);
@@ -26277,28 +26988,28 @@ function renderRetrospectiveMarkdown(record) {
 }
 // src/lib/project-bootstrap.ts
 init_database();
-import { existsSync as existsSync10, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
-import { basename as basename2, dirname as dirname7, resolve as resolve11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { basename as basename3, dirname as dirname8, resolve as resolve12 } from "path";
 function safeStat(path) {
   try {
-    return statSync3(path);
+    return statSync4(path);
   } catch {
     return null;
   }
 }
 function canonicalPath(input) {
-  const resolved = resolve11(input);
+  const resolved = resolve12(input);
   const stats2 = safeStat(resolved);
   if (stats2?.isFile())
-    return dirname7(resolved);
+    return dirname8(resolved);
   return resolved;
 }
 function findUp(start, marker) {
   let current = canonicalPath(start);
   while (true) {
-    if (existsSync10(resolve11(current, marker)))
+    if (existsSync11(resolve12(current, marker)))
       return current;
-    const parent = dirname7(current);
+    const parent = dirname8(current);
     if (parent === current)
       return null;
     current = parent;
@@ -26307,8 +27018,8 @@ function findUp(start, marker) {
 function readPackageJson2(path) {
   if (!path)
     return null;
-  const file = resolve11(path, "package.json");
-  if (!existsSync10(file))
+  const file = resolve12(path, "package.json");
+  if (!existsSync11(file))
     return null;
   try {
     const parsed = JSON.parse(readFileSync8(file, "utf-8"));
@@ -26319,9 +27030,9 @@ function readPackageJson2(path) {
 }
 function packageDisplayName(name, fallbackPath) {
   if (!name)
-    return basename2(fallbackPath);
+    return basename3(fallbackPath);
   const withoutScope = name.startsWith("@") ? name.split("/")[1] : name;
-  return withoutScope || basename2(fallbackPath);
+  return withoutScope || basename3(fallbackPath);
 }
 function workspaceMarker(root, rootPackage) {
   if (!root)
@@ -26330,7 +27041,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 (existsSync10(resolve11(root, marker)))
+    if (existsSync11(resolve12(root, marker)))
       markers.push(marker);
   }
   const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
@@ -26448,177 +27159,9 @@ function getProjectByPathForBootstrap(path, db) {
      WHERE pmp.path = ?`).get(path);
   return machineRow ?? null;
 }
-// src/lib/task-routing.ts
-init_database();
-function classifyProjectKind2(path) {
-  if (!path)
-    return null;
-  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
-}
-function machineLocalPath(project, db) {
-  const machineId = process.env["TODOS_MACHINE_ID"];
-  if (!machineId)
-    return null;
-  try {
-    const row = db.query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
-    return row?.path ?? null;
-  } catch {
-    return null;
-  }
-}
-function resolveProject(task2, db) {
-  const project = task2.project_id ? getProject(task2.project_id, db) : null;
-  const projectPath = project ? machineLocalPath(project, db) ?? project.path : task2.working_dir;
-  return { project, projectPath: projectPath ?? null };
-}
-function resolveTaskList(task2, project, db) {
-  if (task2.task_list_id) {
-    return getTaskList(task2.task_list_id, db) ?? (project ? getTaskListBySlug(task2.task_list_id, project.id, db) : null);
-  }
-  if (project?.task_list_id) {
-    return getTaskListBySlug(project.task_list_id, project.id, db);
-  }
-  return null;
-}
-function isTerminal2(status) {
-  return status === "completed" || status === "cancelled" || status === "failed";
-}
-function routeConcurrencyKey(task2, project, taskList, projectPath) {
-  if (project?.id)
-    return `project:${project.id}`;
-  if (taskList?.id)
-    return `task-list:${taskList.id}`;
-  if (projectPath)
-    return `path:${projectPath}`;
-  return `task:${task2.id}`;
-}
-function getTaskRouteState(taskOrId, db) {
-  const d = db || getDatabase();
-  const task2 = typeof taskOrId === "string" ? getTask(taskOrId, d) : taskOrId;
-  if (!task2)
-    throw new Error(`Task not found: ${taskOrId}`);
-  const { project, projectPath } = resolveProject(task2, d);
-  const taskList = resolveTaskList(task2, project, d);
-  const automation = routingAutomationMetadata(task2, taskList) ?? {};
-  const routeEnabled = routeEnabledForTask(task2, taskList) === true;
-  const tagOptIn = task2.tags.includes("auto:route") || task2.tags.includes("route:enabled");
-  const locked = Boolean(task2.locked_by && !isLockExpired(task2.locked_at));
-  const blockers = getBlockingDeps(task2.id, d);
-  const blocked = blockers.length > 0;
-  const terminal = isTerminal2(task2.status);
-  const requiresApproval = automation.requires_approval === true || task2.requires_approval === true;
-  const approvalRequired = automation.approval_required === true;
-  const approved = Boolean(task2.approved_by);
-  const gates = {
-    route_enabled: routeEnabled,
-    tag_opt_in: tagOptIn,
-    no_auto: automation.no_auto === true,
-    manual: automation.manual === true,
-    manual_required: automation.manual_required === true,
-    requires_approval: requiresApproval,
-    approval_required: approvalRequired,
-    approved,
-    locked,
-    blocked,
-    terminal
-  };
-  const reasons = [];
-  if (task2.status !== "pending")
-    reasons.push("task_not_pending");
-  if (terminal)
-    reasons.push("task_terminal");
-  if (!routeEnabled)
-    reasons.push("route_not_enabled");
-  if (locked)
-    reasons.push("task_locked");
-  if (blocked)
-    reasons.push("task_blocked");
-  if (gates.no_auto)
-    reasons.push("no_auto");
-  if (gates.manual)
-    reasons.push("manual");
-  if (gates.manual_required)
-    reasons.push("manual_required");
-  if (requiresApproval && !approved)
-    reasons.push("requires_approval");
-  if (approvalRequired && !approved)
-    reasons.push("approval_required");
-  if (automation.allowed === false)
-    reasons.push("automation_disallowed");
-  return {
-    schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
-    task_id: task2.id,
-    task_short_id: task2.short_id,
-    status: task2.status,
-    eligible: reasons.length === 0,
-    reasons,
-    blockers: blockers.map((blocker) => ({
-      id: blocker.id,
-      short_id: blocker.short_id,
-      title: blocker.title,
-      status: blocker.status
-    })),
-    gates,
-    automation: Object.keys(automation).length > 0 ? automation : null,
-    route: {
-      project_id: project?.id ?? task2.project_id,
-      project_path: projectPath,
-      working_dir: task2.working_dir ?? projectPath,
-      project_kind: classifyProjectKind2(projectPath),
-      task_list_id: taskList?.id ?? task2.task_list_id,
-      task_list_slug: taskList?.slug ?? null,
-      task_list_name: taskList?.name ?? null,
-      concurrency_key: routeConcurrencyKey(task2, project, taskList, projectPath)
-    },
-    pointers: workflowPointersFromMetadata(task2.metadata)
-  };
-}
-function setTaskWorkflowPointers(taskId, input, db) {
-  const d = db || getDatabase();
-  const task2 = getTask(taskId, d);
-  if (!task2)
-    throw new Error(`Task not found: ${taskId}`);
-  const previous = workflowPointersFromMetadata(task2.metadata);
-  const next = compactWorkflowPointers({
-    current_workflow_invocation_id: pointerPatch(previous.current_workflow_invocation_id, input, "current_workflow_invocation_id"),
-    current_run_id: pointerPatch(previous.current_run_id, input, "current_run_id"),
-    latest_manifest_path: pointerPatch(previous.latest_manifest_path, input, "latest_manifest_path"),
-    latest_evaluation_path: pointerPatch(previous.latest_evaluation_path, input, "latest_evaluation_path"),
-    workflow_state: pointerPatch(previous.workflow_state, input, "workflow_state")
-  });
-  const timestamp2 = now();
-  const {
-    current_workflow_invocation_id,
-    current_run_id,
-    latest_manifest_path,
-    latest_evaluation_path,
-    workflow_state,
-    workflow_invocation,
-    ...baseMetadata
-  } = task2.metadata;
-  const metadata = {
-    ...baseMetadata,
-    ...next,
-    workflow_invocation: {
-      schema_version: TASK_WORKFLOW_POINTER_SCHEMA_VERSION,
-      ...next,
-      updated_at: timestamp2,
-      updated_by: input.actor ?? null
-    }
-  };
-  return updateTask(task2.id, { version: task2.version, metadata }, d);
-}
-function pointerPatch(previous, input, key) {
-  if (!Object.prototype.hasOwnProperty.call(input, key))
-    return previous;
-  const value = input[key];
-  if (value === undefined)
-    return previous;
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
 // src/db/api-keys.ts
 init_database();
-import { createHash as createHash10, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash11, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -26632,7 +27175,7 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key) {
-  return createHash10("sha256").update(key).digest("hex");
+  return createHash11("sha256").update(key).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
@@ -26823,18 +27366,18 @@ var gatherTrainingData = async (options = {}) => {
 };
 // src/lib/model-config.ts
 init_sync_utils();
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { join as join12 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
 function getConfigDir() {
   return getTodosGlobalDir();
 }
 function getConfigPath2() {
-  return join11(getConfigDir(), "config.json");
+  return join12(getConfigDir(), "config.json");
 }
 function readConfig() {
   const configPath = getConfigPath2();
-  if (!existsSync11(configPath))
+  if (!existsSync12(configPath))
     return {};
   try {
     const raw = readFileSync9(configPath, "utf-8");
@@ -26845,7 +27388,7 @@ function readConfig() {
 }
 function writeConfig(config) {
   const configDir = getConfigDir();
-  if (!existsSync11(configDir)) {
+  if (!existsSync12(configDir)) {
     mkdirSync9(configDir, { recursive: true });
   }
   writeFileSync7(getConfigPath2(), JSON.stringify(config, null, 2) + `
@@ -27570,7 +28113,7 @@ CLI equivalent: \`${r.equivalent_cli}\`
 `);
 }
 // src/lib/verification-providers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 init_database();
 init_config();
 init_redaction();
@@ -27681,7 +28224,7 @@ function classifyLog(text) {
 async function sleep2(ms) {
   if (ms <= 0)
     return;
-  await new Promise((resolve12) => setTimeout(resolve12, ms));
+  await new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 async function runCommandProvider(provider, input) {
   const commandTemplate = input.command || provider.command;
@@ -27736,7 +28279,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync10(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync13(input.log_path) ? readFileSync10(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -27748,7 +28291,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 (!existsSync12(input.artifact_path)) {
+  if (!existsSync13(input.artifact_path)) {
     return { status: "failed", attempts: 1, exit_code: null, output_summary: `artifact not found: ${input.artifact_path}` };
   }
   return {
@@ -27913,7 +28456,7 @@ function listVerificationRecords(filter = {}, db) {
 // src/lib/verification-evidence.ts
 init_database();
 import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 var VERIFICATION_EVIDENCE_SCHEMA = "todos.verification_evidence.v1";
 function getMachineId3() {
   return process.env["TODOS_MACHINE_ID"] || __require("os").hostname();
@@ -28033,15 +28576,15 @@ function exportVerificationEvidence(filter = {}, db) {
   };
 }
 function writeVerificationExport(bundle, path) {
-  mkdirSync10(dirname8(path), { recursive: true });
+  mkdirSync10(dirname9(path), { recursive: true });
   writeFileSync8(path, JSON.stringify(bundle, null, 2), "utf8");
 }
 // src/lib/policy-packs.ts
-import { relative as relative3, resolve as resolve12 } from "path";
+import { relative as relative3, resolve as resolve13 } from "path";
 init_database();
 init_config();
-function normalizePath3(path) {
-  return resolve12(path);
+function normalizePath4(path) {
+  return resolve13(path);
 }
 function unique4(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
@@ -28051,13 +28594,13 @@ function parseStatuses(values) {
   return unique4(values).filter((value) => allowed.has(value));
 }
 function configuredPacks(config = loadConfig()) {
-  return Object.values(config.policy_packs || {}).map((pack) => ({ ...pack, root: normalizePath3(pack.root) })).sort((a, b) => a.name.localeCompare(b.name));
+  return Object.values(config.policy_packs || {}).map((pack) => ({ ...pack, root: normalizePath4(pack.root) })).sort((a, b) => a.name.localeCompare(b.name));
 }
 function defaultPolicyPack(name, root) {
   return {
     name,
     version: 1,
-    root: normalizePath3(root),
+    root: normalizePath4(root),
     required_commands: [],
     prohibited_commands: ["npm install -g", "git reset --hard", "git checkout --", "rm -rf"],
     prohibited_paths: [],
@@ -28075,7 +28618,7 @@ function isPathInside3(root, path) {
   const rel = relative3(root, path);
   return rel === "" || !rel.startsWith("..") && !rel.startsWith("/") && !/^[A-Za-z]:/.test(rel);
 }
-function matchesPattern3(value, pattern) {
+function matchesPattern4(value, pattern) {
   const normalizedValue = value.toLowerCase();
   const normalizedPattern = pattern.toLowerCase();
   if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
@@ -28092,14 +28635,14 @@ function matchesPattern3(value, pattern) {
   return normalizedValue === normalizedPattern || normalizedValue.includes(normalizedPattern);
 }
 function commandMatches(commands, pattern) {
-  return commands.filter((command) => matchesPattern3(command, pattern));
+  return commands.filter((command) => matchesPattern4(command, pattern));
 }
 function pathMatches(paths, pattern, root) {
   return paths.filter((path) => {
-    const candidate = path.startsWith("/") ? path : resolve12(root, path);
+    const candidate = path.startsWith("/") ? path : resolve13(root, path);
     if (!isPathInside3(root, candidate))
-      return matchesPattern3(path, pattern);
-    return matchesPattern3(path, pattern) || matchesPattern3(relative3(root, candidate), pattern);
+      return matchesPattern4(path, pattern);
+    return matchesPattern4(path, pattern) || matchesPattern4(relative3(root, candidate), pattern);
   });
 }
 function finding(id, passed, message, evidence = []) {
@@ -28178,7 +28721,7 @@ function getPolicyPack(name) {
 function upsertPolicyPack(input) {
   const config = loadConfig();
   const existing = config.policy_packs?.[input.name];
-  const root = normalizePath3(input.root || existing?.root || process.cwd());
+  const root = normalizePath4(input.root || existing?.root || process.cwd());
   const base = existing || defaultPolicyPack(input.name, root);
   const timestamp2 = new Date().toISOString();
   const pack = {
@@ -28258,7 +28801,7 @@ function validatePolicyPack(input, db) {
     findings.push(finding("linked-pull-request", refs.length > 0, "at least one linked pull request is required", refs.map((ref) => ref.name)));
   }
   if (pack.branch_pattern) {
-    const branches = evidence.gitRefs.filter((ref) => ref.ref_type === "branch" && matchesPattern3(ref.name, pack.branch_pattern));
+    const branches = evidence.gitRefs.filter((ref) => ref.ref_type === "branch" && matchesPattern4(ref.name, pack.branch_pattern));
     findings.push(finding("branch-pattern", branches.length > 0, `at least one linked branch must match: ${pack.branch_pattern}`, branches.map((ref) => ref.name)));
   }
   if (pack.require_approval) {
@@ -28387,21 +28930,21 @@ function resourceDiagnostics() {
   };
 }
 // src/lib/sandbox-profiles.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11 } from "fs";
-import { join as join12, dirname as dirname9 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11 } from "fs";
+import { join as join13, dirname as dirname10 } from "path";
 var SANDBOX_PROFILE_VERSION = "todos.sandbox-profile.v1";
 function getProfilesPath() {
   if (process.env["TODOS_SANDBOX_PROFILES_PATH"]) {
     return process.env["TODOS_SANDBOX_PROFILES_PATH"];
   }
-  const localDir = join12(process.cwd(), ".todos");
-  const local = join12(localDir, "sandbox-profiles.json");
-  if (existsSync13(localDir))
+  const localDir = join13(process.cwd(), ".todos");
+  const local = join13(localDir, "sandbox-profiles.json");
+  if (existsSync14(localDir))
     return local;
-  if (existsSync13(local))
+  if (existsSync14(local))
     return local;
   const home = process.env["HOME"] || "~";
-  return join12(home, ".hasna", "todos", "sandbox-profiles.json");
+  return join13(home, ".hasna", "todos", "sandbox-profiles.json");
 }
 var cached2 = null;
 function resetSandboxProfileCache() {
@@ -28433,7 +28976,7 @@ function loadSandboxProfiles() {
   if (cached2)
     return cached2;
   const path = getProfilesPath();
-  if (!existsSync13(path)) {
+  if (!existsSync14(path)) {
     cached2 = getDefaultSandboxProfiles();
     return cached2;
   }
@@ -28446,7 +28989,7 @@ function getSandboxProfile(name) {
 }
 function saveSandboxProfiles(profiles) {
   const path = getProfilesPath();
-  mkdirSync11(dirname9(path), { recursive: true });
+  mkdirSync11(dirname10(path), { recursive: true });
   writeFileSync9(path, JSON.stringify({ schema_version: SANDBOX_PROFILE_VERSION, profiles }, null, 2));
   cached2 = profiles;
 }
@@ -28806,9 +29349,9 @@ function getDefaultAgentAdapters() {
 }
 function resetAgentAdapterCache() {}
 // src/lib/git-traceability.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 var GIT_TRACEABILITY_SCHEMA_VERSION = "todos.git_traceability.v1";
 function runGit(args, cwd) {
   const result = spawnSync2("git", args, { cwd, encoding: "utf8" });
@@ -28851,8 +29394,8 @@ function inspectGitCommit(sha, cwd) {
   };
 }
 function loadCiSnapshot(path) {
-  const target = path ? resolve13(path) : resolve13(process.cwd(), ".todos", "ci-snapshot.json");
-  if (!existsSync14(target))
+  const target = path ? resolve14(path) : resolve14(process.cwd(), ".todos", "ci-snapshot.json");
+  if (!existsSync15(target))
     return null;
   try {
     const parsed = JSON.parse(readFileSync12(target, "utf8"));
@@ -28948,8 +29491,8 @@ function formatTraceabilityReport(report) {
 `);
 }
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync15, readdirSync as readdirSync2, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
-import { basename as basename3, isAbsolute, join as join13, relative as relative4, resolve as resolve14, sep as sep2 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync3, readFileSync as readFileSync13, statSync as statSync5 } from "fs";
+import { basename as basename4, isAbsolute, join as join14, relative as relative4, resolve as resolve15, sep as sep2 } from "path";
 init_database();
 var PREFIXES = {
   file: "file",
@@ -29025,7 +29568,7 @@ function backlink(kind, key, label, target = key) {
   return { kind, key, label, target };
 }
 function normalizeWorkspace(workspace) {
-  return resolve14(workspace || process.cwd());
+  return resolve15(workspace || process.cwd());
 }
 function isInside(root, absolutePath) {
   const rel = relative4(root, absolutePath);
@@ -29093,18 +29636,18 @@ function resolveFile(parsed, workspace) {
     resolution.warnings.push("path is empty or escapes the workspace");
     return resolution;
   }
-  const absolutePath = resolve14(workspace, relPath);
+  const absolutePath = resolve15(workspace, relPath);
   if (!isInside(workspace, absolutePath)) {
     resolution.path = relPath;
     resolution.warnings.push("path escapes the workspace");
     return resolution;
   }
   resolution.path = relPath;
-  if (!existsSync15(absolutePath)) {
+  if (!existsSync16(absolutePath)) {
     resolution.warnings.push("file does not exist in the local workspace");
     return resolution;
   }
-  const stats2 = statSync4(absolutePath);
+  const stats2 = statSync5(absolutePath);
   if (!stats2.isFile()) {
     resolution.warnings.push("path exists but is not a file");
     return resolution;
@@ -29128,12 +29671,12 @@ function resolveFile(parsed, workspace) {
 function walkSourceFiles(root, current = root, files = []) {
   if (files.length >= 5000)
     return files;
-  for (const entry2 of readdirSync2(current, { withFileTypes: true })) {
+  for (const entry2 of readdirSync3(current, { withFileTypes: true })) {
     if (entry2.name.startsWith(".") && ![".github"].includes(entry2.name)) {
       if (SKIP_DIRS.has(entry2.name))
         continue;
     }
-    const absolutePath = join13(current, entry2.name);
+    const absolutePath = join14(current, entry2.name);
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name))
         walkSourceFiles(root, absolutePath, files);
@@ -29141,8 +29684,8 @@ function walkSourceFiles(root, current = root, files = []) {
     }
     if (!entry2.isFile())
       continue;
-    const extension = `.${basename3(entry2.name).split(".").pop() || ""}`;
-    if (SOURCE_EXTENSIONS.has(extension) && statSync4(absolutePath).size <= 512 * 1024) {
+    const extension = `.${basename4(entry2.name).split(".").pop() || ""}`;
+    if (SOURCE_EXTENSIONS.has(extension) && statSync5(absolutePath).size <= 512 * 1024) {
       files.push(absolutePath);
     }
   }
@@ -31013,9 +31556,9 @@ function getAdapterDocsFingerprint() {
 }
 // src/lib/inbox-intake.ts
 init_database();
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import { basename as basename4 } from "path";
-import { createHash as createHash11 } from "crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { basename as basename5 } from "path";
+import { createHash as createHash12 } from "crypto";
 init_secret_redaction();
 var INBOX_INTAKE_SCHEMA = "todos.inbox_intake.v1";
 var INTAKE_SOURCE_TYPES = [
@@ -31028,7 +31571,7 @@ var INTAKE_SOURCE_TYPES = [
 ];
 var INTAKE_TRIAGE_STATUSES = ["preview", "triaged", "duplicate", "created"];
 function fingerprint2(text) {
-  return createHash11("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadRawContent(input) {
   if (input.github_url) {
@@ -31059,15 +31602,15 @@ function loadRawContent(input) {
     }
   }
   if (input.file_path) {
-    if (!existsSync16(input.file_path))
+    if (!existsSync17(input.file_path))
       throw new Error(`File not found: ${input.file_path}`);
     const raw = readFileSync14(input.file_path, "utf8");
-    const name = basename4(input.file_path).toLowerCase();
+    const name = basename5(input.file_path).toLowerCase();
     const source_type2 = input.source_type ?? (name.includes("ci") || name.endsWith(".log") ? "ci_log" : "file");
     return {
       raw,
       source_type: source_type2,
-      metadata: { file_path: input.file_path, file_name: basename4(input.file_path) }
+      metadata: { file_path: input.file_path, file_name: basename5(input.file_path) }
     };
   }
   const text = input.text?.trim();
@@ -31677,7 +32220,7 @@ function formatNlIntakePreviewText(preview) {
 }
 // src/lib/issue-importers.ts
 init_database();
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "fs";
 var ISSUE_IMPORT_SCHEMA = "todos.issue_import.v1";
 var ISSUE_SOURCES = ["github", "linear", "jira", "auto"];
 var GITHUB_LABEL_PRIORITY = {
@@ -31896,7 +32439,7 @@ function parseIssueExport(data, source9 = "auto") {
   return normalized;
 }
 function loadIssueExportFromFile(path) {
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     throw new Error(`File not found: ${path}`);
   return JSON.parse(readFileSync15(path, "utf8"));
 }
@@ -32056,8 +32599,8 @@ todos import issues ./linear.json --source linear --dry-run
 // src/lib/run-records.ts
 init_database();
 init_secret_redaction();
-import { existsSync as existsSync18, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10 } from "fs";
-import { join as join14, dirname as dirname10 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10 } from "fs";
+import { join as join15, dirname as dirname11 } from "path";
 var RUN_RECORD_SCHEMA = "todos.run_record.v1";
 var RUN_RECORD_STATUSES = ["active", "completed", "failed", "archived"];
 function parseJsonArray3(raw, fallback = []) {
@@ -32250,8 +32793,8 @@ function buildRunReplayBundle(id, db) {
 }
 function exportRunReplay(id, outputPath, db) {
   const bundle = buildRunReplayBundle(id, db);
-  const path = outputPath ?? join14(process.cwd(), ".todos", "replays", `${id.slice(0, 8)}.json`);
-  mkdirSync12(dirname10(path), { recursive: true });
+  const path = outputPath ?? join15(process.cwd(), ".todos", "replays", `${id.slice(0, 8)}.json`);
+  mkdirSync12(dirname11(path), { recursive: true });
   writeFileSync10(path, JSON.stringify(bundle, null, 2));
   const d = db || getDatabase();
   d.run(`UPDATE run_records SET replay_bundle = ?, updated_at = ? WHERE id = ?`, [path, now(), id]);
@@ -32290,16 +32833,16 @@ function formatRunRecordMarkdown(record) {
 `;
 }
 function getDefaultReplayDir() {
-  const local = join14(process.cwd(), ".todos", "replays");
-  if (existsSync18(join14(process.cwd(), ".todos")))
+  const local = join15(process.cwd(), ".todos", "replays");
+  if (existsSync19(join15(process.cwd(), ".todos")))
     return local;
   const home = process.env["HOME"] || "~";
-  return join14(home, ".hasna", "todos", "replays");
+  return join15(home, ".hasna", "todos", "replays");
 }
 // src/lib/release-checks.ts
 init_secret_redaction();
-import { existsSync as existsSync19, readFileSync as readFileSync16, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
-import { join as join15, relative as relative5 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync16, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
+import { join as join16, relative as relative5 } from "path";
 var RELEASE_CHECK_SCHEMA = "todos.release_check.v1";
 var FORBIDDEN_DIST_PATTERNS = [
   {
@@ -32312,17 +32855,17 @@ var FORBIDDEN_DIST_PATTERNS = [
 ];
 var REQUIRED_BINS = ["todos", "todos-mcp", "todos-serve"];
 function readPackageJson3(root) {
-  const path = join15(root, "package.json");
-  if (!existsSync19(path))
+  const path = join16(root, "package.json");
+  if (!existsSync20(path))
     throw new Error(`package.json not found in ${root}`);
   return JSON.parse(readFileSync16(path, "utf8"));
 }
 function walkFiles(dir, acc = []) {
-  if (!existsSync19(dir))
+  if (!existsSync20(dir))
     return acc;
-  for (const entry2 of readdirSync3(dir)) {
-    const full = join15(dir, entry2);
-    const st = statSync5(full);
+  for (const entry2 of readdirSync4(dir)) {
+    const full = join16(dir, entry2);
+    const st = statSync6(full);
     if (st.isDirectory())
       walkFiles(full, acc);
     else if (/\.(js|mjs|cjs|json|d\.ts)$/.test(entry2))
@@ -32339,8 +32882,8 @@ function auditPackageContents(root) {
     checks.push({ id: "files_dist", severity: "error", message: "package.json files must include dist" });
   }
   for (const pattern of files) {
-    const target = join15(root, pattern);
-    if (!existsSync19(target)) {
+    const target = join16(root, pattern);
+    if (!existsSync20(target)) {
       checks.push({ id: `files_missing_${pattern}`, severity: "error", message: `Published file path missing: ${pattern}` });
     }
   }
@@ -32354,8 +32897,8 @@ function auditPackageContents(root) {
       checks.push({ id: `bin_${name}`, severity: "error", message: `Missing bin entry: ${name}` });
       continue;
     }
-    const binPath = join15(root, rel);
-    if (!existsSync19(binPath)) {
+    const binPath = join16(root, rel);
+    if (!existsSync20(binPath)) {
       checks.push({ id: `bin_path_${name}`, severity: "error", message: `Bin file missing: ${rel}` });
     } else {
       checks.push({ id: `bin_ok_${name}`, severity: "info", message: `Bin present: ${name} \u2192 ${rel}` });
@@ -32372,8 +32915,8 @@ function auditPackageContents(root) {
 }
 function scanDistArtifacts(root) {
   const checks = [];
-  const distDir = join15(root, "dist");
-  if (!existsSync19(distDir)) {
+  const distDir = join16(root, "dist");
+  if (!existsSync20(distDir)) {
     checks.push({ id: "dist_missing", severity: "error", message: "dist/ directory not found \u2014 run bun run build" });
     return checks;
   }
@@ -32679,15 +33222,15 @@ function renderReleaseNotesMarkdown(document) {
 // src/lib/db-backup.ts
 init_database();
 init_migrations();
-import { existsSync as existsSync20, copyFileSync, mkdirSync as mkdirSync13, readFileSync as readFileSync17, statSync as statSync6, writeFileSync as writeFileSync11, unlinkSync } from "fs";
-import { dirname as dirname11, join as join16, resolve as resolve15 } from "path";
-import { Database as Database3 } from "bun:sqlite";
+import { existsSync as existsSync21, copyFileSync, mkdirSync as mkdirSync13, readFileSync as readFileSync17, statSync as statSync7, writeFileSync as writeFileSync11, unlinkSync } from "fs";
+import { dirname as dirname12, join as join17, resolve as resolve16 } from "path";
+import { Database as Database4 } from "bun:sqlite";
 var DB_BACKUP_SCHEMA = "todos.db_backup.v1";
 function resolveDbPath(dbPath) {
   if (dbPath)
-    return resolve15(dbPath);
+    return resolve16(dbPath);
   if (process.env["TODOS_DB_PATH"] && process.env["TODOS_DB_PATH"] !== ":memory:") {
-    return resolve15(process.env["TODOS_DB_PATH"]);
+    return resolve16(process.env["TODOS_DB_PATH"]);
   }
   const db = getDatabase();
   const filename = db.filename;
@@ -32697,11 +33240,11 @@ function resolveDbPath(dbPath) {
 }
 function backupDatabase(outputPath, sourcePath) {
   const source9 = resolveDbPath(sourcePath);
-  if (!existsSync20(source9))
+  if (!existsSync21(source9))
     throw new Error(`Database not found: ${source9}`);
-  mkdirSync13(dirname11(outputPath), { recursive: true });
+  mkdirSync13(dirname12(outputPath), { recursive: true });
   closeDatabase();
-  const src = new Database3(source9);
+  const src = new Database4(source9);
   try {
     src.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   } catch {}
@@ -32709,7 +33252,7 @@ function backupDatabase(outputPath, sourcePath) {
   src.close();
   writeFileSync11(outputPath, image);
   const method = "file_copy";
-  const bytes = statSync6(outputPath).size;
+  const bytes = statSync7(outputPath).size;
   return {
     schema_version: DB_BACKUP_SCHEMA,
     source_path: source9,
@@ -32720,14 +33263,14 @@ function backupDatabase(outputPath, sourcePath) {
   };
 }
 function restoreDatabase(backupPath, targetPath) {
-  if (!existsSync20(backupPath))
+  if (!existsSync21(backupPath))
     throw new Error(`Backup not found: ${backupPath}`);
   const integrity = checkDatabaseIntegrity(backupPath);
   if (!integrity.ok) {
     throw new Error(`Backup failed integrity check: ${integrity.errors.join("; ")}`);
   }
-  const target = targetPath ? resolve15(targetPath) : resolveDbPath();
-  mkdirSync13(dirname11(target), { recursive: true });
+  const target = targetPath ? resolve16(targetPath) : resolveDbPath();
+  mkdirSync13(dirname12(target), { recursive: true });
   const staging = `${target}.restore.tmp`;
   copyFileSync(backupPath, staging);
   copyFileSync(staging, target);
@@ -32739,15 +33282,15 @@ function restoreDatabase(backupPath, targetPath) {
     schema_version: DB_BACKUP_SCHEMA,
     source_path: backupPath,
     backup_path: target,
-    bytes: statSync6(target).size,
+    bytes: statSync7(target).size,
     method: "file_copy",
     created_at: new Date().toISOString()
   };
 }
 function checkDatabaseIntegrity(dbPath) {
-  const path = dbPath ? resolve15(dbPath) : resolveDbPath();
+  const path = dbPath ? resolve16(dbPath) : resolveDbPath();
   const errors = [];
-  if (!existsSync20(path)) {
+  if (!existsSync21(path)) {
     return {
       schema_version: DB_BACKUP_SCHEMA,
       path,
@@ -32760,7 +33303,7 @@ function checkDatabaseIntegrity(dbPath) {
   }
   let db;
   try {
-    db = new Database3(path, { readonly: true });
+    db = new Database4(path, { readonly: true });
   } catch (e) {
     return {
       schema_version: DB_BACKUP_SCHEMA,
@@ -32810,18 +33353,18 @@ function checkDatabaseIntegrity(dbPath) {
   };
 }
 function compactDatabase(dbPath) {
-  const path = dbPath ? resolve15(dbPath) : resolveDbPath();
-  const before = statSync6(path).size;
-  const db = new Database3(path);
+  const path = dbPath ? resolve16(dbPath) : resolveDbPath();
+  const before = statSync7(path).size;
+  const db = new Database4(path);
   db.exec("VACUUM");
   db.close();
-  const after = statSync6(path).size;
+  const after = statSync7(path).size;
   closeDatabase();
   return { path, bytes_before: before, bytes_after: after };
 }
 function migrationDryRun(dbPath) {
-  const path = dbPath ? resolve15(dbPath) : resolveDbPath();
-  const db = new Database3(path, { readonly: true });
+  const path = dbPath ? resolve16(dbPath) : resolveDbPath();
+  const db = new Database4(path, { readonly: true });
   let current = 0;
   try {
     const row = db.query("SELECT MAX(id) as id FROM _migrations").get();
@@ -32844,13 +33387,13 @@ function migrationDryRun(dbPath) {
   };
 }
 function defaultBackupPath(dbPath) {
-  const base = dbPath ? dirname11(resolve15(dbPath)) : dirname11(resolveDbPath());
+  const base = dbPath ? dirname12(resolve16(dbPath)) : dirname12(resolveDbPath());
   const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-  return join16(base, "backups", `todos-${stamp}.db`);
+  return join17(base, "backups", `todos-${stamp}.db`);
 }
 function readBackupManifest(backupPath) {
   const manifestPath = `${backupPath}.json`;
-  if (!existsSync20(manifestPath))
+  if (!existsSync21(manifestPath))
     return null;
   try {
     return JSON.parse(readFileSync17(manifestPath, "utf8"));
@@ -32863,7 +33406,7 @@ function writeBackupManifest(backupPath, result) {
   writeFileSyncSafe(manifestPath, JSON.stringify(result, null, 2));
 }
 function writeFileSyncSafe(path, content) {
-  mkdirSync13(dirname11(path), { recursive: true });
+  mkdirSync13(dirname12(path), { recursive: true });
   writeFileSync11(path, content);
 }
 // src/lib/json-schemas.ts
@@ -32927,6 +33470,7 @@ var JSON_SCHEMAS = {
   plan: def("plan", "todos.plan.v1", "Plan", ["schema_version", "id", "name", "status", "created_at", "updated_at"], {
     schema_version: { type: "string", enum: ["todos.plan.v1"] },
     id: { type: "string" },
+    slug: { type: ["string", "null"] },
     project_id: { type: ["string", "null"] },
     name: { type: "string" },
     description: { type: ["string", "null"] },
@@ -33370,15 +33914,15 @@ ${SCHEMA_ENTITIES.map((e) => `- **${e}**: \`${JSON_SCHEMAS[e].schema_version}\``
 }
 function exportSchemasToDirectory(dir) {
   const { mkdirSync: mkdirSync14, writeFileSync: writeFileSync12 } = __require("fs");
-  const { join: join17 } = __require("path");
+  const { join: join18 } = __require("path");
   mkdirSync14(dir, { recursive: true });
   const written = [];
   for (const entity of SCHEMA_ENTITIES) {
-    const path = join17(dir, `${entity}.${JSON_SCHEMAS[entity].schema_version.replace(/\./g, "-")}.json`);
+    const path = join18(dir, `${entity}.${JSON_SCHEMAS[entity].schema_version.replace(/\./g, "-")}.json`);
     writeFileSync12(path, JSON.stringify(JSON_SCHEMAS[entity], null, 2));
     written.push(path);
   }
-  const catalogPath = join17(dir, "catalog.json");
+  const catalogPath = join18(dir, "catalog.json");
   writeFileSync12(catalogPath, JSON.stringify({
     catalog_version: JSON_SCHEMA_CATALOG_VERSION,
     semver: SCHEMA_SEMVER,
@@ -34279,7 +34823,7 @@ function getReminderDocs() {
 // src/lib/import-export-bridge.ts
 init_database();
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14 } from "fs";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 init_secret_redaction();
 var BUNDLE_SCHEMA = "todos.bundle.v1";
 var BUNDLE_TYPES = ["full_export", "tasks", "partial"];
@@ -34687,7 +35231,7 @@ function importBundle(bundle, options = {}, db) {
   return result;
 }
 function writeBundleFile(bundle, path) {
-  mkdirSync14(dirname12(path), { recursive: true });
+  mkdirSync14(dirname13(path), { recursive: true });
   writeFileSync12(path, JSON.stringify(bundle, null, 2), "utf8");
 }
 function readBundleFile(path) {
@@ -35168,7 +35712,7 @@ function createPlanWithSteps(name, steps, opts = {}, db) {
 // src/lib/handoff-packets.ts
 init_database();
 import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync15 } from "fs";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 var HANDOFF_PACKET_SCHEMA = "todos.handoff_packet.v1";
 function summarizeTask2(t) {
   return {
@@ -35342,7 +35886,7 @@ function formatHandoffPacket(packet, format = "json") {
 function exportHandoffPacket(input = {}, path, db) {
   const packet = createHandoffPacket(input, db);
   if (path) {
-    mkdirSync15(dirname13(path), { recursive: true });
+    mkdirSync15(dirname14(path), { recursive: true });
     writeFileSync13(path, formatHandoffPacket(packet, "json"), "utf8");
   }
   return packet;
@@ -35947,7 +36491,7 @@ function generateCliReferenceMarkdown() {
 // src/db/builtin-templates.ts
 init_database();
 import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21";
 var BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library";
 var TEMPLATE_LIBRARY_SCHEMA = "todos.template_library.v1";
@@ -36223,7 +36767,7 @@ function writeBuiltinTemplateFiles(directory) {
   mkdirSync16(directory, { recursive: true });
   const files = [];
   for (const entry2 of exportBuiltinTemplateFiles()) {
-    const path = join17(directory, entry2.filename);
+    const path = join18(directory, entry2.filename);
     writeFileSync14(path, `${JSON.stringify(entry2.template, null, 2)}
 `, "utf-8");
     files.push(path);
@@ -36268,7 +36812,7 @@ function initBuiltinTemplates(db) {
 // src/lib/template-library.ts
 init_database();
 import { writeFileSync as writeFileSync15, readFileSync as readFileSync19, mkdirSync as mkdirSync17 } from "fs";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 function listTemplateLibrary(db) {
   const d = db || getDatabase();
   const installed = new Set(listTemplates(d).map((t) => t.name));
@@ -36310,7 +36854,7 @@ function exportTemplateLibraryCatalog(path, db) {
     templates: listTemplateLibrary(db)
   };
   if (path) {
-    mkdirSync17(dirname14(path), { recursive: true });
+    mkdirSync17(dirname15(path), { recursive: true });
     writeFileSync15(path, JSON.stringify(catalog, null, 2), "utf8");
   }
   return catalog;
@@ -36370,11 +36914,11 @@ init_database();
 init_machines();
 import { hostname as hostname2 } from "os";
 var MACHINE_TOPOLOGY_SCHEMA = "todos.machine_topology.v1";
-function normalizePath4(p) {
+function normalizePath5(p) {
   return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
 function detectCasingMismatch(stored, canonical) {
-  return normalizePath4(stored) === normalizePath4(canonical) && stored !== canonical;
+  return normalizePath5(stored) === normalizePath5(canonical) && stored !== canonical;
 }
 function registerLocalMachine(db) {
   resetMachineId();
@@ -36393,7 +36937,7 @@ function getPathOverrides(db) {
       project_name: project?.name ?? row.project_id.slice(0, 8),
       machine_id: row.machine_id,
       path: row.path,
-      path_normalized: normalizePath4(row.path),
+      path_normalized: normalizePath5(row.path),
       casing_mismatch: detectCasingMismatch(row.path, canonical)
     };
   });
@@ -36505,10 +37049,10 @@ todos machines topology      # full diagnostic report
 `;
 }
 // src/lib/environment-snapshots.ts
-import { createHash as createHash12 } from "crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync20, statSync as statSync7 } from "fs";
+import { createHash as createHash13 } from "crypto";
+import { existsSync as existsSync22, readFileSync as readFileSync20, statSync as statSync8 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
-import { dirname as dirname15, join as join18, resolve as resolve16 } from "path";
+import { dirname as dirname16, join as join19, resolve as resolve17 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 init_database();
 init_redaction();
@@ -36530,13 +37074,13 @@ var CONFIG_FILES = [
   "dashboard/vite.config.ts"
 ];
 function sha2565(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
-  const path = join18(root, relativePath);
-  if (!existsSync21(path))
+  const path = join19(root, relativePath);
+  if (!existsSync22(path))
     return null;
-  const stat = statSync7(path);
+  const stat = statSync8(path);
   if (!stat.isFile())
     return null;
   const content = readFileSync20(path);
@@ -36546,7 +37090,7 @@ function manifestRecord(root, relativePath) {
   const base = fileRecord(root, relativePath);
   if (!base)
     return null;
-  const parsed = readJsonFile(join18(root, relativePath));
+  const parsed = readJsonFile(join19(root, relativePath));
   if (!parsed)
     return { ...base, redacted: {} };
   const redacted = redactValue({
@@ -36641,15 +37185,15 @@ function commandEnv(env, includeValues) {
 function defaultSnapshotDir() {
   const dbPath = getDatabasePath();
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
-    return join18(tmpdir3(), "hasna-todos", "environment-snapshots");
-  return join18(dirname15(resolve16(dbPath)), "environment-snapshots");
+    return join19(tmpdir3(), "hasna-todos", "environment-snapshots");
+  return join19(dirname16(resolve17(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
   const digest = sha2565(JSON.stringify(snapshot)).slice(0, 24);
   return { id: `env_${digest}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
-  const root = resolve16(input.root || process.cwd());
+  const root = resolve17(input.root || process.cwd());
   const env = input.env || process.env;
   const warnings = [];
   const manifests = MANIFEST_FILES.map((file) => manifestRecord(root, file)).filter((file) => Boolean(file));
@@ -36689,13 +37233,13 @@ function captureEnvironmentSnapshot(input = {}) {
   });
 }
 function writeEnvironmentSnapshot(snapshot, outputPath) {
-  const path = outputPath ? resolve16(outputPath) : join18(defaultSnapshotDir(), `${snapshot.id}.json`);
-  ensureDir2(dirname15(path));
+  const path = outputPath ? resolve17(outputPath) : join19(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname16(path));
   writeJsonFile(path, snapshot);
   return path;
 }
 function readEnvironmentSnapshot(path) {
-  const snapshot = readJsonFile(resolve16(path));
+  const snapshot = readJsonFile(resolve17(path));
   if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
     throw new Error(`Invalid environment snapshot: ${path}`);
   }
@@ -36780,9 +37324,9 @@ function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
 }
 // src/lib/decision-records.ts
 init_database();
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname16, join as join19 } from "path";
+import { dirname as dirname17, join as join20 } from "path";
 var DECISION_RECORD_SCHEMA = "todos.decision_record.v1";
 var KNOWLEDGE_SNAPSHOT_SCHEMA = "todos.knowledge_snapshot.v1";
 var DECISION_STATUSES = ["proposed", "accepted", "deprecated", "superseded", "rejected"];
@@ -36836,7 +37380,7 @@ function rowToDecisionRecord(row) {
 }
 function stableSnapshotHash(payload) {
   const { captured_at: _capturedAt, ...rest } = payload;
-  return createHash13("sha256").update(JSON.stringify(rest)).digest("hex");
+  return createHash14("sha256").update(JSON.stringify(rest)).digest("hex");
 }
 function createDecisionRecord(input, db) {
   const d = db || getDatabase();
@@ -37012,8 +37556,8 @@ function exportDecisionRecord(id, outputPath, format = "markdown", db) {
   if (!record)
     throw new Error(`Decision record not found: ${id}`);
   const content = format === "markdown" ? formatDecisionRecordMarkdown(record) : JSON.stringify(record, null, 2);
-  const path = outputPath ?? join19(process.cwd(), ".todos", "decisions", `${record.short_ref}.${format === "markdown" ? "md" : "json"}`);
-  mkdirSync18(dirname16(path), { recursive: true });
+  const path = outputPath ?? join20(process.cwd(), ".todos", "decisions", `${record.short_ref}.${format === "markdown" ? "md" : "json"}`);
+  mkdirSync18(dirname17(path), { recursive: true });
   writeFileSync16(path, content, "utf8");
   return { path, content };
 }
@@ -37160,8 +37704,8 @@ function exportKnowledgeSnapshot(id, outputPath, format = "markdown", db) {
     throw new Error(`Knowledge snapshot not found: ${id}`);
   const content = format === "markdown" ? formatKnowledgeSnapshotMarkdown(record) : JSON.stringify(record, null, 2);
   const slug = record.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-  const path = outputPath ?? join19(process.cwd(), ".todos", "knowledge", `${slug || record.id.slice(0, 8)}.${format === "markdown" ? "md" : "json"}`);
-  mkdirSync18(dirname16(path), { recursive: true });
+  const path = outputPath ?? join20(process.cwd(), ".todos", "knowledge", `${slug || record.id.slice(0, 8)}.${format === "markdown" ? "md" : "json"}`);
+  mkdirSync18(dirname17(path), { recursive: true });
   writeFileSync16(path, content, "utf8");
   return { path, content };
 }
@@ -37189,7 +37733,7 @@ Schema versions:
 // src/lib/report-exports.ts
 init_database();
 import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync19 } from "fs";
-import { dirname as dirname17 } from "path";
+import { dirname as dirname18 } from "path";
 init_secret_redaction();
 var REPORT_EXPORT_SCHEMA = "todos.report_export.v1";
 var REPORT_KINDS = ["project", "plan", "run", "evidence", "roadmap", "retrospective"];
@@ -37421,7 +37965,7 @@ function formatReportExport(data, format) {
   return format === "html" ? formatReportHtml(data) : formatReportMarkdown(data);
 }
 function writeReportExport(data, format, path) {
-  mkdirSync19(dirname17(path), { recursive: true });
+  mkdirSync19(dirname18(path), { recursive: true });
   writeFileSync17(path, formatReportExport(data, format), "utf8");
 }
 function exportReport(input, db) {
@@ -37455,8 +37999,8 @@ todos report export --kind retrospective --days 14 --format markdown --out retro
 `;
 }
 // src/lib/command-aliases.ts
-import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync20 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync20 } from "fs";
+import { join as join21 } from "path";
 var COMMAND_ALIASES_SCHEMA = "todos.command_aliases.v1";
 var RESERVED = new Set([...listTopLevelCommands(), "help", "version", "alias", "shortcuts"]);
 var BUILTIN_SHORTCUTS = [
@@ -37475,7 +38019,7 @@ var BUILTIN_SHORTCUTS = [
   { pattern: /^reports?$/, argv: ["report", "docs"], explain: "Report export documentation" }
 ];
 function aliasesPath(cwd = process.cwd()) {
-  return join20(cwd, ".todos", "aliases.json");
+  return join21(cwd, ".todos", "aliases.json");
 }
 function emptyStore() {
   return { schema_version: COMMAND_ALIASES_SCHEMA, aliases: {}, updated_at: new Date(0).toISOString() };
@@ -37492,7 +38036,7 @@ function validateAliasName(name) {
 }
 function loadAliasStore(cwd) {
   const path = aliasesPath(cwd);
-  if (!existsSync22(path))
+  if (!existsSync23(path))
     return emptyStore();
   const parsed = JSON.parse(readFileSync21(path, "utf8"));
   if (parsed.schema_version !== COMMAND_ALIASES_SCHEMA) {
@@ -37502,7 +38046,7 @@ function loadAliasStore(cwd) {
 }
 function saveAliasStore(store, cwd) {
   const path = aliasesPath(cwd);
-  mkdirSync20(join20(path, ".."), { recursive: true });
+  mkdirSync20(join21(path, ".."), { recursive: true });
   store.updated_at = new Date().toISOString();
   writeFileSync18(path, JSON.stringify(store, null, 2), "utf8");
 }
@@ -38017,7 +38561,7 @@ function normalizeBranch(value) {
   }
   return branch;
 }
-function normalizePath5(value) {
+function normalizePath6(value) {
   const path = value.trim().replace(/\\/g, "/");
   if (!path || path.startsWith("/") || path.includes("\x00"))
     return null;
@@ -38049,7 +38593,7 @@ function getGitStatus(root, branch, includeGitStatus) {
   const branchExists = runGit3(root, ["show-ref", "--verify", `refs/heads/${branch}`]) !== null;
   const status = runGit3(root, ["status", "--short"]) || "";
   const dirtyFiles = status.split(`
-`).map((line) => line.trim()).filter(Boolean).map((line) => normalizePath5(line.replace(/^.. /, "").replace(/^.* -> /, ""))).filter((path) => Boolean(path));
+`).map((line) => line.trim()).filter(Boolean).map((line) => normalizePath6(line.replace(/^.. /, "").replace(/^.* -> /, ""))).filter((path) => Boolean(path));
   return { has_git: true, current_branch: currentBranch || null, branch_exists: branchExists, dirty_files: dirtyFiles };
 }
 function resolveScope2(input, db) {
@@ -38064,8 +38608,8 @@ function resolveScope2(input, db) {
   throw new Error("task_id or plan_id is required");
 }
 function collectPlannedFiles(tasks, explicitPaths, db) {
-  const fromTasks = tasks.flatMap((task2) => listTaskFiles(task2.id, db).map((file) => normalizePath5(file.path)));
-  const fromInput = (explicitPaths || []).map(normalizePath5);
+  const fromTasks = tasks.flatMap((task2) => listTaskFiles(task2.id, db).map((file) => normalizePath6(file.path)));
+  const fromInput = (explicitPaths || []).map(normalizePath6);
   return uniqueSorted2([...fromTasks, ...fromInput]);
 }
 function detectBranchPlanConflicts(taskIds, files, db) {
@@ -38150,18 +38694,18 @@ function createBranchWorkPlan(input, db) {
 }
 // src/lib/user-scaffolds.ts
 init_database();
-import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync19, mkdirSync as mkdirSync21 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync19, mkdirSync as mkdirSync21 } from "fs";
+import { join as join22 } from "path";
 var USER_SCAFFOLD_SCHEMA = "todos.user_scaffold.v1";
 var SCAFFOLD_KINDS = ["task", "project", "plan", "checklist", "contract", "verification_policy"];
 function storeDir(cwd = process.cwd()) {
-  return join21(cwd, ".todos", "scaffolds");
+  return join22(cwd, ".todos", "scaffolds");
 }
 function storePath(cwd) {
-  return join21(storeDir(cwd), "store.json");
+  return join22(storeDir(cwd), "store.json");
 }
 function versionsDir(cwd) {
-  return join21(storeDir(cwd), "versions");
+  return join22(storeDir(cwd), "versions");
 }
 function slugify5(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -38171,7 +38715,7 @@ function emptyStore2() {
 }
 function loadUserScaffoldStore(cwd) {
   const path = storePath(cwd);
-  if (!existsSync23(path))
+  if (!existsSync24(path))
     return emptyStore2();
   const parsed = JSON.parse(readFileSync22(path, "utf8"));
   if (parsed.schema_version !== USER_SCAFFOLD_SCHEMA) {
@@ -38186,7 +38730,7 @@ function saveUserScaffoldStore(store, cwd) {
 }
 function snapshotVersion(scaffold, cwd) {
   mkdirSync21(versionsDir(cwd), { recursive: true });
-  const path = join21(versionsDir(cwd), `${scaffold.id}-v${scaffold.version}.json`);
+  const path = join22(versionsDir(cwd), `${scaffold.id}-v${scaffold.version}.json`);
   writeFileSync19(path, JSON.stringify(scaffold, null, 2), "utf8");
 }
 function listUserScaffolds(kind, cwd) {
@@ -38433,7 +38977,7 @@ function listLinkedTemplates(db, cwd) {
 // src/lib/agent-workflow-demo.ts
 init_database();
 import { mkdtempSync } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 var AGENT_WORKFLOW_DEMO_SCHEMA = "todos.agent_workflow_demo.v1";
 var DEMO_DEFAULT_AGENT = "demoagent";
@@ -38449,7 +38993,7 @@ function setupEphemeralDemoDb(options = {}) {
   if (options.db_path) {
     db_path = options.db_path;
   } else if (options.persist) {
-    db_path = join22(mkdtempSync(join22(tmpdir4(), "todos-demo-")), "todos.db");
+    db_path = join23(mkdtempSync(join23(tmpdir4(), "todos-demo-")), "todos.db");
   } else {
     db_path = ":memory:";
   }
@@ -40774,18 +41318,18 @@ function runSearchView(idOrName, db) {
   return { ...runSavedSearch(view.filters, view.scope, d), view };
 }
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync24, readFileSync as readFileSync23, readdirSync as readdirSync4, writeFileSync as writeFileSync20 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync5, writeFileSync as writeFileSync20 } from "fs";
+import { join as join24 } from "path";
 init_config();
 init_sync_utils();
 function getTaskListDir(taskListId) {
-  return join23(HOME, ".claude", "tasks", taskListId);
+  return join24(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join23(dir, filename));
+  return readJsonFile(join24(dir, filename));
 }
 function writeClaudeTask(dir, task2) {
-  writeJsonFile(join23(dir, `${task2.id}.json`), task2);
+  writeJsonFile(join24(dir, `${task2.id}.json`), task2);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -40797,14 +41341,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join23(dir, ".prefix-counter");
-  if (!existsSync24(path))
+  const path = join24(dir, ".prefix-counter");
+  if (!existsSync25(path))
     return 0;
   const val = parseInt(readFileSync23(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync20(join23(dir, ".prefix-counter"), String(value));
+  writeFileSync20(join24(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -40831,7 +41375,7 @@ function taskToClaudeTask(task2, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync24(dir))
+  if (!existsSync25(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -40840,7 +41384,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join23(dir, f);
+    const path = join24(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -40927,10 +41471,10 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync24(dir)) {
+  if (!existsSync25(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
-  const files = readdirSync4(dir).filter((f) => f.endsWith(".json"));
+  const files = readdirSync5(dir).filter((f) => f.endsWith(".json"));
   let pulled = 0;
   const errors = [];
   const prefer = options.prefer || "remote";
@@ -40947,7 +41491,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join23(dir, f);
+      const filePath = join24(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -41015,22 +41559,22 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 }
 
 // src/lib/agent-tasks.ts
-import { existsSync as existsSync25 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { join as join25 } from "path";
 init_sync_utils();
 init_config();
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join24(getTodosGlobalDir(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join25(getTodosGlobalDir(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join24(agentBaseDir(agent), agent, taskListId);
+  return join25(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join24(dir, filename));
+  return readJsonFile(join25(dir, filename));
 }
 function writeAgentTask(dir, task2) {
-  writeJsonFile(join24(dir, `${task2.id}.json`), task2);
+  writeJsonFile(join25(dir, `${task2.id}.json`), task2);
 }
 function taskToAgentTask(task2, externalId, existingMeta) {
   return {
@@ -41055,7 +41599,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync25(dir))
+  if (!existsSync26(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -41064,7 +41608,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join24(dir, f);
+    const path = join25(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -41138,7 +41682,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -41157,7 +41701,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join24(dir, f);
+      const filePath = join25(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -41295,9 +41839,9 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
   return { pushed, pulled, errors };
 }
 // src/lib/extract.ts
-import { existsSync as existsSync26, readFileSync as readFileSync24, statSync as statSync8 } from "fs";
-import { createHash as createHash14 } from "crypto";
-import { relative as relative6, resolve as resolve17, join as join25 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync24, statSync as statSync9 } from "fs";
+import { createHash as createHash15 } from "crypto";
+import { relative as relative6, resolve as resolve18, join as join26 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
   ".ts",
@@ -41361,15 +41905,15 @@ var SKIP_DIRS2 = new Set([
   ".parcel-cache"
 ]);
 function stableHash(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readGitignorePatterns(basePath) {
-  const root = statSync8(basePath).isFile() ? resolve17(basePath, "..") : basePath;
-  const gitignorePath = join25(root, ".gitignore");
-  if (!existsSync26(gitignorePath))
+  const root = statSync9(basePath).isFile() ? resolve18(basePath, "..") : basePath;
+  const gitignorePath = join26(root, ".gitignore");
+  if (!existsSync27(gitignorePath))
     return [];
   try {
     return readFileSync24(gitignorePath, "utf-8").split(`
@@ -41478,7 +42022,7 @@ function extractFromSource(source9, filePath, tags = [...EXTRACT_TAGS]) {
   return results;
 }
 function collectFiles(basePath, extensions, excludes, respectGitignore) {
-  const stat = statSync8(basePath);
+  const stat = statSync9(basePath);
   if (stat.isFile()) {
     return [basePath];
   }
@@ -41503,7 +42047,7 @@ function collectFiles(basePath, extensions, excludes, respectGitignore) {
   return files.sort();
 }
 function buildCodebaseIndex(options) {
-  const basePath = resolve17(options.path);
+  const basePath = resolve18(options.path);
   const tags = options.patterns || [...EXTRACT_TAGS];
   const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
   const excludes = options.exclude || [];
@@ -41511,10 +42055,10 @@ function buildCodebaseIndex(options) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const indexed = [];
   for (const file of files) {
-    const fullPath = statSync8(basePath).isFile() ? basePath : join25(basePath, file);
+    const fullPath = statSync9(basePath).isFile() ? basePath : join26(basePath, file);
     try {
       const source9 = readFileSync24(fullPath, "utf-8");
-      const relPath = statSync8(basePath).isFile() ? relative6(resolve17(basePath, ".."), fullPath) : file;
+      const relPath = statSync9(basePath).isFile() ? relative6(resolve18(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
         checksum: stableHash(source9).slice(0, 24),
@@ -41534,7 +42078,7 @@ function buildCodebaseIndex(options) {
   };
 }
 function extractTodos(options, db) {
-  const basePath = resolve17(options.path);
+  const basePath = resolve18(options.path);
   const tags = options.patterns || [...EXTRACT_TAGS];
   const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
   const excludes = options.exclude || [];
@@ -41542,10 +42086,10 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync8(basePath).isFile() ? basePath : join25(basePath, file);
+    const fullPath = statSync9(basePath).isFile() ? basePath : join26(basePath, file);
     try {
       const source9 = readFileSync24(fullPath, "utf-8");
-      const relPath = statSync8(basePath).isFile() ? relative6(resolve17(basePath, ".."), fullPath) : file;
+      const relPath = statSync9(basePath).isFile() ? relative6(resolve18(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source9, relPath, tags);
       allComments.push(...comments);
     } catch {}
@@ -41639,7 +42183,7 @@ async function watchSourceTodos(options, onRun) {
   const interval = Math.max(100, options.interval_ms || 2000);
   const once = options.once !== false && (!options.max_runs || options.max_runs <= 1);
   const maxRuns = options.max_runs ?? (once ? 1 : Number.POSITIVE_INFINITY);
-  const root = resolve17(options.path);
+  const root = resolve18(options.path);
   const runs = [];
   let previous = new Map;
   for (let runNumber = 1;runNumber <= maxRuns; runNumber++) {
@@ -42249,7 +42793,7 @@ function renderWorkflowStatesMarkdown(states = listWorkflowStates()) {
 }
 // src/lib/agent-replay-simulator.ts
 init_redaction();
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { readFileSync as readFileSync25 } from "fs";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -42271,7 +42815,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable2(value[key])]));
 }
 function fingerprint3(value) {
-  return createHash15("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash16("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject(input))
@@ -42510,9 +43054,9 @@ function renderAgentReplaySimulationMarkdown(simulation) {
 }
 // src/lib/local-extensions.ts
 init_config();
-import { createHash as createHash16, createVerify } from "crypto";
-import { existsSync as existsSync27, readdirSync as readdirSync5, readFileSync as readFileSync26, statSync as statSync9 } from "fs";
-import { basename as basename5, join as join26, resolve as resolve18 } from "path";
+import { createHash as createHash17, createVerify } from "crypto";
+import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync26, statSync as statSync10 } from "fs";
+import { basename as basename6, join as join27, resolve as resolve19 } from "path";
 init_redaction();
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -42597,7 +43141,7 @@ function parseJson(path) {
   return JSON.parse(readFileSync26(path, "utf8"));
 }
 function sha2566(bytes) {
-  return `sha256:${createHash16("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash17("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -42792,11 +43336,11 @@ function verifyExtensionSignature(input) {
   return verifier.verify(input.public_key, decodeSignature(input.signature));
 }
 function inspectExtensionSource(source9) {
-  const resolved = resolve18(source9);
-  if (!existsSync27(resolved))
+  const resolved = resolve19(source9);
+  if (!existsSync28(resolved))
     throw new Error(`extension source not found: ${source9}`);
-  const stat = statSync9(resolved);
-  const manifestPath = stat.isDirectory() ? [join26(resolved, "todos.extension.json"), join26(resolved, "extension.json")].find(existsSync27) : resolved;
+  const stat = statSync10(resolved);
+  const manifestPath = stat.isDirectory() ? [join27(resolved, "todos.extension.json"), join27(resolved, "extension.json")].find(existsSync28) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source9} is missing todos.extension.json`);
   const raw = readFileSync26(manifestPath);
@@ -42890,26 +43434,26 @@ function testExtensionCompatibility(sourceOrManifest) {
 function projectExtensionSources(projectPath) {
   if (!projectPath)
     return [];
-  const root = resolve18(projectPath);
+  const root = resolve19(projectPath);
   const candidates = [
-    join26(root, "todos.extension.json"),
-    join26(root, ".todos", "todos.extension.json")
+    join27(root, "todos.extension.json"),
+    join27(root, ".todos", "todos.extension.json")
   ];
-  const extensionDir = join26(root, ".todos", "extensions");
-  if (existsSync27(extensionDir)) {
-    for (const entry2 of readdirSync5(extensionDir)) {
+  const extensionDir = join27(root, ".todos", "extensions");
+  if (existsSync28(extensionDir)) {
+    for (const entry2 of readdirSync6(extensionDir)) {
       if (entry2.startsWith("."))
         continue;
-      const full = join26(extensionDir, entry2);
-      if (statSync9(full).isDirectory() || entry2.endsWith(".json"))
+      const full = join27(extensionDir, entry2);
+      if (statSync10(full).isDirectory() || entry2.endsWith(".json"))
         candidates.push(full);
     }
   }
-  return candidates.filter(existsSync27);
+  return candidates.filter(existsSync28);
 }
 function discoverLocalExtensions(options = {}) {
   const config = loadConfig();
-  const projectPath = options.project_path ? resolve18(options.project_path) : null;
+  const projectPath = options.project_path ? resolve19(options.project_path) : null;
   const configuredSources = [
     ...config.extension_sources || [],
     ...projectPath ? config.project_overrides?.[projectPath]?.extension_sources || [] : []
@@ -42917,7 +43461,7 @@ function discoverLocalExtensions(options = {}) {
   const sources = Array.from(new Set([
     ...configuredSources,
     ...projectExtensionSources(projectPath || undefined)
-  ])).map((source9) => projectPath && !source9.startsWith("/") ? resolve18(projectPath, source9) : resolve18(source9));
+  ])).map((source9) => projectPath && !source9.startsWith("/") ? resolve19(projectPath, source9) : resolve19(source9));
   const warnings = [];
   const discovered = [];
   for (const source9 of sources) {
@@ -42999,7 +43543,7 @@ function removeLocalExtension(name) {
   return true;
 }
 function renderExtensionSummary(record) {
-  return `${record.name}@${record.version} ${record.status} ${basename5(record.source)} ${record.signature_verified ? "signed" : "unsigned"}`;
+  return `${record.name}@${record.version} ${record.status} ${basename6(record.source)} ${record.signature_verified ? "signed" : "unsigned"}`;
 }
 // src/lib/workflow-prompts.ts
 var COMMON_ARGUMENTS = [
@@ -43766,7 +44310,7 @@ function resolveMissingTaskFindings(input, db) {
 init_redaction();
 
 // src/lib/retention-cleanup.ts
-import { existsSync as existsSync28, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync29, unlinkSync as unlinkSync2 } from "fs";
 init_database();
 var RETENTION_CLEANUP_CONFIRMATION = "delete-local-retention-data";
 var ALL_SCOPES = ["comments", "runs", "verifications", "expired_artifacts"];
@@ -43978,7 +44522,7 @@ function applyRetentionCleanup(input, db) {
   for (const artifact of report.candidates.artifact_files) {
     try {
       const path = artifactStorePath(artifact.relative_path);
-      if (!existsSync28(path)) {
+      if (!existsSync29(path)) {
         report.warnings.push(`stored artifact already missing: ${artifact.relative_path}`);
         continue;
       }
@@ -44216,8 +44760,8 @@ function renderScalePerformanceReportMarkdown(report) {
 init_database();
 init_migrations();
 init_schema();
-import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync29, mkdirSync as mkdirSync22, statSync as statSync10 } from "fs";
-import { basename as basename6, dirname as dirname18, join as join27 } from "path";
+import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync22, statSync as statSync11 } from "fs";
+import { basename as basename7, dirname as dirname19, join as join28 } from "path";
 var REQUIRED_TABLES2 = [
   "_migrations",
   "projects",
@@ -44324,7 +44868,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync29(row.path))
+    if (!existsSync30(row.path))
       missing++;
   }
   return missing;
@@ -44376,7 +44920,7 @@ function databasePermissionsAreUnsafe(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return false;
   try {
-    return (statSync10(dbPath).mode & 63) !== 0;
+    return (statSync11(dbPath).mode & 63) !== 0;
   } catch {
     return false;
   }
@@ -44384,16 +44928,16 @@ function databasePermissionsAreUnsafe(dbPath) {
 function createBackup(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return;
-  if (!existsSync29(dbPath))
+  if (!existsSync30(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join27(dirname18(dbPath), `${basename6(dbPath)}.backup-${stamp}`);
+  const backupDir = join28(dirname19(dbPath), `${basename7(dbPath)}.backup-${stamp}`);
   const files = [];
   mkdirSync22(backupDir, { recursive: true });
   for (const source9 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync29(source9))
+    if (!existsSync30(source9))
       continue;
-    const target = join27(backupDir, basename6(source9));
+    const target = join28(backupDir, basename7(source9));
     copyFileSync2(source9, target);
     files.push(target);
   }
@@ -45817,6 +46361,7 @@ export {
   dispatchToMultiple,
   dismissReminder,
   discoverVerificationProviderCapabilities,
+  discoverTaskRouteSources,
   discoverProjectWorkspace,
   discoverLocalExtensions,
   detectSourceType,
@@ -46068,6 +46613,7 @@ export {
   TASK_WORKFLOW_POINTER_SCHEMA_VERSION,
   TASK_STATUSES,
   TASK_SCHEDULING_SCHEMA,
+  TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION,
   TASK_PRIORITIES,
   TASK_FINDING_UPSERT_SCHEMA_VERSION,
   TASK_FINDING_SCHEMA_VERSION,