@hasna/todos 0.11.68 → 0.11.70

package/dist/cli/index.js

@@ -12448,6 +12448,7 @@ __export(exports_helpers, {
   resolveTaskId: () => resolveTaskId,
   resolveExplicitProject: () => resolveExplicitProject,
   priorityColors: () => priorityColors,
+  printJson: () => printJson,
   output: () => output,
   normalizeStatusList: () => normalizeStatusList,
   normalizeStatus: () => normalizeStatus,
@@ -12460,6 +12461,7 @@ __export(exports_helpers, {
 });
 import chalk from "chalk";
 import { execSync } from "child_process";
+import { writeSync } from "fs";
 import { resolve as resolve8 } from "path";
 function handleError(e) {
   console.error(chalk.red(e instanceof Error ? e.message : String(e)));
@@ -12556,9 +12558,35 @@ function normalizeStatusList(statuses) {
     return statuses.map(normalizeStatus);
   return normalizeStatus(statuses);
 }
+function writeStdoutSync(text) {
+  const buffer = Buffer.from(text);
+  let offset = 0;
+  while (offset < buffer.length) {
+    try {
+      const written = writeSync(1, buffer, offset, buffer.length - offset);
+      if (written <= 0)
+        throw new Error("Unable to write complete stdout payload");
+      offset += written;
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+      if (code === "EPIPE") {
+        return;
+      }
+      if (code === "EAGAIN" || code === "EWOULDBLOCK" || code === "EINTR") {
+        Atomics.wait(stdoutRetrySignal, 0, 0, 1);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function printJson(data) {
+  writeStdoutSync(`${JSON.stringify(data, null, 2)}
+`);
+}
 function output(data, jsonMode) {
   if (jsonMode) {
-    console.log(JSON.stringify(data, null, 2));
+    printJson(data);
   }
 }
 function formatTaskLine(t) {
@@ -12570,11 +12598,13 @@ function formatTaskLine(t) {
   const plan = t.plan_id ? chalk.magenta(` [plan:${t.plan_id.slice(0, 8)}]`) : "";
   return `${chalk.dim(t.id.slice(0, 8))} ${statusFn(t.status.padEnd(11))} ${priorityFn(t.priority.padEnd(8))} ${t.title}${assigned}${lock}${tags}${plan}`;
 }
-var statusColors, priorityColors;
+var stdoutRetryBuffer, stdoutRetrySignal, statusColors, priorityColors;
 var init_helpers = __esm(() => {
   init_database();
   init_projects();
   init_package_version();
+  stdoutRetryBuffer = new SharedArrayBuffer(4);
+  stdoutRetrySignal = new Int32Array(stdoutRetryBuffer);
   statusColors = {
     pending: chalk.yellow,
     in_progress: chalk.blue,
@@ -13651,6 +13681,299 @@ 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 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;
+  return {
+    project_id: project.id,
+    project_root: projectRoot,
+    directory,
+    file_path: planId ? join7(directory, `${planId}.md`) : directory
+  };
+}
+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,
+      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)}`,
+    `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,
+      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 = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
+  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 = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
+  if (!existsSync8(paths.file_path))
+    return null;
+  const markdown = readFileSync4(paths.file_path, "utf8");
+  return {
+    path: paths.file_path,
+    markdown,
+    ...parsePlanArtifactMarkdown(markdown)
+  };
+}
+function inspectPlanArtifact(plan, db) {
+  if (!plan.project_id)
+    return null;
+  const d = db || getDatabase();
+  const paths = resolvePlanArtifactPaths({ project_id: plan.project_id, plan_id: plan.id, db: d });
+  if (!existsSync8(paths.file_path)) {
+    return {
+      path: paths.file_path,
+      exists: false,
+      parse_error: null,
+      metadata: null,
+      task_references: [],
+      conflicts: []
+    };
+  }
+  try {
+    const artifact = parsePlanArtifactMarkdown(readFileSync4(paths.file_path, "utf8"));
+    return {
+      path: paths.file_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: paths.file_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);
+  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, {
@@ -13665,8 +13988,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,
@@ -13722,11 +14045,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);
   }
@@ -13994,7 +14317,7 @@ __export(exports_plan_template_commands, {
 });
 import chalk3 from "chalk";
 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("-d, --description <text>", "Plan description (with --add)").option("--show <id>", "Show plan details with its tasks").option("--artifact <id>", "Show local Markdown artifact diagnostics for a plan").option("--write-artifacts", "Write local Markdown artifacts for all project-scoped plans in scope").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action((opts) => {
     const globalOpts = program2.opts();
     const projectId = autoProject(globalOpts);
     if (opts.add) {
@@ -14003,11 +14326,71 @@ function registerPlanTemplateCommands(program2) {
         description: opts.description,
         project_id: projectId
       });
+      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}]`)}`);
+        if (artifact)
+          console.log(`${chalk3.dim("Artifact:")} ${artifact.path}`);
+      }
+      return;
+    }
+    if (opts.artifact) {
+      const db = getDatabase();
+      const resolvedId = resolvePartialId(db, "plans", opts.artifact);
+      if (!resolvedId) {
+        console.error(chalk3.red(`Could not resolve plan ID: ${opts.artifact}`));
+        process.exit(1);
+      }
+      const 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;
     }
@@ -14025,8 +14408,18 @@ 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:
@@ -14038,6 +14431,8 @@ function registerPlanTemplateCommands(program2) {
         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(`
@@ -14078,11 +14473,14 @@ function registerPlanTemplateCommands(program2) {
       }
       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);
@@ -14360,14 +14758,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) {
@@ -14411,6 +14809,7 @@ var init_plan_template_commands = __esm(() => {
   init_database();
   init_plans();
   init_tasks();
+  init_plan_artifacts();
   init_helpers();
 });
 
@@ -14979,16 +15378,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") {
@@ -15000,14 +15399,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");
@@ -15034,7 +15433,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)
@@ -15043,7 +15442,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) });
@@ -15130,7 +15529,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"));
@@ -15150,7 +15549,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;
@@ -15223,20 +15622,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 {
@@ -15261,7 +15660,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)
@@ -15270,7 +15669,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) });
@@ -15344,7 +15743,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);
@@ -15363,7 +15762,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;
@@ -15516,8 +15915,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);
@@ -15526,7 +15925,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);
@@ -15535,7 +15934,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)
@@ -15546,11 +15945,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;
@@ -15569,7 +15968,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;
@@ -21092,9 +21491,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");
 }
@@ -21102,12 +21501,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 [];
@@ -21238,7 +21637,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 || [];
@@ -21246,10 +21645,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),
@@ -21269,7 +21668,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 || [];
@@ -21277,10 +21676,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 {}
@@ -21374,7 +21773,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++) {
@@ -22545,7 +22944,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];
 }
@@ -22887,7 +23286,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;
@@ -22995,7 +23394,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 {
@@ -23062,7 +23461,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,
@@ -23123,7 +23522,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,
@@ -23159,8 +23558,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 {
@@ -23175,12 +23574,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;
     }
@@ -23193,21 +23592,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;
@@ -23235,11 +23634,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;
@@ -24367,7 +24766,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];
@@ -24570,7 +24969,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;
       }
@@ -25248,8 +25647,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));
 }
@@ -25330,7 +25729,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")}`;
@@ -25507,14 +25906,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);
@@ -25605,26 +26004,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 || [] : []
@@ -25632,7 +26031,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) {
@@ -25892,9 +26291,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)));
@@ -25949,7 +26348,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);
@@ -26915,8 +27314,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));
 }
