@hasna/todos 0.11.69 → 0.11.71

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)
@@ -10333,15 +10379,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 +10483,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 +10535,7 @@ var init_plans = __esm(() => {
   init_event_emission_safety();
   init_event_hooks();
   init_database();
+  init_projects();
   init_storage_tombstones();
 });
 
@@ -13681,6 +13797,323 @@ var init_task_commands = __esm(() => {
   init_types();
 });
 
+// src/lib/plan-artifacts.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, resolve as resolve10 } from "path";
+function assertSafePathSegment(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "." || trimmed === ".." || trimmed.includes("/") || trimmed.includes("\\")) {
+    throw new Error(`Invalid ${label} for plan artifact path`);
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+    throw new Error(`Invalid ${label} for plan artifact path`);
+  }
+  return trimmed;
+}
+function frontmatterScalar(value) {
+  return JSON.stringify(value);
+}
+function parseFrontmatterScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed === "null")
+    return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed === null || typeof parsed === "string")
+      return parsed;
+  } catch {}
+  return trimmed.replace(/^["']|["']$/g, "") || null;
+}
+function markdownEscape(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, "").trim();
+}
+function markdownLine(text) {
+  return markdownEscape(text).replace(/\s+/g, " ").trim();
+}
+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);
+  if (byPath)
+    return byPath;
+  const resolvedId = resolvePartialId(db, "projects", ref);
+  if (resolvedId) {
+    const project2 = getProject(resolvedId, db);
+    if (project2)
+      return project2;
+  }
+  const project = listProjects(db).find((candidate) => projectSlugMatches(candidate, ref));
+  if (project)
+    return project;
+  throw new Error(`Project not found for plan artifacts: ${ref}`);
+}
+function resolvePlanArtifactPaths(input) {
+  const project = resolvePlanArtifactProject(input);
+  const projectId = assertSafePathSegment(project.id, "project id");
+  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: 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()) {
+  if (!plan.project_id)
+    throw new Error("Plan artifacts require a project-scoped plan");
+  const taskReferences = tasks.map((task) => ({
+    task_id: task.id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority
+  }));
+  const body = renderPlanArtifactBody(plan, taskReferences);
+  return {
+    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,
+      stable_id: plan.id,
+      name: plan.name,
+      status: plan.status,
+      created_at: plan.created_at,
+      updated_at: plan.updated_at,
+      artifact_updated_at: artifactUpdatedAt
+    },
+    task_references: taskReferences,
+    body
+  };
+}
+function renderPlanArtifactBody(plan, tasks) {
+  const lines = [`# ${markdownLine(plan.name) || plan.id}`, ""];
+  if (plan.description?.trim()) {
+    lines.push(markdownEscape(plan.description), "");
+  }
+  lines.push("## Tasks", "");
+  if (tasks.length === 0) {
+    lines.push("_No tasks are currently attached to this plan._", "");
+  } else {
+    for (const task of tasks) {
+      const check = task.status === "completed" ? "x" : " ";
+      lines.push(`- [${check}] ${markdownLine(task.title) || task.task_id}`);
+      lines.push(`  <!-- todos: task_id=${task.task_id} status=${task.status} priority=${task.priority} -->`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderPlanArtifactMarkdown(snapshot) {
+  const metadata = snapshot.metadata;
+  const lines = [
+    "---",
+    `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)}`,
+    `stable_id: ${frontmatterScalar(metadata.stable_id)}`,
+    `name: ${frontmatterScalar(metadata.name)}`,
+    `status: ${frontmatterScalar(metadata.status)}`,
+    `created_at: ${frontmatterScalar(metadata.created_at)}`,
+    `updated_at: ${frontmatterScalar(metadata.updated_at)}`,
+    `artifact_updated_at: ${frontmatterScalar(metadata.artifact_updated_at)}`,
+    "---",
+    "",
+    snapshot.body
+  ];
+  return `${lines.join(`
+`).replace(/\n{3,}/g, `
+
+`).trimEnd()}
+`;
+}
+function parsePlanArtifactMarkdown(markdown) {
+  const match = markdown.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match)
+    throw new Error("Invalid plan artifact: missing frontmatter");
+  const rawMetadata = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator === -1)
+      continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1);
+    rawMetadata[key] = parseFrontmatterScalar(value);
+  }
+  if (rawMetadata.schema !== PLAN_MARKDOWN_SCHEMA) {
+    throw new Error(`Unsupported plan artifact schema: ${rawMetadata.schema ?? "unknown"}`);
+  }
+  const required = ["plan_id", "project_id", "stable_id", "name", "status", "created_at", "updated_at", "artifact_updated_at"];
+  for (const key of required) {
+    if (!rawMetadata[key])
+      throw new Error(`Invalid plan artifact: missing ${key}`);
+  }
+  const body = match[2] ?? "";
+  return {
+    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,
+      stable_id: rawMetadata.stable_id,
+      name: rawMetadata.name,
+      status: rawMetadata.status,
+      created_at: rawMetadata.created_at,
+      updated_at: rawMetadata.updated_at,
+      artifact_updated_at: rawMetadata.artifact_updated_at
+    },
+    task_references: parseTaskReferences(body),
+    body
+  };
+}
+function parseTaskReferences(body) {
+  const references = [];
+  const taskLine = /^\s*-\s+\[[ xX]\]\s+(.+)$/;
+  const metadataLine = /<!--\s*todos:\s*task_id=([A-Za-z0-9._-]+)\s+status=([A-Za-z_]+)\s+priority=([A-Za-z_]+)\s*-->/;
+  const lines = body.split(/\r?\n/);
+  for (let index = 0;index < lines.length; index++) {
+    const titleMatch = lines[index].match(taskLine);
+    if (!titleMatch)
+      continue;
+    const metadataMatch = lines[index + 1]?.match(metadataLine);
+    if (!metadataMatch)
+      continue;
+    references.push({
+      task_id: metadataMatch[1],
+      title: titleMatch[1].trim(),
+      status: metadataMatch[2],
+      priority: metadataMatch[3]
+    });
+  }
+  return references;
+}
+function writePlanArtifact(plan, db) {
+  if (!plan.project_id)
+    return null;
+  const d = db || getDatabase();
+  const tasks = listTasks({ plan_id: plan.id, include_archived: true }, d);
+  const paths = resolvePlanArtifactCandidatePaths(plan, d).primary;
+  const snapshot = buildPlanArtifactSnapshot(plan, tasks);
+  mkdirSync5(paths.directory, { recursive: true });
+  writeFileSync3(paths.file_path, renderPlanArtifactMarkdown(snapshot), "utf8");
+  return { path: paths.file_path, snapshot };
+}
+function readPlanArtifact(plan, db) {
+  if (!plan.project_id)
+    return null;
+  const d = db || getDatabase();
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path)
+    return null;
+  const markdown = readFileSync4(path, "utf8");
+  return {
+    path,
+    markdown,
+    ...parsePlanArtifactMarkdown(markdown)
+  };
+}
+function inspectPlanArtifact(plan, db) {
+  if (!plan.project_id)
+    return null;
+  const d = db || getDatabase();
+  const paths = resolvePlanArtifactCandidatePaths(plan, d);
+  const path = existsSync8(paths.primary.file_path) ? paths.primary.file_path : existsSync8(paths.legacy.file_path) ? paths.legacy.file_path : null;
+  if (!path) {
+    return {
+      path: paths.primary.file_path,
+      exists: false,
+      parse_error: null,
+      metadata: null,
+      task_references: [],
+      conflicts: []
+    };
+  }
+  try {
+    const artifact = parsePlanArtifactMarkdown(readFileSync4(path, "utf8"));
+    return {
+      path,
+      exists: true,
+      parse_error: null,
+      metadata: artifact.metadata,
+      task_references: artifact.task_references,
+      conflicts: comparePlanArtifact(plan, artifact, listTasks({ plan_id: plan.id, include_archived: true }, d))
+    };
+  } catch (error) {
+    return {
+      path,
+      exists: true,
+      parse_error: error instanceof Error ? error.message : String(error),
+      metadata: null,
+      task_references: [],
+      conflicts: []
+    };
+  }
+}
+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);
+  compare("updated_at", plan.updated_at, artifact.metadata.updated_at, conflicts);
+  const dbTaskIds = tasks.map((task) => task.id).sort();
+  const artifactTaskIds = artifact.task_references.map((task) => task.task_id).sort();
+  if (dbTaskIds.join(",") !== artifactTaskIds.join(",")) {
+    conflicts.push({
+      field: "task_references",
+      database: dbTaskIds.join(",") || null,
+      artifact: artifactTaskIds.join(",") || null
+    });
+  }
+  return conflicts;
+}
+function compare(field, database, artifact, conflicts) {
+  if ((database ?? null) !== (artifact ?? null)) {
+    conflicts.push({ field, database: database ?? null, artifact: artifact ?? null });
+  }
+}
+var PLAN_MARKDOWN_SCHEMA = "hasna.todos.plan/v1";
+var init_plan_artifacts = __esm(() => {
+  init_database();
+  init_projects();
+  init_tasks();
+});
+
 // src/db/builtin-templates.ts
 var exports_builtin_templates = {};
 __export(exports_builtin_templates, {
@@ -13695,8 +14128,8 @@ __export(exports_builtin_templates, {
   BUILTIN_TEMPLATE_LIBRARY_SOURCE: () => BUILTIN_TEMPLATE_LIBRARY_SOURCE,
   BUILTIN_TEMPLATES: () => BUILTIN_TEMPLATES
 });
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 function templateMetadata(template) {
   return {
     source: BUILTIN_TEMPLATE_LIBRARY_SOURCE,
@@ -13752,11 +14185,11 @@ function exportBuiltinTemplateFiles() {
   }));
 }
 function writeBuiltinTemplateFiles(directory) {
-  mkdirSync5(directory, { recursive: true });
+  mkdirSync6(directory, { recursive: true });
   const files = [];
   for (const entry of exportBuiltinTemplateFiles()) {
-    const path = join7(directory, entry.filename);
-    writeFileSync3(path, `${JSON.stringify(entry.template, null, 2)}
+    const path = join8(directory, entry.filename);
+    writeFileSync4(path, `${JSON.stringify(entry.template, null, 2)}
 `, "utf-8");
     files.push(path);
   }
@@ -14023,31 +14456,105 @@ __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("--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}`);
       }
       return;
     }
-    if (opts.show) {
+    if (opts.artifact) {
       const db = getDatabase();
-      const resolvedId = resolvePartialId(db, "plans", opts.show);
-      if (!resolvedId) {
-        console.error(chalk3.red(`Could not resolve plan ID: ${opts.show}`));
+      const resolvedId = resolvePlanCliRef(opts.artifact, projectId);
+      const plan = getPlan(resolvedId);
+      if (!plan) {
+        console.error(chalk3.red(`Plan not found: ${opts.artifact}`));
         process.exit(1);
       }
+      const inspection = inspectPlanArtifact(plan, db);
+      if (!inspection) {
+        const result = { plan_id: plan.id, artifact: null, reason: "plan is not project-scoped" };
+        if (globalOpts.json)
+          output(result, true);
+        else
+          console.log(chalk3.dim("Plan is not project-scoped; no local Markdown artifact path is available."));
+        return;
+      }
+      if (globalOpts.json) {
+        output({ plan, artifact: inspection }, true);
+        return;
+      }
+      console.log(chalk3.bold(`Plan Artifact:
+`));
+      console.log(`  ${chalk3.dim("Plan:")}      ${plan.id}`);
+      console.log(`  ${chalk3.dim("Path:")}      ${inspection.path}`);
+      console.log(`  ${chalk3.dim("Exists:")}    ${inspection.exists ? "yes" : "no"}`);
+      if (inspection.parse_error)
+        console.log(`  ${chalk3.dim("Parse:")}     ${chalk3.red(inspection.parse_error)}`);
+      console.log(`  ${chalk3.dim("Conflicts:")} ${inspection.conflicts.length}`);
+      for (const conflict of inspection.conflicts) {
+        console.log(`    ${conflict.field}: db=${conflict.database ?? "null"} artifact=${conflict.artifact ?? "null"}`);
+      }
+      return;
+    }
+    if (opts.writeArtifacts) {
+      const plans2 = listPlans(projectId);
+      const written = plans2.map((plan) => ({ plan, artifact: writePlanArtifact(plan) })).filter((entry) => entry.artifact);
+      const result = {
+        count: written.length,
+        artifacts: written.map((entry) => ({
+          plan_id: entry.plan.id,
+          path: entry.artifact.path
+        }))
+      };
+      if (globalOpts.json) {
+        output(result, true);
+      } else {
+        console.log(chalk3.green(`Wrote ${written.length} plan artifact(s).`));
+        for (const artifact of result.artifacts)
+          console.log(`${chalk3.dim(artifact.plan_id.slice(0, 8))} ${artifact.path}`);
+      }
+      return;
+    }
+    if (opts.show) {
+      const db = getDatabase();
+      const resolvedId = resolvePlanCliRef(opts.show, projectId);
       const plan = getPlan(resolvedId);
       if (!plan) {
         console.error(chalk3.red(`Plan not found: ${opts.show}`));
@@ -14055,19 +14562,33 @@ function registerPlanTemplateCommands(program2) {
       }
       const { listTasks: listTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
       const tasks = listTasks2({ plan_id: resolvedId });
+      const artifact = readPlanArtifact(plan, db);
       if (globalOpts.json) {
-        output({ plan, tasks }, true);
+        output({
+          plan,
+          tasks,
+          artifact: artifact ? {
+            path: artifact.path,
+            metadata: artifact.metadata,
+            task_references: artifact.task_references,
+            body: artifact.body
+          } : null
+        }, true);
         return;
       }
       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)
         console.log(`  ${chalk3.dim("Desc:")}     ${plan.description}`);
       if (plan.project_id)
         console.log(`  ${chalk3.dim("Project:")}  ${plan.project_id}`);
+      if (artifact)
+        console.log(`  ${chalk3.dim("Artifact:")} ${artifact.path}`);
       console.log(`  ${chalk3.dim("Created:")}  ${plan.created_at}`);
       if (tasks.length > 0) {
         console.log(chalk3.bold(`
@@ -14082,12 +14603,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);
@@ -14100,19 +14616,17 @@ 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);
         if (globalOpts.json) {
           output(plan, true);
         } else {
           console.log(chalk3.green("Plan completed:"));
           console.log(`${chalk3.dim(plan.id.slice(0, 8))} ${chalk3.bold(plan.name)} ${chalk3.cyan(`[${plan.status}]`)}`);
+          if (artifact)
+            console.log(`${chalk3.dim("Artifact:")} ${artifact.path}`);
         }
       } catch (e) {
         handleError(e);
@@ -14132,7 +14646,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) => {
@@ -14390,14 +14905,14 @@ function registerPlanTemplateCommands(program2) {
   program2.command("template-import [file]").alias("templates-import").description("Import a template from a JSON file").option("--file <path>", "Path to template JSON file (alternative to positional arg)").action(async (file, opts) => {
     const globalOpts = program2.opts();
     const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
-    const { readFileSync: readFileSync4 } = await import("fs");
+    const { readFileSync: readFileSync5 } = await import("fs");
     try {
       const filePath = file || opts.file;
       if (!filePath) {
         console.error(chalk3.red("Provide a file path: todos template-import <file> or --file <path>"));
         process.exit(1);
       }
-      const content = readFileSync4(filePath, "utf-8");
+      const content = readFileSync5(filePath, "utf-8");
       const json = JSON.parse(content);
       const template = importTemplate2(json);
       if (globalOpts.json) {
@@ -14441,6 +14956,7 @@ var init_plan_template_commands = __esm(() => {
   init_database();
   init_plans();
   init_tasks();
+  init_plan_artifacts();
   init_helpers();
 });
 
@@ -15009,16 +15525,16 @@ var init_saved_search_views = __esm(() => {
 });
 
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 function getTaskListDir(taskListId) {
-  return join8(HOME, ".claude", "tasks", taskListId);
+  return join9(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join8(dir, filename));
+  return readJsonFile(join9(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join8(dir, `${task.id}.json`), task);
+  writeJsonFile(join9(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -15030,14 +15546,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join8(dir, ".prefix-counter");
-  if (!existsSync8(path))
+  const path = join9(dir, ".prefix-counter");
+  if (!existsSync9(path))
     return 0;
-  const val = parseInt(readFileSync4(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync5(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync4(join8(dir, ".prefix-counter"), String(value));
+  writeFileSync5(join9(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -15064,7 +15580,7 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -15073,7 +15589,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join8(dir, f);
+    const path = join9(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -15160,7 +15676,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync2(dir).filter((f) => f.endsWith(".json"));
@@ -15180,7 +15696,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join8(dir, f);
+      const filePath = join9(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -15253,20 +15769,20 @@ var init_claude_tasks = __esm(() => {
 });
 
 // src/lib/agent-tasks.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join9(getTodosGlobalDir(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join10(getTodosGlobalDir(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join9(agentBaseDir(agent), agent, taskListId);
+  return join10(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join9(dir, filename));
+  return readJsonFile(join10(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join9(dir, `${task.id}.json`), task);
+  writeJsonFile(join10(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -15291,7 +15807,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -15300,7 +15816,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join9(dir, f);
+    const path = join10(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -15374,7 +15890,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync9(dir)) {
+  if (!existsSync10(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -15393,7 +15909,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join9(dir, f);
+      const filePath = join10(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -15546,8 +16062,8 @@ __export(exports_project_bootstrap, {
   discoverProjectWorkspace: () => discoverProjectWorkspace,
   bootstrapProject: () => bootstrapProject
 });
-import { existsSync as existsSync10, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { basename as basename4, dirname as dirname6, resolve as resolve10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { basename as basename4, dirname as dirname6, resolve as resolve11 } from "path";
 function safeStat(path) {
   try {
     return statSync3(path);
@@ -15556,7 +16072,7 @@ function safeStat(path) {
   }
 }
 function canonicalPath(input) {
-  const resolved = resolve10(input);
+  const resolved = resolve11(input);
   const stats = safeStat(resolved);
   if (stats?.isFile())
     return dirname6(resolved);
@@ -15565,7 +16081,7 @@ function canonicalPath(input) {
 function findUp(start, marker) {
   let current = canonicalPath(start);
   while (true) {
-    if (existsSync10(resolve10(current, marker)))
+    if (existsSync11(resolve11(current, marker)))
       return current;
     const parent = dirname6(current);
     if (parent === current)
@@ -15576,11 +16092,11 @@ function findUp(start, marker) {
 function readPackageJson(path) {
   if (!path)
     return null;
-  const file = resolve10(path, "package.json");
-  if (!existsSync10(file))
+  const file = resolve11(path, "package.json");
+  if (!existsSync11(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -15599,7 +16115,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(resolve10(root, marker)))
+    if (existsSync11(resolve11(root, marker)))
       markers.push(marker);
   }
   const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
@@ -21122,9 +21638,9 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync11, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
 import { createHash as createHash3 } from "crypto";
-import { relative as relative3, resolve as resolve11, join as join10 } from "path";
+import { relative as relative3, resolve as resolve12, join as join11 } from "path";
 function stableHash(value) {
   return createHash3("sha256").update(value).digest("hex");
 }
@@ -21132,12 +21648,12 @@ function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readGitignorePatterns(basePath) {
-  const root = statSync4(basePath).isFile() ? resolve11(basePath, "..") : basePath;
-  const gitignorePath = join10(root, ".gitignore");
-  if (!existsSync11(gitignorePath))
+  const root = statSync4(basePath).isFile() ? resolve12(basePath, "..") : basePath;
+  const gitignorePath = join11(root, ".gitignore");
+  if (!existsSync12(gitignorePath))
     return [];
   try {
-    return readFileSync6(gitignorePath, "utf-8").split(`
+    return readFileSync7(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -21268,7 +21784,7 @@ function collectFiles(basePath, extensions, excludes, respectGitignore) {
   return files.sort();
 }
 function buildCodebaseIndex(options) {
-  const basePath = resolve11(options.path);
+  const basePath = resolve12(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 || [];
@@ -21276,10 +21792,10 @@ function buildCodebaseIndex(options) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const indexed = [];
   for (const file of files) {
-    const fullPath = statSync4(basePath).isFile() ? basePath : join10(basePath, file);
+    const fullPath = statSync4(basePath).isFile() ? basePath : join11(basePath, file);
     try {
-      const source = readFileSync6(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve11(basePath, ".."), fullPath) : file;
+      const source = readFileSync7(fullPath, "utf-8");
+      const relPath = statSync4(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
         checksum: stableHash(source).slice(0, 24),
@@ -21299,7 +21815,7 @@ function buildCodebaseIndex(options) {
   };
 }
 function extractTodos(options, db) {
-  const basePath = resolve11(options.path);
+  const basePath = resolve12(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 || [];
@@ -21307,10 +21823,10 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync4(basePath).isFile() ? basePath : join10(basePath, file);
+    const fullPath = statSync4(basePath).isFile() ? basePath : join11(basePath, file);
     try {
-      const source = readFileSync6(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve11(basePath, ".."), fullPath) : file;
+      const source = readFileSync7(fullPath, "utf-8");
+      const relPath = statSync4(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source, relPath, tags);
       allComments.push(...comments);
     } catch {}
@@ -21404,7 +21920,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 = resolve11(options.path);
+  const root = resolve12(options.path);
   const runs = [];
   let previous = new Map;
   for (let runNumber = 1;runNumber <= maxRuns; runNumber++) {
@@ -21705,6 +22221,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];
@@ -21841,6 +22387,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 ?? [],
@@ -21925,7 +22472,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",
@@ -22575,7 +23122,7 @@ __export(exports_project_commands, {
   registerProjectCommands: () => registerProjectCommands
 });
 import chalk4 from "chalk";
-import { basename as basename5, resolve as resolve12 } from "path";
+import { basename as basename5, resolve as resolve13 } from "path";
 function collectOption(value, previous = []) {
   return [...previous, value];
 }
@@ -22917,7 +23464,7 @@ function registerProjectCommands(program2) {
   program2.command("projects").description("List and manage projects").option("--add <path>", "Register a project by path").option("--name <name>", "Project name (with --add)").option("--task-list-id <id>", "Custom task list ID (with --add)").action(async (opts) => {
     const globalOpts = program2.opts();
     if (opts.add) {
-      const projectPath = resolve12(opts.add);
+      const projectPath = resolve13(opts.add);
       const name = opts.name || basename5(projectPath);
       const existing = getProjectByPath(projectPath);
       let project;
@@ -23025,7 +23572,7 @@ function registerProjectCommands(program2) {
         console.error(chalk4.red(`Project not found: ${projectId}`));
         process.exit(1);
       }
-      const entry = setMachineLocalPath2(resolved, resolve12(projectPath));
+      const entry = setMachineLocalPath2(resolved, resolve13(projectPath));
       if (useJson) {
         output(entry, true);
       } else {
@@ -23092,7 +23639,7 @@ function registerProjectCommands(program2) {
       const patterns = opts.pattern ? opts.pattern.split(",").map((t) => t.trim().toUpperCase()) : undefined;
       const taskListId = opts.list ? resolveTaskListId(opts.list) : undefined;
       const result = extractTodos2({
-        path: resolve12(scanPath),
+        path: resolve13(scanPath),
         patterns,
         project_id: projectId,
         task_list_id: taskListId,
@@ -23153,7 +23700,7 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
       const taskListId = opts.list ? resolveTaskListId(opts.list) : undefined;
       const maxRuns = opts.maxRuns ? parseInt(opts.maxRuns, 10) : 1;
       const result = await watchSourceTodos2({
-        path: resolve12(scanPath),
+        path: resolve13(scanPath),
         patterns,
         project_id: projectId,
         task_list_id: taskListId,
@@ -23189,8 +23736,8 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
     const projectId = autoProject(globalOpts);
     const writeOutput = async (content) => {
       if (opts.output) {
-        const { writeFileSync: writeFileSync5 } = await import("fs");
-        writeFileSync5(resolve12(opts.output), content.endsWith(`
+        const { writeFileSync: writeFileSync6 } = await import("fs");
+        writeFileSync6(resolve13(opts.output), content.endsWith(`
 `) ? content : `${content}
 `);
       } else {
@@ -23205,12 +23752,12 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
       const exported = opts.encrypt ? createEncryptedBridgeBundle2(bundle, { profile: opts.encryptionProfile }) : bundle;
       const json = JSON.stringify(exported, null, 2);
       await writeOutput(json);
-      emitLocalEventHooksQuiet3({ type: "export.finished", payload: { format: "bridge", encrypted: Boolean(opts.encrypt), project_id: projectId, output: opts.output ? resolve12(opts.output) : null, stats: bundle.stats } });
+      emitLocalEventHooksQuiet3({ type: "export.finished", payload: { format: "bridge", encrypted: Boolean(opts.encrypt), project_id: projectId, output: opts.output ? resolve13(opts.output) : null, stats: bundle.stats } });
       if (!opts.encrypt && !opts.allowPlaintextSensitive) {
         console.error(chalk4.yellow("Warning: bridge exports are plaintext JSON. Use --encrypt for sensitive metadata, evidence, and artifact bundles."));
       }
       if (opts.output && !globalOpts.json) {
-        console.log(chalk4.green(`${opts.encrypt ? "Encrypted bridge export" : "Bridge export"} written to ${resolve12(opts.output)}`));
+        console.log(chalk4.green(`${opts.encrypt ? "Encrypted bridge export" : "Bridge export"} written to ${resolve13(opts.output)}`));
       }
       return;
     }
@@ -23223,21 +23770,21 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
       await writeOutput(JSON.stringify(tasks, null, 2));
     }
     const { emitLocalEventHooksQuiet: emitLocalEventHooksQuiet2 } = await Promise.resolve().then(() => (init_event_hooks(), exports_event_hooks));
-    emitLocalEventHooksQuiet2({ type: "export.finished", payload: { format: opts.format, project_id: projectId, output: opts.output ? resolve12(opts.output) : null, count: exportedCount } });
+    emitLocalEventHooksQuiet2({ type: "export.finished", payload: { format: opts.format, project_id: projectId, output: opts.output ? resolve13(opts.output) : null, count: exportedCount } });
   });
   program2.command("bridge-import <file>").description("Dry-run or apply a local hasna/todos bridge export bundle").option("--apply", "Apply the import. Defaults to dry-run.").option("--decrypt", "Decrypt an encrypted bridge export before importing").option("--resolve-conflicts", "Safely merge existing local tasks by filling blank fields, unioning tags, and recording unresolved divergences").action(async (file, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { readFileSync: readFileSync7 } = await import("fs");
+      const { readFileSync: readFileSync8 } = await import("fs");
       const { importLocalBridgeBundle: importLocalBridgeBundle2 } = await Promise.resolve().then(() => (init_local_bridge(), exports_local_bridge));
       const { decryptBridgeBundle: decryptBridgeBundle2, isEncryptedBridgeBundle: isEncryptedBridgeBundle2 } = await Promise.resolve().then(() => (init_local_encryption(), exports_local_encryption));
-      const parsed = JSON.parse(readFileSync7(resolve12(file), "utf-8"));
+      const parsed = JSON.parse(readFileSync8(resolve13(file), "utf-8"));
       const bundle = isEncryptedBridgeBundle2(parsed) ? opts.decrypt ? decryptBridgeBundle2(parsed) : (() => {
         throw new Error("Bridge bundle is encrypted. Re-run with --decrypt and the configured key environment variable set.");
       })() : parsed;
       const result = importLocalBridgeBundle2(bundle, { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
       const { emitLocalEventHooksQuiet: emitLocalEventHooksQuiet2 } = await Promise.resolve().then(() => (init_event_hooks(), exports_event_hooks));
-      emitLocalEventHooksQuiet2({ type: "import.finished", payload: { file: resolve12(file), dry_run: result.dry_run, ok: result.ok, inserted: result.inserted, skipped: result.skipped, conflicts: result.conflicts.length, issues: result.issues.length } });
+      emitLocalEventHooksQuiet2({ type: "import.finished", payload: { file: resolve13(file), dry_run: result.dry_run, ok: result.ok, inserted: result.inserted, skipped: result.skipped, conflicts: result.conflicts.length, issues: result.issues.length } });
       if (globalOpts.json) {
         output(result, true);
         return;
@@ -23265,11 +23812,11 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
   program2.command("todos-md-import <file>").alias("markdown-import").alias("import-md").description("Dry-run or apply a local todos.md Markdown import").option("--apply", "Apply the import. Defaults to dry-run.").option("--resolve-conflicts", "Safely merge embedded bridge task conflicts while preserving local divergent fields").action(async (file, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { readFileSync: readFileSync7 } = await import("fs");
+      const { readFileSync: readFileSync8 } = await import("fs");
       const { importTodosMarkdown: importTodosMarkdown2 } = await Promise.resolve().then(() => (init_todos_md(), exports_todos_md));
-      const result = importTodosMarkdown2(readFileSync7(resolve12(file), "utf-8"), { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
+      const result = importTodosMarkdown2(readFileSync8(resolve13(file), "utf-8"), { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
       const { emitLocalEventHooksQuiet: emitLocalEventHooksQuiet2 } = await Promise.resolve().then(() => (init_event_hooks(), exports_event_hooks));
-      emitLocalEventHooksQuiet2({ type: "import.finished", payload: { file: resolve12(file), format: "todos.md", dry_run: result.dry_run, ok: result.ok, inserted: result.inserted, skipped: result.skipped, issues: result.issues.length } });
+      emitLocalEventHooksQuiet2({ type: "import.finished", payload: { file: resolve13(file), format: "todos.md", dry_run: result.dry_run, ok: result.ok, inserted: result.inserted, skipped: result.skipped, issues: result.issues.length } });
       if (globalOpts.json) {
         output(result, true);
         return;
@@ -24397,7 +24944,7 @@ __export(exports_retention_cleanup, {
   applyRetentionCleanup: () => applyRetentionCleanup,
   RETENTION_CLEANUP_CONFIRMATION: () => RETENTION_CLEANUP_CONFIRMATION
 });
-import { existsSync as existsSync12, unlinkSync } from "fs";
+import { existsSync as existsSync13, unlinkSync } from "fs";
 function normalizeScopes(scopes) {
   if (!scopes || scopes.length === 0)
     return [...ALL_SCOPES];
@@ -24600,7 +25147,7 @@ function applyRetentionCleanup(input, db) {
   for (const artifact of report.candidates.artifact_files) {
     try {
       const path = artifactStorePath(artifact.relative_path);
-      if (!existsSync12(path)) {
+      if (!existsSync13(path)) {
         report.warnings.push(`stored artifact already missing: ${artifact.relative_path}`);
         continue;
       }
@@ -25278,8 +25825,8 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash5, createVerify } from "crypto";
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
-import { basename as basename6, join as join11, resolve as resolve13 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { basename as basename6, join as join12, resolve as resolve14 } from "path";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -25360,7 +25907,7 @@ function normalizeManifest(input) {
   };
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync7(path, "utf8"));
+  return JSON.parse(readFileSync8(path, "utf8"));
 }
 function sha2563(bytes) {
   return `sha256:${createHash5("sha256").update(bytes).digest("hex")}`;
@@ -25537,14 +26084,14 @@ function verifyExtensionSignature(input) {
   return verifier.verify(input.public_key, decodeSignature(input.signature));
 }
 function inspectExtensionSource(source2) {
-  const resolved = resolve13(source2);
-  if (!existsSync13(resolved))
+  const resolved = resolve14(source2);
+  if (!existsSync14(resolved))
     throw new Error(`extension source not found: ${source2}`);
   const stat = statSync5(resolved);
-  const manifestPath = stat.isDirectory() ? [join11(resolved, "todos.extension.json"), join11(resolved, "extension.json")].find(existsSync13) : resolved;
+  const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync14) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source2} is missing todos.extension.json`);
-  const raw = readFileSync7(manifestPath);
+  const raw = readFileSync8(manifestPath);
   const parsed = parseJson(manifestPath);
   const bundle = isObject(parsed) && isObject(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -25635,26 +26182,26 @@ function testExtensionCompatibility(sourceOrManifest) {
 function projectExtensionSources(projectPath) {
   if (!projectPath)
     return [];
-  const root = resolve13(projectPath);
+  const root = resolve14(projectPath);
   const candidates = [
-    join11(root, "todos.extension.json"),
-    join11(root, ".todos", "todos.extension.json")
+    join12(root, "todos.extension.json"),
+    join12(root, ".todos", "todos.extension.json")
   ];
-  const extensionDir = join11(root, ".todos", "extensions");
-  if (existsSync13(extensionDir)) {
+  const extensionDir = join12(root, ".todos", "extensions");
+  if (existsSync14(extensionDir)) {
     for (const entry of readdirSync3(extensionDir)) {
       if (entry.startsWith("."))
         continue;
-      const full = join11(extensionDir, entry);
+      const full = join12(extensionDir, entry);
       if (statSync5(full).isDirectory() || entry.endsWith(".json"))
         candidates.push(full);
     }
   }
-  return candidates.filter(existsSync13);
+  return candidates.filter(existsSync14);
 }
 function discoverLocalExtensions(options = {}) {
   const config = loadConfig();
-  const projectPath = options.project_path ? resolve13(options.project_path) : null;
+  const projectPath = options.project_path ? resolve14(options.project_path) : null;
   const configuredSources = [
     ...config.extension_sources || [],
     ...projectPath ? config.project_overrides?.[projectPath]?.extension_sources || [] : []
@@ -25662,7 +26209,7 @@ function discoverLocalExtensions(options = {}) {
   const sources = Array.from(new Set([
     ...configuredSources,
     ...projectExtensionSources(projectPath || undefined)
-  ])).map((source2) => projectPath && !source2.startsWith("/") ? resolve13(projectPath, source2) : resolve13(source2));
+  ])).map((source2) => projectPath && !source2.startsWith("/") ? resolve14(projectPath, source2) : resolve14(source2));
   const warnings = [];
   const discovered = [];
   for (const source2 of sources) {
@@ -25922,9 +26469,9 @@ __export(exports_policy_packs, {
   getPolicyPack: () => getPolicyPack,
   explainPolicyPack: () => explainPolicyPack
 });
-import { relative as relative4, resolve as resolve14 } from "path";
+import { relative as relative4, resolve as resolve15 } from "path";
 function normalizePath3(path) {
-  return resolve14(path);
+  return resolve15(path);
 }
 function unique5(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
@@ -25979,7 +26526,7 @@ function commandMatches(commands, pattern) {
 }
 function pathMatches(paths, pattern, root) {
   return paths.filter((path) => {
-    const candidate = path.startsWith("/") ? path : resolve14(root, path);
+    const candidate = path.startsWith("/") ? path : resolve15(root, path);
     if (!isPathInside3(root, candidate))
       return matchesPattern3(path, pattern);
     return matchesPattern3(path, pattern) || matchesPattern3(relative4(root, candidate), pattern);
@@ -26945,8 +27492,8 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync, copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync6, statSync as statSync6 } from "fs";
-import { basename as basename7, dirname as dirname7, join as join12 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync7, statSync as statSync6 } from "fs";
+import { basename as basename7, dirname as dirname7, join as join13 } from "path";
 function tableExists(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
@@ -27040,7 +27587,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync14(row.path))
+    if (!existsSync15(row.path))
       missing++;
   }
   return missing;
@@ -27100,16 +27647,16 @@ function databasePermissionsAreUnsafe(dbPath) {
 function createBackup(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return;
-  if (!existsSync14(dbPath))
+  if (!existsSync15(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join12(dirname7(dbPath), `${basename7(dbPath)}.backup-${stamp}`);
+  const backupDir = join13(dirname7(dbPath), `${basename7(dbPath)}.backup-${stamp}`);
   const files = [];
-  mkdirSync6(backupDir, { recursive: true });
+  mkdirSync7(backupDir, { recursive: true });
   for (const source2 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync14(source2))
+    if (!existsSync15(source2))
       continue;
-    const target = join12(backupDir, basename7(source2));
+    const target = join13(backupDir, basename7(source2));
     copyFileSync(source2, target);
     files.push(target);
   }
@@ -27335,7 +27882,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/server/routes.ts
-import { join as join13, resolve as resolve15, sep as sep2 } from "path";
+import { join as join14, resolve as resolve16, sep as sep2 } from "path";
 function parseFieldsParam(url) {
   const fieldsParam = url.searchParams.get("fields");
   return fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
@@ -28020,6 +28567,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,
@@ -28072,9 +28620,9 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
   if (!ctx.dashboardExists || method !== "GET" && method !== "HEAD")
     return null;
   if (path !== "/") {
-    const filePath = join13(ctx.dashboardDir, path);
-    const resolvedFile = resolve15(filePath);
-    const resolvedBase = resolve15(ctx.dashboardDir);
+    const filePath = join14(ctx.dashboardDir, path);
+    const resolvedFile = resolve16(filePath);
+    const resolvedBase = resolve16(ctx.dashboardDir);
     if (!resolvedFile.startsWith(resolvedBase + sep2) && resolvedFile !== resolvedBase) {
       return json2({ error: "Forbidden" }, 403);
     }
@@ -28082,7 +28630,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
     if (res2)
       return res2;
   }
-  const indexPath = join13(ctx.dashboardDir, "index.html");
+  const indexPath = join14(ctx.dashboardDir, "index.html");
   const res = serveStaticFile2(indexPath);
   if (res)
     return res;
@@ -33077,8 +33625,8 @@ var exports_mention_resolver = {};
 __export(exports_mention_resolver, {
   resolveMentions: () => resolveMentions
 });
-import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync7 } from "fs";
-import { basename as basename8, isAbsolute, join as join14, relative as relative5, resolve as resolve16, sep as sep3 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync7 } from "fs";
+import { basename as basename8, isAbsolute, join as join15, relative as relative5, resolve as resolve17, sep as sep3 } from "path";
 function blankResolution(parsed) {
   return {
     input: parsed.input,
@@ -33101,7 +33649,7 @@ function backlink(kind, key, label, target = key) {
   return { kind, key, label, target };
 }
 function normalizeWorkspace(workspace) {
-  return resolve16(workspace || process.cwd());
+  return resolve17(workspace || process.cwd());
 }
 function isInside(root, absolutePath) {
   const rel = relative5(root, absolutePath);
@@ -33169,14 +33717,14 @@ function resolveFile(parsed, workspace) {
     resolution.warnings.push("path is empty or escapes the workspace");
     return resolution;
   }
-  const absolutePath = resolve16(workspace, relPath);
+  const absolutePath = resolve17(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;
   }
@@ -33186,7 +33734,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync8(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync9(absolutePath, "utf-8").split(/\r?\n/).length;
     if (parsed.line < 1 || parsed.line > lineCount) {
       resolution.warnings.push(`line ${parsed.line} is outside the file range 1-${lineCount}`);
       return resolution;
@@ -33209,7 +33757,7 @@ function walkSourceFiles(root, current = root, files = []) {
       if (SKIP_DIRS3.has(entry.name))
         continue;
     }
-    const absolutePath = join14(current, entry.name);
+    const absolutePath = join15(current, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS3.has(entry.name))
         walkSourceFiles(root, absolutePath, files);
@@ -33239,7 +33787,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync8(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync9(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -35973,8 +36521,8 @@ __export(exports_release_compatibility, {
   createReleaseCompatibilityReport: () => createReleaseCompatibilityReport,
   LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION: () => LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION
 });
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join15, resolve as resolve17 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join16, resolve as resolve18 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 function pass(id, message, details) {
   return { id, status: "passed", message, details };
@@ -35986,7 +36534,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync9(join15(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync10(join16(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -36082,7 +36630,7 @@ function checkChangelog() {
   ];
 }
 function createReleaseCompatibilityReport(options = {}) {
-  const root = resolve17(options.root ?? process.cwd());
+  const root = resolve18(options.root ?? process.cwd());
   const packageJson = readPackageJson2(root);
   const simulatedLevels = options.simulated_levels ?? defaultSimulationLevels();
   const checks = [
@@ -37369,6 +37917,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"),
@@ -41665,7 +42214,7 @@ __export(exports_verification_providers, {
   getVerificationRecord: () => getVerificationRecord,
   discoverVerificationProviderCapabilities: () => discoverVerificationProviderCapabilities
 });
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
 function normalizeName6(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -41762,7 +42311,7 @@ function classifyLog(text) {
 async function sleep3(ms) {
   if (ms <= 0)
     return;
-  await new Promise((resolve18) => setTimeout(resolve18, ms));
+  await new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 async function runCommandProvider(provider, input) {
   const commandTemplate = input.command || provider.command;
@@ -41817,7 +42366,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync16(input.log_path) ? readFileSync10(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync17(input.log_path) ? readFileSync11(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -41829,7 +42378,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 (!existsSync16(input.artifact_path)) {
+  if (!existsSync17(input.artifact_path)) {
     return { status: "failed", attempts: 1, exit_code: null, output_summary: `artifact not found: ${input.artifact_path}` };
   }
   return {
@@ -44111,9 +44660,9 @@ __export(exports_local_backups, {
   LOCAL_BACKUP_CHECKSUM_ALGORITHM: () => LOCAL_BACKUP_CHECKSUM_ALGORITHM
 });
 import { createHash as createHash8 } from "crypto";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname8, resolve as resolve18 } from "path";
-import { mkdirSync as mkdirSync7 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, resolve as resolve19 } from "path";
+import { mkdirSync as mkdirSync8 } from "fs";
 function stableJson(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
@@ -44214,14 +44763,14 @@ function createLocalBackup(options = {}, db) {
   return backup;
 }
 function writeLocalBackupFile(backup, outputPath) {
-  const path = resolve18(outputPath);
-  mkdirSync7(dirname8(path), { recursive: true });
-  writeFileSync5(path, `${JSON.stringify(backup, null, 2)}
+  const path = resolve19(outputPath);
+  mkdirSync8(dirname8(path), { recursive: true });
+  writeFileSync6(path, `${JSON.stringify(backup, null, 2)}
 `);
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync11(resolve18(path), "utf-8"));
+  return JSON.parse(readFileSync12(resolve19(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -44417,8 +44966,8 @@ __export(exports_onboarding_fixtures, {
   TODOS_ONBOARDING_FIXTURE_SOURCE: () => TODOS_ONBOARDING_FIXTURE_SOURCE,
   TODOS_ONBOARDING_FIXTURE_LIBRARY_VERSION: () => TODOS_ONBOARDING_FIXTURE_LIBRARY_VERSION
 });
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync6 } from "fs";
-import { join as join16 } from "path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
+import { join as join17 } from "path";
 function emptyData() {
   return {
     projects: [],
@@ -44529,6 +45078,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",
@@ -44748,11 +45298,11 @@ function getOnboardingFixtureBundle(name = "agent-project-demo") {
   return getOnboardingFixture(name).bundle;
 }
 function writeOnboardingFixtureFiles(directory) {
-  mkdirSync8(directory, { recursive: true });
+  mkdirSync9(directory, { recursive: true });
   const files = [];
   for (const fixture of allFixtures()) {
-    const path = join16(directory, `${fixture.summary.name}.bridge.json`);
-    writeFileSync6(path, `${JSON.stringify(fixture.bundle, null, 2)}
+    const path = join17(directory, `${fixture.summary.name}.bridge.json`);
+    writeFileSync7(path, `${JSON.stringify(fixture.bundle, null, 2)}
 `, "utf-8");
     files.push(path);
   }
@@ -45399,7 +45949,7 @@ __export(exports_agent_replay_simulator, {
   renderAgentReplaySimulationMarkdown: () => renderAgentReplaySimulationMarkdown
 });
 import { createHash as createHash10 } from "crypto";
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -45632,7 +46182,7 @@ function simulateAgentReplay(input, options = {}) {
   };
 }
 function simulateAgentReplayFile(path, options = {}) {
-  const parsed = JSON.parse(readFileSync12(path, "utf8"));
+  const parsed = JSON.parse(readFileSync13(path, "utf8"));
   return simulateAgentReplay(parsed, options);
 }
 function renderAgentReplaySimulationMarkdown(simulation) {
@@ -50919,28 +51469,28 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash12 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync13, statSync as statSync8 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14, statSync as statSync8 } from "fs";
 import { hostname as hostname2, platform, arch } from "os";
-import { dirname as dirname9, join as join17, resolve as resolve19 } from "path";
+import { dirname as dirname9, join as join18, resolve as resolve20 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 function sha2566(value) {
   return createHash12("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
-  const path = join17(root, relativePath);
-  if (!existsSync17(path))
+  const path = join18(root, relativePath);
+  if (!existsSync18(path))
     return null;
   const stat = statSync8(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync13(path);
+  const content = readFileSync14(path);
   return { path: relativePath, sha256: sha2566(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {
   const base = fileRecord(root, relativePath);
   if (!base)
     return null;
-  const parsed = readJsonFile(join17(root, relativePath));
+  const parsed = readJsonFile(join18(root, relativePath));
   if (!parsed)
     return { ...base, redacted: {} };
   const redacted = redactValue({
@@ -51035,15 +51585,15 @@ function commandEnv(env, includeValues) {
 function defaultSnapshotDir() {
   const dbPath = getDatabasePath();
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
-    return join17(tmpdir3(), "hasna-todos", "environment-snapshots");
-  return join17(dirname9(resolve19(dbPath)), "environment-snapshots");
+    return join18(tmpdir3(), "hasna-todos", "environment-snapshots");
+  return join18(dirname9(resolve20(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
   const digest = sha2566(JSON.stringify(snapshot)).slice(0, 24);
   return { id: `env_${digest}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
-  const root = resolve19(input.root || process.cwd());
+  const root = resolve20(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));
@@ -51083,13 +51633,13 @@ function captureEnvironmentSnapshot(input = {}) {
   });
 }
 function writeEnvironmentSnapshot(snapshot, outputPath) {
-  const path = outputPath ? resolve19(outputPath) : join17(defaultSnapshotDir(), `${snapshot.id}.json`);
+  const path = outputPath ? resolve20(outputPath) : join18(defaultSnapshotDir(), `${snapshot.id}.json`);
   ensureDir2(dirname9(path));
   writeJsonFile(path, snapshot);
   return path;
 }
 function readEnvironmentSnapshot(path) {
-  const snapshot = readJsonFile(resolve19(path));
+  const snapshot = readJsonFile(resolve20(path));
   if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
     throw new Error(`Invalid environment snapshot: ${path}`);
   }
@@ -51614,27 +52164,27 @@ __export(exports_serve, {
   SECURITY_HEADERS: () => SECURITY_HEADERS,
   MIME_TYPES: () => MIME_TYPES
 });
-import { existsSync as existsSync18 } from "fs";
-import { join as join18, dirname as dirname10, extname } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join19, dirname as dirname10, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname10(fileURLToPath2(import.meta.url));
-    candidates.push(join18(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join18(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join19(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join19(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname10(process.argv[1]);
-    candidates.push(join18(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join18(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join19(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join19(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join18(process.cwd(), "dashboard", "dist"));
+  candidates.push(join19(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync18(candidate))
+    if (existsSync19(candidate))
       return candidate;
   }
-  return join18(process.cwd(), "dashboard", "dist");
+  return join19(process.cwd(), "dashboard", "dist");
 }
 function getProvidedApiKey(req) {
   const headerKey = req.headers.get("x-api-key");
@@ -51684,7 +52234,7 @@ function json(data, status = 200, headers) {
   });
 }
 function serveStaticFile(filePath) {
-  if (!existsSync18(filePath))
+  if (!existsSync19(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -51765,7 +52315,7 @@ data: ${data}
       filteredSseClients.delete(client);
   }
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync18(dashboardDir);
+  const dashboardExists = existsSync19(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -53595,12 +54145,12 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk6 from "chalk";
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname11, join as join19 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname11, join as join20 } from "path";
 function registerConfigServeCommands(program2) {
   program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
     const globalOpts = program2.opts();
-    const configPath = join19(getTodosGlobalDir(), "config.json");
+    const configPath = join20(getTodosGlobalDir(), "config.json");
     if (opts.get) {
       const config2 = loadConfig();
       const keys = opts.get.split(".");
@@ -53626,7 +54176,7 @@ function registerConfigServeCommands(program2) {
       }
       let config2 = {};
       try {
-        config2 = JSON.parse(readFileSync14(configPath, "utf-8"));
+        config2 = JSON.parse(readFileSync15(configPath, "utf-8"));
       } catch {}
       const keys = key.split(".");
       let obj = config2;
@@ -53637,9 +54187,9 @@ function registerConfigServeCommands(program2) {
       }
       obj[keys[keys.length - 1]] = parsedValue;
       const dir = dirname11(configPath);
-      if (!existsSync19(dir))
-        mkdirSync9(dir, { recursive: true });
-      writeFileSync7(configPath, JSON.stringify(config2, null, 2));
+      if (!existsSync20(dir))
+        mkdirSync10(dir, { recursive: true });
+      writeFileSync8(configPath, JSON.stringify(config2, null, 2));
       if (globalOpts.json) {
         output({ key, value: parsedValue }, true);
       } else {
@@ -53766,7 +54316,7 @@ function registerConfigServeCommands(program2) {
   redaction.command("scan [text]").description("Scan text or a file for secret-like values without printing values").option("--file <path>", "File to scan").action(async (text2, opts) => {
     const globalOpts = program2.opts();
     const { listSecretFindings: listSecretFindings2 } = await Promise.resolve().then(() => (init_redaction(), exports_redaction));
-    const value = opts.file ? readFileSync14(opts.file, "utf-8") : text2 || "";
+    const value = opts.file ? readFileSync15(opts.file, "utf-8") : text2 || "";
     const findings = listSecretFindings2(value);
     if (globalOpts.json) {
       output({ ok: findings.length === 0, findings }, true);
@@ -55152,7 +55702,7 @@ __export(exports_query_commands, {
   registerQueryCommands: () => registerQueryCommands
 });
 import chalk7 from "chalk";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
 function parseJsonObjectOption2(value, label) {
   if (!value)
     return;
@@ -55811,9 +56361,9 @@ Repairs`));
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
       const { statSync: statSync9 } = await import("fs");
-      const { join: join20 } = await import("path");
+      const { join: join21 } = await import("path");
       const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join20(home, ".hasna", "todos", "todos.db");
+      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join21(home, ".hasna", "todos", "todos.db");
       let size = "unknown";
       try {
         size = `${(statSync9(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
@@ -56430,7 +56980,7 @@ Repairs`));
     const sessionId = opts.session || globalOpts.session || undefined;
     try {
       if (opts.import) {
-        const bundle = JSON.parse(readFileSync15(opts.import, "utf-8"));
+        const bundle = JSON.parse(readFileSync16(opts.import, "utf-8"));
         const result = importHandoffBundle(bundle, { apply: opts.apply }, db);
         if (opts.json || globalOpts.json) {
           console.log(JSON.stringify(result));
@@ -56446,7 +56996,7 @@ Repairs`));
         const bundle = exportHandoffBundle(opts.export, db);
         const json2 = JSON.stringify(bundle, null, 2);
         if (opts.output) {
-          writeFileSync8(opts.output, `${json2}
+          writeFileSync9(opts.output, `${json2}
 `);
           if (opts.json || globalOpts.json) {
             console.log(JSON.stringify({ path: opts.output, handoff_id: bundle.handoff.id }));
@@ -56677,7 +57227,7 @@ Repairs`));
       });
       const content = format === "json" ? JSON.stringify(document, null, 2) : renderReleaseNotesMarkdown2(document);
       if (opts.out) {
-        writeFileSync8(opts.out, content);
+        writeFileSync9(opts.out, content);
         if (format !== "json")
           console.log(chalk7.green(`Wrote release notes to ${opts.out}`));
         return;
@@ -56792,7 +57342,7 @@ Repairs`));
         redact: Boolean(opts.redact)
       });
       if (opts.out) {
-        writeFileSync8(opts.out, exported.content);
+        writeFileSync9(opts.out, exported.content);
         if (!(opts.json || globalOpts.json))
           console.log(chalk7.green(`Wrote ${exported.events.length} events to ${opts.out}`));
       }
@@ -56808,7 +57358,7 @@ Repairs`));
   });
   calendar.command("import <path>").description("Import VEVENT entries from an ICS file as local imported calendar items").option("-j, --json", "Output JSON").action((path, opts) => {
     try {
-      const result = importCalendarIcs(readFileSync15(path, "utf-8"));
+      const result = importCalendarIcs(readFileSync16(path, "utf-8"));
       if (opts.json || program2.opts().json) {
         output(result, true);
         return;
@@ -56947,7 +57497,7 @@ Repairs`));
       const bundle = exportTaskBoardBundle(boardId);
       const json2 = JSON.stringify(bundle, null, 2);
       if (opts.out) {
-        writeFileSync8(opts.out, json2);
+        writeFileSync9(opts.out, json2);
         if (!(opts.json || program2.opts().json))
           console.log(chalk7.green(`Wrote ${bundle.boards.length} board(s) to ${opts.out}`));
       }
@@ -56959,7 +57509,7 @@ Repairs`));
   });
   board.command("import <path>").description("Import local board definitions from a JSON bundle").option("-j, --json", "Output JSON").action((path, opts) => {
     try {
-      const bundle = JSON.parse(readFileSync15(path, "utf-8"));
+      const bundle = JSON.parse(readFileSync16(path, "utf-8"));
       const result = importTaskBoardBundle(bundle);
       if (opts.json || program2.opts().json) {
         output(result, true);
@@ -57335,7 +57885,7 @@ Repairs`));
       const { importExternalIssues: importExternalIssues2 } = await Promise.resolve().then(() => (init_external_issue_importers(), exports_external_issue_importers));
       let body = text2 || "";
       if (opts.file)
-        body = readFileSync15(opts.file, "utf-8");
+        body = readFileSync16(opts.file, "utf-8");
       if (!body && !opts.url && !process.stdin.isTTY)
         body = await Bun.stdin.text();
       if (!body.trim() && !opts.url) {
@@ -57393,7 +57943,7 @@ Repairs`));
       } = await Promise.resolve().then(() => (init_tester_issue_reports(), exports_tester_issue_reports));
       let body = jsonText || "";
       if (opts.file)
-        body = readFileSync15(opts.file, "utf-8");
+        body = readFileSync16(opts.file, "utf-8");
       if (!body && !process.stdin.isTTY)
         body = await Bun.stdin.text();
       if (!body.trim()) {
@@ -57436,11 +57986,11 @@ Repairs`));
   const inbox = program2.command("inbox").description("Capture local inbox items from pasted errors, CI logs, git context, files, or GitHub issue URLs");
   inbox.command("add [text]").description("Create a local inbox item and linked task from text, stdin, or a file").option("--file <path>", "Read captured context from a file").option("--source-type <type>", "pasted_error, ci_log, git_context, github_issue, file, or other").option("--source-name <name>", "Human-readable source name").option("--source-url <url>", "Source URL, including GitHub issue URLs").option("--title <title>", "Task/inbox title").option("--priority <priority>", "Task priority").option("--tags <tags>", "Comma-separated extra tags").option("--metadata <json>", "Additional JSON metadata").option("--no-task", "Only store inbox item; do not create a linked task").option("-j, --json", "Output as JSON").action(async (text2, opts) => {
     const globalOpts = program2.opts();
-    const { readFileSync: readFileSync16 } = await import("fs");
+    const { readFileSync: readFileSync17 } = await import("fs");
     const { createInboxItem: createInboxItem2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
     let body = text2 || "";
     if (opts.file)
-      body = readFileSync16(opts.file, "utf-8");
+      body = readFileSync17(opts.file, "utf-8");
     if (!body && !process.stdin.isTTY)
       body = await Bun.stdin.text();
     if (!body.trim()) {
@@ -57501,11 +58051,11 @@ ${diff}` : null].filter(Boolean).join(`
   });
   inbox.command("parse [text]").description("Preview or apply deterministic local natural-language task intake").option("--file <path>", "Read natural-language input from a file").option("--priority <priority>", "Default priority for parsed tasks", "medium").option("--project <id>", "Project ID for applied tasks").option("--list <id>", "Task list ID for applied tasks").option("--reference-date <iso>", "Reference date for due today/tomorrow/next week").option("--apply", "Create parsed tasks; default is dry-run preview").option("-j, --json", "Output as JSON").action(async (text2, opts) => {
     const globalOpts = program2.opts();
-    const { readFileSync: readFileSync16 } = await import("fs");
+    const { readFileSync: readFileSync17 } = await import("fs");
     const { previewNaturalLanguageIntake: previewNaturalLanguageIntake2 } = await Promise.resolve().then(() => (init_natural_language_intake(), exports_natural_language_intake));
     let body = text2 || "";
     if (opts.file)
-      body = readFileSync16(opts.file, "utf-8");
+      body = readFileSync17(opts.file, "utf-8");
     if (!body && !process.stdin.isTTY)
       body = await Bun.stdin.text();
     if (!body.trim()) {
@@ -57629,45 +58179,45 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname12, join as join20 } from "path";
+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";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join20(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync20(bunBin))
+  const bunBin = join21(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync21(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return {};
   try {
-    return JSON.parse(readFileSync16(path, "utf-8"));
+    return JSON.parse(readFileSync17(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeJsonFile2(path, data) {
   const dir = dirname12(path);
-  if (!existsSync20(dir))
-    mkdirSync10(dir, { recursive: true });
-  writeFileSync9(path, JSON.stringify(data, null, 2) + `
+  if (!existsSync21(dir))
+    mkdirSync11(dir, { recursive: true });
+  writeFileSync10(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return "";
-  return readFileSync16(path, "utf-8");
+  return readFileSync17(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname12(path);
-  if (!existsSync20(dir))
-    mkdirSync10(dir, { recursive: true });
-  writeFileSync9(path, content);
+  if (!existsSync21(dir))
+    mkdirSync11(dir, { recursive: true });
+  writeFileSync10(path, content);
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -57731,7 +58281,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join20(HOME2, ".codex", "config.toml");
+  const configPath = join21(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -57745,7 +58295,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join20(HOME2, ".codex", "config.toml");
+  const configPath = join21(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}`));
@@ -57757,7 +58307,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join20(HOME2, ".gemini", "settings.json");
+  const configPath = join21(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -57771,7 +58321,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join20(HOME2, ".gemini", "settings.json");
+  const configPath = join21(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -57828,9 +58378,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join20(process.cwd(), ".claude", "hooks");
-    if (!existsSync20(hooksDir))
-      mkdirSync10(hooksDir, { recursive: true });
+    const hooksDir = join21(process.cwd(), ".claude", "hooks");
+    if (!existsSync21(hooksDir))
+      mkdirSync11(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
@@ -57854,11 +58404,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join20(hooksDir, "todos-sync.sh");
-    writeFileSync9(hookPath, hookScript);
+    const hookPath = join21(hooksDir, "todos-sync.sh");
+    writeFileSync10(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join20(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join21(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -58727,18 +59277,18 @@ Artifacts:`));
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (existsSync20(hookPath)) {
-        const existing = readFileSync16(hookPath, "utf-8");
+      if (existsSync21(hookPath)) {
+        const existing = readFileSync17(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk8.yellow("Hook already installed."));
           return;
         }
-        writeFileSync9(hookPath, existing + `
+        writeFileSync10(hookPath, existing + `
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
       } else {
-        writeFileSync9(hookPath, `#!/usr/bin/env bash
+        writeFileSync10(hookPath, `#!/usr/bin/env bash
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
@@ -58755,11 +59305,11 @@ $(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 (!existsSync20(hookPath)) {
+      if (!existsSync21(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
-      const content = readFileSync16(hookPath, "utf-8");
+      const content = readFileSync17(hookPath, "utf-8");
       if (!content.includes(marker)) {
         console.log(chalk8.dim("Hook not managed by todos."));
         return;
@@ -58770,7 +59320,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       if (cleaned === "#!/usr/bin/env bash" || cleaned === "") {
         (await import("fs")).unlinkSync(hookPath);
       } else {
-        writeFileSync9(hookPath, cleaned + `
+        writeFileSync10(hookPath, cleaned + `
 `);
       }
       console.log(chalk8.green("Post-commit hook removed."));
@@ -58939,9 +59489,9 @@ __export(exports_machines, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync17, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
+import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -58979,11 +59529,11 @@ function remoteTempPath(sshAddress) {
 }
 function readRemoteBridgeBundle(sshAddress) {
   const remotePath = remoteTempPath(sshAddress);
-  const localPath = join21(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
+  const localPath = join22(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
   try {
     runSsh(sshAddress, `todos export --format bridge --allow-plaintext-sensitive --output ${shellQuote(remotePath)}`, 120000);
     scpFromRemote(sshAddress, remotePath, localPath);
-    return JSON.parse(readFileSync17(localPath, "utf-8"));
+    return JSON.parse(readFileSync18(localPath, "utf-8"));
   } finally {
     try {
       runSsh(sshAddress, `rm -f ${shellQuote(remotePath)}`, 1e4);
@@ -58994,8 +59544,8 @@ function readRemoteBridgeBundle(sshAddress) {
   }
 }
 function writeLocalBridgeBundle() {
-  const localPath = join21(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
-  writeFileSync10(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
+  const localPath = join22(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
+  writeFileSync11(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
   return localPath;
 }
 function pushLocalBridgeBundle(sshAddress, dryRun) {
@@ -60058,7 +60608,7 @@ __export(exports_onboarding_commands, {
   registerOnboardingCommands: () => registerOnboardingCommands
 });
 import chalk17 from "chalk";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } 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();
@@ -60074,7 +60624,7 @@ function registerOnboardingCommands(program2) {
         return;
       }
       if (opts.write) {
-        const result = writeOnboardingFixtureFiles2(resolve20(opts.write));
+        const result = writeOnboardingFixtureFiles2(resolve21(opts.write));
         if (globalOpts.json) {
           output(result, true);
           return;
@@ -63522,8 +64072,8 @@ __export(exports_sdk_integration_fixtures, {
   TODOS_SDK_INTEGRATION_FIXTURE_SCHEMA_VERSION: () => TODOS_SDK_INTEGRATION_FIXTURE_SCHEMA_VERSION,
   TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT: () => TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT
 });
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join23 } from "path";
 function source5(version) {
   return {
     packageName: "@hasna/todos",
@@ -63619,7 +64169,7 @@ function createSdkIntegrationFixturePack(options = {}) {
   };
 }
 function writeSdkIntegrationFixtures(directory, options = {}) {
-  mkdirSync11(directory, { recursive: true });
+  mkdirSync12(directory, { recursive: true });
   const pack = createSdkIntegrationFixturePack(options);
   const bundle = getOnboardingFixtureBundle("agent-project-demo");
   const files = [
@@ -63630,8 +64180,8 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   ];
   const written = [];
   for (const [name, payload] of files) {
-    const file = join22(directory, name);
-    writeFileSync11(file, `${JSON.stringify(payload, null, 2)}
+    const file = join23(directory, name);
+    writeFileSync12(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
   }
@@ -63654,7 +64204,7 @@ __export(exports_sdk_fixture_commands, {
   registerSdkFixtureCommands: () => registerSdkFixtureCommands
 });
 import chalk19 from "chalk";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } 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();
@@ -63665,7 +64215,7 @@ function registerSdkFixtureCommands(program2) {
         writeSdkIntegrationFixtures: writeSdkIntegrationFixtures2
       } = await Promise.resolve().then(() => (init_sdk_integration_fixtures(), exports_sdk_integration_fixtures));
       if (opts.write) {
-        const result = writeSdkIntegrationFixtures2(resolve21(opts.write));
+        const result = writeSdkIntegrationFixtures2(resolve22(opts.write));
         if (globalOpts.json) {
           console.log(JSON.stringify(result));
           return;
@@ -63895,7 +64445,7 @@ var exports_roadmap_commands = {};
 __export(exports_roadmap_commands, {
   registerRoadmapCommands: () => registerRoadmapCommands
 });
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
 import chalk21 from "chalk";
 function splitList3(value) {
   return value?.split(";").flatMap((part) => part.split(",")).map((item) => item.trim()).filter(Boolean);
@@ -64106,7 +64656,7 @@ function registerRoadmapCommands(program2) {
       const { exportRoadmapBundle: exportRoadmapBundle2, renderRoadmapMarkdown: renderRoadmapMarkdown2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const content = opts.format === "markdown" ? renderRoadmapMarkdown2(roadmap) : JSON.stringify(exportRoadmapBundle2(roadmap), null, 2);
       if (opts.out) {
-        writeFileSync12(opts.out, content);
+        writeFileSync13(opts.out, content);
         if (!globalOpts.json)
           console.log(chalk21.green(`Wrote roadmap export to ${opts.out}`));
       }
@@ -64124,7 +64674,7 @@ function registerRoadmapCommands(program2) {
     const globalOpts = globalOptions(program2);
     try {
       const { importRoadmapBundle: importRoadmapBundle2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
-      const bundle = JSON.parse(readFileSync18(path, "utf8"));
+      const bundle = JSON.parse(readFileSync19(path, "utf8"));
       const result = importRoadmapBundle2(bundle, { apply: Boolean(opts.apply) });
       if (globalOpts.json) {
         output(result, true);
@@ -64487,7 +65037,7 @@ __export(exports_local_backup_commands, {
   registerLocalBackupCommands: () => registerLocalBackupCommands
 });
 import chalk26 from "chalk";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 function globalOptions6(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
@@ -64509,10 +65059,10 @@ function registerLocalBackupCommands(program2) {
       const projectId = opts.projectId ?? autoProject(globalOpts);
       const backupBundle = createLocalBackup2({
         project_id: projectId,
-        output_path: opts.output ? resolve22(opts.output) : undefined
+        output_path: opts.output ? resolve23(opts.output) : undefined
       });
       const result = {
-        output_path: opts.output ? resolve22(opts.output) : null,
+        output_path: opts.output ? resolve23(opts.output) : null,
         backup: backupBundle
       };
       if (opts.json || globalOpts.json) {
@@ -65922,9 +66472,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,
@@ -65938,7 +66496,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");
@@ -66191,8 +66759,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));