@hasna/todos 0.11.70 → 0.11.72

package/dist/cli/index.js

@@ -1011,7 +1011,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          }
+          } else {}
         };
       }
       return this;
@@ -3282,6 +3282,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);
   `
   ];
 });
@@ -3305,6 +3310,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 {
@@ -3354,7 +3382,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')),
@@ -3869,8 +3898,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");
@@ -3985,6 +4016,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)");
@@ -4838,6 +4871,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}`);
@@ -4864,6 +4900,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)
@@ -7169,8 +7215,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;
@@ -7192,8 +7236,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/");
@@ -7266,7 +7328,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;
     }
@@ -7278,6 +7339,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;
@@ -10333,15 +10398,76 @@ var init_task_relations = __esm(() => {
 });
 
 // src/db/plans.ts
+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 resolvePlanRefDetailed(ref, db, projectId) {
+  const d = db || getDatabase();
+  const byId = d.query("SELECT * FROM plans WHERE id = ? OR id LIKE ? ORDER BY id").all(ref, `${ref}%`);
+  if (byId.length === 1)
+    return { id: byId[0].id, reason: "id", matches: byId };
+  if (byId.length > 1)
+    return { id: null, reason: "ambiguous", matches: byId };
+  const slug = slugify(ref);
+  if (!slug)
+    return { id: null, reason: "not_found", matches: [] };
+  const bySlug = plansBySlug(slug, d, projectId);
+  if (bySlug.length === 1)
+    return { id: bySlug[0].id, reason: "slug", matches: bySlug };
+  if (bySlug.length > 1)
+    return { id: null, reason: "ambiguous", matches: bySlug };
+  return { id: null, reason: "not_found", matches: [] };
+}
 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,
@@ -10376,6 +10502,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);
@@ -10420,6 +10554,7 @@ var init_plans = __esm(() => {
   init_event_emission_safety();
   init_event_hooks();
   init_database();
+  init_projects();
   init_storage_tombstones();
 });
 
@@ -12626,11 +12761,6 @@ __export(exports_task_routing, {
   setTaskWorkflowPointers: () => setTaskWorkflowPointers,
   getTaskRouteState: () => getTaskRouteState
 });