@@ -27010,7 +27409,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync14(row.path))
+    if (!existsSync15(row.path))
       missing++;
   }
   return missing;
@@ -27070,16 +27469,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);
   }
@@ -27305,7 +27704,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;
@@ -28042,9 +28441,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);
     }
@@ -28052,7 +28451,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;
@@ -33047,8 +33446,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,
@@ -33071,7 +33470,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);
@@ -33139,14 +33538,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;
   }
@@ -33156,7 +33555,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;
@@ -33179,7 +33578,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);
@@ -33209,7 +33608,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);
@@ -35943,8 +36342,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 };
@@ -35956,7 +36355,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));
@@ -36052,7 +36451,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 = [
@@ -41635,7 +42034,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)) {
@@ -41732,7 +42131,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;
@@ -41787,7 +42186,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,
@@ -41799,7 +42198,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 {
@@ -44081,9 +44480,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);
@@ -44184,14 +44583,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();
@@ -44387,8 +44786,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: [],
@@ -44718,11 +45117,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);
   }
@@ -45369,7 +45768,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));
 }
@@ -45602,7 +46001,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) {
@@ -50889,28 +51288,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({
@@ -51005,15 +51404,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));
@@ -51053,13 +51452,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}`);
   }
@@ -51584,27 +51983,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");
@@ -51654,7 +52053,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";
@@ -51735,7 +52134,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}`);
@@ -53565,12 +53964,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(".");
@@ -53596,7 +53995,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;
@@ -53607,9 +54006,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 {
@@ -53736,7 +54135,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);
@@ -55122,7 +55521,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;
@@ -55781,9 +56180,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`;
@@ -56400,7 +56799,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));
@@ -56416,7 +56815,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 }));
@@ -56647,7 +57046,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;
@@ -56762,7 +57161,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}`));
       }