-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)
@@ -12678,6 +12808,7 @@ function getTaskRouteState(taskOrId, db) {
   const automation = routingAutomationMetadata(task, taskList) ?? {};
   const routeEnabled = routeEnabledForTask(task, taskList) === true;
   const tagOptIn = task.tags.includes("auto:route") || task.tags.includes("route:enabled");
+  const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
   const locked = Boolean(task.locked_by && !isLockExpired(task.locked_at));
   const blockers = getBlockingDeps(task.id, d);
   const blocked = blockers.length > 0;
@@ -12740,7 +12871,7 @@ function getTaskRouteState(taskOrId, db) {
       project_id: project?.id ?? task.project_id,
       project_path: projectPath,
       working_dir: task.working_dir ?? projectPath,
-      project_kind: classifyProjectKind2(projectPath),
+      project_kind: projectKind,
       task_list_id: taskList?.id ?? task.task_list_id,
       task_list_slug: taskList?.slug ?? null,
       task_list_name: taskList?.name ?? null,
@@ -13718,6 +13849,9 @@ 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;
@@ -13743,11 +13877,24 @@ function resolvePlanArtifactPaths(input) {
   const projectRoot = resolve10(project.path);
   const directory = join7(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 ? join7(directory, `${planId}.md`) : directory
+    file_path: fileName ? join7(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()) {
@@ -13764,6 +13911,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,
@@ -13803,6 +13951,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)}`,
@@ -13848,6 +13997,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,
@@ -13888,7 +14038,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);
   mkdirSync5(paths.directory, { recursive: true });
   writeFileSync3(paths.file_path, renderPlanArtifactMarkdown(snapshot), "utf8");
@@ -13898,12 +14048,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 (!existsSync8(paths.file_path))
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path)
     return null;
-  const markdown = readFileSync4(paths.file_path, "utf8");
+  const markdown = readFileSync4(path, "utf8");
   return {
-    path: paths.file_path,
+    path,
     markdown,
     ...parsePlanArtifactMarkdown(markdown)
   };
@@ -13912,10 +14063,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 (!existsSync8(paths.file_path)) {
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path) {
     return {
-      path: paths.file_path,
+      path: paths.primary.file_path,
       exists: false,
       parse_error: null,
       metadata: null,
@@ -13924,9 +14076,9 @@ function inspectPlanArtifact(plan, db) {
     };
   }
   try {
-    const artifact = parsePlanArtifactMarkdown(readFileSync4(paths.file_path, "utf8"));
+    const artifact = parsePlanArtifactMarkdown(readFileSync4(path, "utf8"));
     return {
-      path: paths.file_path,
+      path,
       exists: true,
       parse_error: null,
       metadata: artifact.metadata,
@@ -13935,7 +14087,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,
@@ -13947,6 +14099,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);
@@ -14316,22 +14471,44 @@ __export(exports_plan_template_commands, {
   registerPlanTemplateCommands: () => registerPlanTemplateCommands
 });
 import chalk3 from "chalk";
+function resolvePlanCliRef(ref, projectId) {
+  const db = getDatabase();
+  const resolved = resolvePlanRefDetailed(ref, db, projectId);
+  if (resolved.id)
+    return resolved.id;
+  if (resolved.reason === "ambiguous") {
+    console.error(chalk3.red(`Ambiguous plan reference: ${ref}`));
+    if (resolved.matches.length > 0) {
+      console.error(chalk3.dim(`Matches: ${resolved.matches.map((plan) => `${plan.slug ?? plan.name} (${plan.id.slice(0, 8)})`).join(", ")}`));
+    }
+  } else {
+    console.error(chalk3.red(`Could not resolve plan ID or slug: ${ref}`));
+  }
+  process.exit(1);
+}
 function registerPlanTemplateCommands(program2) {
-  program2.command("plans").description("List and manage plans").option("--add <name>", "Create a plan").option("-d, --description <text>", "Plan description (with --add)").option("--show <id>", "Show plan details with its tasks").option("--artifact <id>", "Show local Markdown artifact diagnostics for a plan").option("--write-artifacts", "Write local Markdown artifacts for all project-scoped plans in scope").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action((opts) => {
+  program2.command("plans").description("List and manage plans").option("--add <name>", "Create a plan").option("--slug <slug>", "Readable plan slug (with --add)").option("-d, --description <text>", "Plan description (with --add)").option("--show <id-or-slug>", "Show plan details with its tasks").option("--artifact <id-or-slug>", "Show local Markdown artifact diagnostics for a plan").option("--write-artifacts", "Write local Markdown artifacts for all project-scoped plans in scope").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action((opts) => {
     const globalOpts = program2.opts();
     const projectId = autoProject(globalOpts);
     if (opts.add) {
-      const plan = createPlan({
-        name: opts.add,
-        description: opts.description,
-        project_id: projectId
-      });
+      let plan;
+      try {
+        plan = createPlan({
+          name: opts.add,
+          slug: opts.slug,
+          description: opts.description,
+          project_id: projectId
+        });
+      } catch (error) {
+        handleError(error);
+      }
       const artifact = writePlanArtifact(plan);
       if (globalOpts.json) {
         output(plan, true);
       } else {
         console.log(chalk3.green("Plan created:"));
         console.log(`${chalk3.dim(plan.id.slice(0, 8))} ${chalk3.bold(plan.name)} ${chalk3.cyan(`[${plan.status}]`)}`);
+        console.log(`${chalk3.dim("Slug:")} ${plan.slug}`);
         if (artifact)
           console.log(`${chalk3.dim("Artifact:")} ${artifact.path}`);
       }
@@ -14339,11 +14516,7 @@ function registerPlanTemplateCommands(program2) {
     }
     if (opts.artifact) {
       const db = getDatabase();
-      const resolvedId = resolvePartialId(db, "plans", opts.artifact);
-      if (!resolvedId) {
-        console.error(chalk3.red(`Could not resolve plan ID: ${opts.artifact}`));
-        process.exit(1);
-      }
+      const resolvedId = resolvePlanCliRef(opts.artifact, projectId);
       const plan = getPlan(resolvedId);
       if (!plan) {
         console.error(chalk3.red(`Plan not found: ${opts.artifact}`));
@@ -14396,11 +14569,7 @@ function registerPlanTemplateCommands(program2) {
     }
     if (opts.show) {
       const db = getDatabase();
-      const resolvedId = resolvePartialId(db, "plans", opts.show);
-      if (!resolvedId) {
-        console.error(chalk3.red(`Could not resolve plan ID: ${opts.show}`));
-        process.exit(1);
-      }
+      const resolvedId = resolvePlanCliRef(opts.show, projectId);
       const plan = getPlan(resolvedId);
       if (!plan) {
         console.error(chalk3.red(`Plan not found: ${opts.show}`));
@@ -14425,6 +14594,8 @@ function registerPlanTemplateCommands(program2) {
       console.log(chalk3.bold(`Plan Details:
 `));
       console.log(`  ${chalk3.dim("ID:")}       ${plan.id}`);
+      if (plan.slug)
+        console.log(`  ${chalk3.dim("Slug:")}     ${plan.slug}`);
       console.log(`  ${chalk3.dim("Name:")}     ${plan.name}`);
       console.log(`  ${chalk3.dim("Status:")}   ${chalk3.cyan(plan.status)}`);
       if (plan.description)
@@ -14447,12 +14618,7 @@ function registerPlanTemplateCommands(program2) {
       return;
     }
     if (opts.delete) {
-      const db = getDatabase();
-      const resolvedId = resolvePartialId(db, "plans", opts.delete);
-      if (!resolvedId) {
-        console.error(chalk3.red(`Could not resolve plan ID: ${opts.delete}`));
-        process.exit(1);
-      }
+      const resolvedId = resolvePlanCliRef(opts.delete, projectId);
       const deleted = deletePlan(resolvedId);
       if (globalOpts.json) {
         output({ deleted }, true);
@@ -14465,12 +14631,7 @@ function registerPlanTemplateCommands(program2) {
       return;
     }
     if (opts.complete) {
-      const db = getDatabase();
-      const resolvedId = resolvePartialId(db, "plans", opts.complete);
-      if (!resolvedId) {
-        console.error(chalk3.red(`Could not resolve plan ID: ${opts.complete}`));
-        process.exit(1);
-      }
+      const resolvedId = resolvePlanCliRef(opts.complete, projectId);
       try {
         const plan = updatePlan(resolvedId, { status: "completed" });
         const artifact = writePlanArtifact(plan);
@@ -14500,7 +14661,8 @@ function registerPlanTemplateCommands(program2) {
 `));
     for (const p of plans) {
       const desc = p.description ? chalk3.dim(` - ${p.description}`) : "";
-      console.log(`${chalk3.dim(p.id.slice(0, 8))} ${chalk3.bold(p.name)} ${chalk3.cyan(`[${p.status}]`)}${desc}`);
+      const slug = p.slug ? chalk3.dim(` ${p.slug}`) : "";
+      console.log(`${chalk3.dim(p.id.slice(0, 8))}${slug} ${chalk3.bold(p.name)} ${chalk3.cyan(`[${p.status}]`)}${desc}`);
     }
   });
   program2.command("templates").description("List and manage task templates").option("--add <name>", "Create a template").option("--title <pattern>", "Title pattern (with --add)").option("-d, --description <text>", "Default description").option("-p, --priority <level>", "Default priority").option("-t, --tags <tags>", "Default tags (comma-separated)").option("--delete <id>", "Delete a template").option("--update <id>", "Update a template").option("--use <id>", "Create a task from a template").option("--var <vars...>", "Variable substitutions: key=value (e.g. --var feature=login)").action(async (opts) => {
@@ -22074,6 +22236,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];
@@ -22210,6 +22402,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 ?? [],
@@ -22294,7 +22487,7 @@ var init_local_bridge = __esm(() => {
   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",
@@ -28389,6 +28582,7 @@ async function handleCreatePlan(req, _ctx, json2) {
       return json2({ error: "Missing 'name'" }, 400);
     const plan = createPlan({
       name: body.name,
+      slug: body.slug,
       description: body.description,
       project_id: body.project_id,
       task_list_id: body.task_list_id,
@@ -37738,6 +37932,7 @@ Tasks:` : null,
   if (shouldRegisterTool("create_plan")) {
     server.tool("create_plan", "Create a new plan (sprint/milestone).", {
       name: exports_external2.string().describe("Plan name"),
+      slug: exports_external2.string().optional().describe("Readable plan slug"),
       project_id: exports_external2.string().optional().describe("Project ID"),
       description: exports_external2.string().optional(),
       start_date: exports_external2.string().optional().describe("ISO date"),
@@ -44898,6 +45093,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",
@@ -55038,6 +55234,339 @@ var init_config_serve_commands = __esm(() => {
   init_helpers();
 });
 
+// src/lib/task-route-sources.ts
+var exports_task_route_sources = {};
+__export(exports_task_route_sources, {
+  discoverTaskRouteSources: () => discoverTaskRouteSources,
+  TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION: () => TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION
+});
+import { Database as Database3 } from "bun:sqlite";
+import { createHash as createHash13 } from "crypto";
+import { existsSync as existsSync21, readdirSync as readdirSync5, statSync as statSync9 } from "fs";
+import { basename as basename9, dirname as dirname12, join as join21, resolve as resolve21 } from "path";
+function normalizePath5(input) {
+  return resolve21(input);
+}
+function sourceStoreId(sourceDbPath) {
+  const digest = createHash13("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  return `sqlite:${digest}`;
+}
+function inferSourceRepoPath(sourceDbPath) {
+  const normalized = normalizePath5(sourceDbPath);
+  if (normalized.endsWith(TODO_STORE_RELATIVE_PATH)) {
+    return dirname12(dirname12(dirname12(normalized)));
+  }
+  return dirname12(normalized);
+}
+function createStoreRef(sourceDbPath) {
+  const normalized = normalizePath5(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 source3 = "";
+  for (const char of pattern) {
+    if (char === "*")
+      source3 += ".*";
+    else if (char === "?")
+      source3 += ".";
+    else
+      source3 += escapeRegExp(char);
+  }
+  return new RegExp(`^${source3}$`);
+}
+function matchesPattern4(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, basename9(value)]);
+  return patterns.some((pattern) => values.some((value) => matchesPattern4(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 = normalizePath5(sourceRoot);
+  const errors2 = [];
+  const stores = [];
+  if (!existsSync21(rootPath)) {
+    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors2.push({
+      ...ref,
+      code: "SOURCE_ROOT_MISSING",
+      message: `Source root does not exist: ${rootPath}`
+    });
+    return { stores, errors: errors2 };
+  }
+  let rootStat;
+  try {
+    rootStat = statSync9(rootPath);
+  } catch (error) {
+    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors2.push({
+      ...ref,
+      code: "SOURCE_ROOT_UNREADABLE",
+      message: error instanceof Error ? error.message : `Unable to read source root: ${rootPath}`
+    });
+    return { stores, errors: errors2 };
+  }
+  if (rootStat.isFile()) {
+    stores.push(createStoreRef(rootPath));
+    return { stores, errors: errors2 };
+  }
+  function scanDirectory(dir, depth) {
+    const candidate = join21(dir, TODO_STORE_RELATIVE_PATH);
+    if (existsSync21(candidate)) {
+      stores.push(createStoreRef(candidate));
+    }
+    if (depth >= ROOT_SCAN_MAX_DEPTH)
+      return;
+    let entries;
+    try {
+      entries = readdirSync5(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      const ref = createStoreRef(candidate);
+      errors2.push({
+        ...ref,
+        code: "SOURCE_ROOT_UNREADABLE",
+        message: error instanceof Error ? error.message : `Unable to read source root: ${dir}`
+      });
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIPPED_SCAN_DIRS.has(entry.name))
+        continue;
+      scanDirectory(join21(dir, entry.name), depth + 1);
+    }
+  }
+  scanDirectory(rootPath, 0);
+  return { stores, errors: errors2 };
+}
+function collectStoreRefs(input) {
+  const byPath = new Map;
+  const errors2 = [];
+  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);
+    }
+    errors2.push(...discovered.errors);
+  }
+  return {
+    stores: [...byPath.values()].sort((a, b) => a.source_db_path.localeCompare(b.source_db_path)),
+    errors: errors2.sort((a, b) => a.source_db_path.localeCompare(b.source_db_path))
+  };
+}
+function openReadonlyStore(ref) {
+  if (!existsSync21(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(normalizePath5).sort();
+  const sourceStores = (input.sourceStores ?? []).map(normalizePath5).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 errors2 = [...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);
+      errors2.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: errors2
+  };
+}
+var TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION = "todos.task_route_sources.v1", TODO_STORE_RELATIVE_PATH, ROOT_SCAN_MAX_DEPTH = 5, SKIPPED_SCAN_DIRS;
+var init_task_route_sources = __esm(() => {
+  init_database();
+  init_task_lifecycle();
+  init_task_crud();
+  init_redaction();
+  init_task_routing();
+  TODO_STORE_RELATIVE_PATH = join21(".hasna", "todos", "todos.db");
+  SKIPPED_SCAN_DIRS = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".cache"
+  ]);
+});
+
 // src/lib/tester-issue-reports.ts
 var exports_tester_issue_reports = {};
 __export(exports_tester_issue_reports, {
@@ -55050,7 +55579,7 @@ __export(exports_tester_issue_reports, {
   TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
   TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION
 });
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function asObject3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -55222,7 +55751,7 @@ function fingerprintTesterIssueReport(report) {
     normalizeText4(report.failure?.message || report.summary || report.title).slice(0, 240),
     normalizeText4(stackTop).slice(0, 160)
   ].join("::");
-  return `testers:${createHash13("sha256").update(raw).digest("hex").slice(0, 16)}`;
+  return `testers:${createHash14("sha256").update(raw).digest("hex").slice(0, 16)}`;
 }
 function priorityForSeverity(severity, fallback) {
   return PRIORITIES5.includes(severity) ? severity : fallback;
@@ -55541,6 +56070,15 @@ function parseCsvOption(value) {
   const values = value.split(",").map((item) => item.trim()).filter(Boolean);
   return values.length > 0 ? values : undefined;
 }
+function collectOption2(value, previous = []) {
+  return [...previous, value];
+}
+function expandRepeatedCsvOption(value) {
+  if (!value || value.length === 0)
+    return;
+  const values = value.flatMap((item) => item.split(",").map((part) => part.trim()).filter(Boolean));
+  return values.length > 0 ? values : undefined;
+}
 function resolveOptionalId(table, value) {
   if (!value)
     return;
@@ -56179,13 +56717,13 @@ Repairs`));
     try {
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
-      const { statSync: statSync9 } = await import("fs");
-      const { join: join21 } = await import("path");
+      const { statSync: statSync10 } = await import("fs");
+      const { join: join22 } = await import("path");
       const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join21(home, ".hasna", "todos", "todos.db");
+      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join22(home, ".hasna", "todos", "todos.db");
       let size = "unknown";
       try {
-        size = `${(statSync9(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
+        size = `${(statSync10(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
       } catch {}
       checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk7.dim(dbPath)}` });
     } catch (e) {
@@ -56675,8 +57213,42 @@ Repairs`));
       console.log(`  ${chalk7.dim(time2)} ${chalk7.cyan(entry.source)} ${chalk7.dim(ref)} ${entry.event_type}${message}${agent}`);
     }
   });
-  program2.command("ready").description("Show all tasks ready to be claimed (pending, unblocked, unlocked)").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").option("--limit <n>", "Max tasks to show", "20").action(async (opts) => {
+  program2.command("ready").description("Show all tasks ready to be claimed (pending, unblocked, unlocked)").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").option("--limit <n>", "Max tasks to show", "20").option("--source-root <path>", "Read-only source root to scan for .hasna/todos/todos.db (repeatable)", collectOption2, []).option("--source-store <path>", "Read-only todos SQLite store path to scan (repeatable)", collectOption2, []).option("--include <pattern>", "Include source repo/store paths matching substring or glob (repeatable or comma-separated)", collectOption2, []).option("--exclude <pattern>", "Exclude source repo/store paths matching substring or glob (repeatable or comma-separated)", collectOption2, []).action(async (opts) => {
     const globalOpts = program2.opts();
+    const sourceRoots = expandRepeatedCsvOption(opts.sourceRoot);
+    const sourceStores = expandRepeatedCsvOption(opts.sourceStore);
+    const include = expandRepeatedCsvOption(opts.include);
+    const exclude = expandRepeatedCsvOption(opts.exclude);
+    if (sourceRoots || sourceStores || include || exclude) {
+      const { discoverTaskRouteSources: discoverTaskRouteSources2 } = await Promise.resolve().then(() => (init_task_route_sources(), exports_task_route_sources));
+      const result = discoverTaskRouteSources2({
+        sourceRoots,
+        sourceStores,
+        include,
+        exclude,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (opts.json || globalOpts.json) {
+        console.log(JSON.stringify(result));
+        return;
+      }
+      if (result.candidates.length === 0) {
+        console.log(chalk7.dim("  No source tasks ready to claim."));
+      } else {
+        console.log(chalk7.bold(`Ready source tasks (${result.candidates.length}):
+`));
+        for (const candidate of result.candidates) {
+          const source3 = candidate.source_repo_path ?? candidate.source_db_path;
+          const pri = candidate.priority === "critical" ? chalk7.bgRed.white(" CRIT ") : candidate.priority === "high" ? chalk7.red("[high]") : candidate.priority === "medium" ? chalk7.yellow("[med]") : "";
+          console.log(`  ${chalk7.cyan(candidate.task_short_id || candidate.task_id.slice(0, 8))} ${candidate.title} ${pri}${chalk7.dim(` ${source3}`)}`);
+        }
+      }
+      if (result.errors.length > 0) {
+        console.log(chalk7.yellow(`
+  ${result.errors.length} source error${result.errors.length === 1 ? "" : "s"} isolated; rerun with --json for details.`));
+      }
+      return;
+    }
     const db = getDatabase();
     const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const { isLockExpired: isLockExpired2 } = await Promise.resolve().then(() => (init_database(), exports_database));
@@ -57998,21 +58570,21 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync17, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname12, join as join21 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname13, join as join22 } from "path";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join21(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync21(bunBin))
+  const bunBin = join22(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync22(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return {};
   try {
     return JSON.parse(readFileSync17(path, "utf-8"));
@@ -58021,20 +58593,20 @@ function readJsonFile2(path) {
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname12(path);
-  if (!existsSync21(dir))
+  const dir = dirname13(path);
+  if (!existsSync22(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync10(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return "";
   return readFileSync17(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname12(path);
-  if (!existsSync21(dir))
+  const dir = dirname13(path);
+  if (!existsSync22(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync10(path, content);
 }
@@ -58100,7 +58672,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join21(HOME2, ".codex", "config.toml");
+  const configPath = join22(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -58114,7 +58686,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join21(HOME2, ".codex", "config.toml");
+  const configPath = join22(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk8.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -58126,7 +58698,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join21(HOME2, ".gemini", "settings.json");
+  const configPath = join22(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -58140,7 +58712,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join21(HOME2, ".gemini", "settings.json");
+  const configPath = join22(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -58197,8 +58769,8 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join21(process.cwd(), ".claude", "hooks");
-    if (!existsSync21(hooksDir))
+    const hooksDir = join22(process.cwd(), ".claude", "hooks");
+    if (!existsSync22(hooksDir))
       mkdirSync11(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
@@ -58223,11 +58795,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join21(hooksDir, "todos-sync.sh");
+    const hookPath = join22(hooksDir, "todos-sync.sh");
     writeFileSync10(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join21(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join22(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -59096,7 +59668,7 @@ Artifacts:`));
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (existsSync21(hookPath)) {
+      if (existsSync22(hookPath)) {
         const existing = readFileSync17(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk8.yellow("Hook already installed."));
@@ -59124,7 +59696,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (!existsSync21(hookPath)) {
+      if (!existsSync22(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
@@ -59310,7 +59882,7 @@ import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
 import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -59348,7 +59920,7 @@ function remoteTempPath(sshAddress) {
 }
 function readRemoteBridgeBundle(sshAddress) {
   const remotePath = remoteTempPath(sshAddress);
-  const localPath = join22(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
+  const localPath = join23(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
   try {
     runSsh(sshAddress, `todos export --format bridge --allow-plaintext-sensitive --output ${shellQuote(remotePath)}`, 120000);
     scpFromRemote(sshAddress, remotePath, localPath);
@@ -59363,7 +59935,7 @@ function readRemoteBridgeBundle(sshAddress) {
   }
 }
 function writeLocalBridgeBundle() {
-  const localPath = join22(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
+  const localPath = join23(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
   writeFileSync11(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
   return localPath;
 }
@@ -60427,7 +60999,7 @@ __export(exports_onboarding_commands, {
   registerOnboardingCommands: () => registerOnboardingCommands
 });
 import chalk17 from "chalk";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 function registerOnboardingCommands(program2) {
   program2.command("onboarding").alias("demo-fixtures").description("List, show, write, or import bundled local onboarding fixtures").option("--show <name>", "Show one fixture bridge bundle as JSON").option("--write <dir>", "Write all bundled fixture bridge bundles to a directory").option("--import <name>", "Dry-run or apply an onboarding fixture import").option("--apply", "Apply an onboarding fixture import. Defaults to dry-run.").option("--resolve-conflicts", "Safely merge existing local tasks while preserving divergent fields").action(async (opts) => {
     const globalOpts = program2.opts();
@@ -60443,7 +61015,7 @@ function registerOnboardingCommands(program2) {
         return;
       }
       if (opts.write) {
-        const result = writeOnboardingFixtureFiles2(resolve21(opts.write));
+        const result = writeOnboardingFixtureFiles2(resolve22(opts.write));
         if (globalOpts.json) {
           output(result, true);
           return;
@@ -63892,7 +64464,7 @@ __export(exports_sdk_integration_fixtures, {
   TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT: () => TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT
 });
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function source5(version) {
   return {
     packageName: "@hasna/todos",
@@ -63999,7 +64571,7 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   ];
   const written = [];
   for (const [name, payload] of files) {
-    const file = join23(directory, name);
+    const file = join24(directory, name);
     writeFileSync12(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
@@ -64023,7 +64595,7 @@ __export(exports_sdk_fixture_commands, {
   registerSdkFixtureCommands: () => registerSdkFixtureCommands
 });
 import chalk19 from "chalk";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 function registerSdkFixtureCommands(program2) {
   program2.command("sdk-fixtures").description("List, show, or write local SDK integration fixtures").option("--show", "Print the full fixture pack JSON").option("--write <dir>", "Write fixture pack, bridge fixture, contract snapshots, and example index to a directory").action(async (opts) => {
     const globalOpts = program2.opts();
@@ -64034,7 +64606,7 @@ function registerSdkFixtureCommands(program2) {
         writeSdkIntegrationFixtures: writeSdkIntegrationFixtures2
       } = await Promise.resolve().then(() => (init_sdk_integration_fixtures(), exports_sdk_integration_fixtures));
       if (opts.write) {
-        const result = writeSdkIntegrationFixtures2(resolve22(opts.write));
+        const result = writeSdkIntegrationFixtures2(resolve23(opts.write));
         if (globalOpts.json) {
           console.log(JSON.stringify(result));
           return;
@@ -64856,7 +65428,7 @@ __export(exports_local_backup_commands, {
   registerLocalBackupCommands: () => registerLocalBackupCommands
 });
 import chalk26 from "chalk";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 function globalOptions6(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
@@ -64878,10 +65450,10 @@ function registerLocalBackupCommands(program2) {
       const projectId = opts.projectId ?? autoProject(globalOpts);
       const backupBundle = createLocalBackup2({
         project_id: projectId,
-        output_path: opts.output ? resolve23(opts.output) : undefined
+        output_path: opts.output ? resolve24(opts.output) : undefined
       });
       const result = {
-        output_path: opts.output ? resolve23(opts.output) : null,
+        output_path: opts.output ? resolve24(opts.output) : null,
         backup: backupBundle
       };
       if (opts.json || globalOpts.json) {
@@ -66291,9 +66863,17 @@ async function updateProject2(id, input, store) {
 }
 async function createPlan2(input, store, context) {
   const timestamp3 = 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,
@@ -66307,7 +66887,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");
@@ -66560,8 +67150,38 @@ function matchesOne(value, expected) {
 function priorityRank2(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));
@@ -66637,7 +67257,7 @@ var init_factory = __esm(() => {
 });
 
 // src/storage/s3-artifacts.ts
-import { createHash as createHash14, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash15, createHmac as createHmac2 } from "crypto";
 function createTodosS3ArtifactStore(options) {
   const requestFetch = options.fetch ?? fetch;
   const now4 = options.now ?? (() => new Date);
@@ -66809,7 +67429,7 @@ function toAmzDate(date) {
   return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
 }
 function sha256Hex(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function hmac(key, value) {
   return createHmac2("sha256", key).update(value).digest();