@@ -56778,7 +57177,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;
@@ -56917,7 +57316,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}`));
       }
@@ -56929,7 +57328,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);
@@ -57305,7 +57704,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) {
@@ -57363,7 +57762,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()) {
@@ -57406,11 +57805,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()) {
@@ -57471,11 +57870,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()) {
@@ -57599,45 +57998,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(`
@@ -57701,7 +58100,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 = `
@@ -57715,7 +58114,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}`));
@@ -57727,7 +58126,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"] = {};
@@ -57741,7 +58140,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)) {
@@ -57798,9 +58197,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.
@@ -57824,11 +58223,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"] = {};
@@ -58697,18 +59096,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
 `);
@@ -58725,11 +59124,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;
@@ -58740,7 +59139,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."));
@@ -58909,9 +59308,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";
 }
@@ -58949,11 +59348,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);
@@ -58964,8 +59363,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) {
@@ -59403,7 +59802,7 @@ __export(exports_environment_snapshots2, {
   registerEnvironmentSnapshotCommands: () => registerEnvironmentSnapshotCommands
 });
 import chalk12 from "chalk";
-function printJson(value) {
+function printJson2(value) {
   console.log(JSON.stringify(value, null, 2));
 }
 function registerEnvironmentSnapshotCommands(program2) {
@@ -59421,7 +59820,7 @@ function registerEnvironmentSnapshotCommands(program2) {
         include_env_values: Boolean(opts.includeEnvValues)
       });
       if (globalOpts.json) {
-        printJson(result);
+        printJson2(result);
         return;
       }
       console.log(chalk12.green("Captured") + ` ${result.snapshot.id}`);
@@ -59438,7 +59837,7 @@ function registerEnvironmentSnapshotCommands(program2) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (globalOpts.json)
-        printJson({ error: message });
+        printJson2({ error: message });
       else
         console.error(chalk12.red(`Error: ${message}`));
       process.exit(1);
@@ -59449,7 +59848,7 @@ function registerEnvironmentSnapshotCommands(program2) {
     try {
       const comparison = compareEnvironmentSnapshotFiles(left, right);
       if (globalOpts.json) {
-        printJson(comparison);
+        printJson2(comparison);
         return;
       }
       console.log(`left: ${comparison.left_id}`);
@@ -59464,7 +59863,7 @@ function registerEnvironmentSnapshotCommands(program2) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (globalOpts.json)
-        printJson({ error: message });
+        printJson2({ error: message });
       else
         console.error(chalk12.red(`Error: ${message}`));
       process.exit(1);
@@ -60028,7 +60427,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();
@@ -60044,7 +60443,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;
@@ -63492,8 +63891,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",
@@ -63589,7 +63988,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 = [
@@ -63600,8 +63999,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);
   }
@@ -63624,7 +64023,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();
@@ -63635,7 +64034,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;
@@ -63865,7 +64264,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);
@@ -64076,7 +64475,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}`));
       }
@@ -64094,7 +64493,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);
@@ -64457,7 +64856,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();
@@ -64479,10 +64878,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) {