@hasna/todos 0.11.42 → 0.11.44

package/dist/cli/index.js

@@ -8908,9 +8908,83 @@ var init_plans = __esm(() => {
 // src/db/builtin-templates.ts
 var exports_builtin_templates = {};
 __export(exports_builtin_templates, {
+  writeBuiltinTemplateFiles: () => writeBuiltinTemplateFiles,
+  listBuiltinTemplates: () => listBuiltinTemplates,
   initBuiltinTemplates: () => initBuiltinTemplates,
+  getBuiltinTemplate: () => getBuiltinTemplate,
+  exportBuiltinTemplateFiles: () => exportBuiltinTemplateFiles,
+  exportBuiltinTemplate: () => exportBuiltinTemplate,
+  BUILTIN_TEMPLATE_LIBRARY_VERSION: () => BUILTIN_TEMPLATE_LIBRARY_VERSION,
+  BUILTIN_TEMPLATE_LIBRARY_SOURCE: () => BUILTIN_TEMPLATE_LIBRARY_SOURCE,
   BUILTIN_TEMPLATES: () => BUILTIN_TEMPLATES
 });
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+function templateMetadata(template) {
+  return {
+    source: BUILTIN_TEMPLATE_LIBRARY_SOURCE,
+    library_version: template.version,
+    category: template.category,
+    template_file: `${template.name}.json`,
+    local_only: true,
+    marketplace_free: true
+  };
+}
+function listBuiltinTemplates() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    ...template,
+    variables: template.variables.map((variable) => ({ ...variable })),
+    tasks: template.tasks.map((task) => ({ ...task, tags: task.tags ? [...task.tags] : undefined }))
+  }));
+}
+function getBuiltinTemplate(name) {
+  return listBuiltinTemplates().find((template) => template.name === name) ?? null;
+}
+function exportBuiltinTemplate(name) {
+  const template = getBuiltinTemplate(name);
+  if (!template)
+    throw new Error(`Built-in template not found: ${name}`);
+  return {
+    name: template.name,
+    title_pattern: `${template.name}: {${template.variables[0]?.name ?? "name"}}`,
+    description: template.description,
+    priority: "medium",
+    tags: [template.category, "local-template"],
+    variables: template.variables,
+    project_id: null,
+    plan_id: null,
+    metadata: templateMetadata(template),
+    tasks: template.tasks.map((task) => ({
+      position: task.position,
+      title_pattern: task.title_pattern,
+      description: task.description ?? null,
+      priority: task.priority ?? "medium",
+      tags: task.tags ?? [template.category],
+      task_type: task.task_type ?? null,
+      condition: task.condition ?? null,
+      include_template_id: task.include_template_id ?? null,
+      depends_on_positions: task.depends_on_positions ?? task.depends_on ?? [],
+      metadata: task.metadata ?? { category: template.category }
+    }))
+  };
+}
+function exportBuiltinTemplateFiles() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    filename: `${template.name}.json`,
+    template: exportBuiltinTemplate(template.name)
+  }));
+}
+function writeBuiltinTemplateFiles(directory) {
+  mkdirSync4(directory, { recursive: true });
+  const files = [];
+  for (const entry of exportBuiltinTemplateFiles()) {
+    const path = join5(directory, entry.filename);
+    writeFileSync2(path, `${JSON.stringify(entry.template, null, 2)}
+`, "utf-8");
+    files.push(path);
+  }
+  return { directory, written: files.length, files };
+}
 function initBuiltinTemplates(db) {
   const d = db || getDatabase();
   const existing = listTemplates(d);
@@ -8936,7 +9010,9 @@ function initBuiltinTemplates(db) {
       name: bt.name,
       title_pattern: `${bt.name}: {${bt.variables[0]?.name || "name"}}`,
       description: bt.description,
+      tags: [bt.category, "local-template"],
       variables: bt.variables,
+      metadata: templateMetadata(bt),
       tasks
     }, d);
     created++;
@@ -8944,14 +9020,141 @@ function initBuiltinTemplates(db) {
   }
   return { created, skipped, names };
 }
-var BUILTIN_TEMPLATES;
+var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21", BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library", BUILTIN_TEMPLATES;
 var init_builtin_templates = __esm(() => {
   init_database();
   init_templates();
   BUILTIN_TEMPLATES = [
+    {
+      name: "bug-fix",
+      description: "Reproduce, diagnose, fix, test, and release a defect.",
+      category: "bug-fix",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "bug", required: true, description: "Bug description" }],
+      tasks: [
+        { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical", tags: ["bug", "repro"] },
+        { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", tags: ["bug", "diagnosis"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Write regression test for {bug}", priority: "high", tags: ["bug", "test"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Implement fix for {bug}", priority: "critical", tags: ["bug", "implementation"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Run full verification for {bug}", priority: "high", tags: ["bug", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Publish and smoke test fix for {bug}", priority: "high", tags: ["bug", "release"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "feature-implementation",
+      description: "Plan, build, test, document, and release a product feature.",
+      category: "feature",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [
+        { name: "feature", required: true, description: "Feature name" },
+        { name: "scope", required: false, default: "medium", description: "Implementation size or risk" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Define acceptance criteria for {feature}", priority: "high", tags: ["feature", "spec"] },
+        { position: 1, title_pattern: "Design {scope} implementation plan for {feature}", priority: "high", tags: ["feature", "design"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement {feature}", priority: "critical", tags: ["feature", "implementation"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Add tests for {feature}", priority: "high", tags: ["feature", "test"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Update docs for {feature}", priority: "medium", tags: ["feature", "docs"], depends_on_positions: [2] },
+        { position: 5, title_pattern: "Run release checks for {feature}", priority: "high", tags: ["feature", "verification"], depends_on_positions: [3, 4] }
+      ]
+    },
+    {
+      name: "security-review",
+      description: "Threat model, test, remediate, and report on security posture.",
+      category: "security",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "target", required: true, description: "System, package, or change under review" }],
+      tasks: [
+        { position: 0, title_pattern: "Map trust boundaries for {target}", priority: "critical", tags: ["security", "threat-model"] },
+        { position: 1, title_pattern: "Scan {target} for vulnerabilities and secret exposure", priority: "critical", tags: ["security", "scan"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Review authz, data access, and dependency risks in {target}", priority: "critical", tags: ["security", "review"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Fix critical security findings in {target}", priority: "critical", tags: ["security", "fix"], depends_on_positions: [1, 2] },
+        { position: 4, title_pattern: "Retest {target} security fixes", priority: "high", tags: ["security", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Write local security review report for {target}", priority: "medium", tags: ["security", "report"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "release",
+      description: "Prepare, verify, publish, install, and smoke test a package release.",
+      category: "release",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [
+        { name: "package", required: true, description: "Package name" },
+        { name: "version", required: false, default: "patch", description: "Release version or bump type" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Prepare {package} {version} release notes", priority: "medium", tags: ["release", "docs"] },
+        { position: 1, title_pattern: "Run full tests for {package}", priority: "critical", tags: ["release", "test"] },
+        { position: 2, title_pattern: "Run build and release verification for {package}", priority: "critical", tags: ["release", "verification"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Scan {package} release diff for secrets", priority: "critical", tags: ["release", "security"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Publish {package} {version}", priority: "high", tags: ["release", "publish"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Install and smoke test published {package}", priority: "high", tags: ["release", "smoke"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "migration",
+      description: "Plan, test, apply, and verify a schema or data migration.",
+      category: "migration",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "migration", required: true, description: "Migration name or objective" }],
+      tasks: [
+        { position: 0, title_pattern: "Design migration plan for {migration}", priority: "critical", tags: ["migration", "plan"] },
+        { position: 1, title_pattern: "Write rollback plan for {migration}", priority: "critical", tags: ["migration", "rollback"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement migration {migration}", priority: "critical", tags: ["migration", "implementation"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Test migration {migration} on fixture data", priority: "high", tags: ["migration", "test"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Run migration {migration} verification and drift checks", priority: "high", tags: ["migration", "verification"], depends_on_positions: [1, 3] },
+        { position: 5, title_pattern: "Document migration {migration} evidence", priority: "medium", tags: ["migration", "docs"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "incident",
+      description: "Triage, mitigate, repair, verify, and retrospect an incident.",
+      category: "incident",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "incident", required: true, description: "Incident summary" }],
+      tasks: [
+        { position: 0, title_pattern: "Triage incident: {incident}", priority: "critical", tags: ["incident", "triage"] },
+        { position: 1, title_pattern: "Mitigate customer impact for {incident}", priority: "critical", tags: ["incident", "mitigation"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Diagnose root cause for {incident}", priority: "critical", tags: ["incident", "diagnosis"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Implement durable repair for {incident}", priority: "critical", tags: ["incident", "repair"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Verify recovery from {incident}", priority: "high", tags: ["incident", "verification"], depends_on_positions: [1, 3] },
+        { position: 5, title_pattern: "Write retrospective for {incident}", priority: "medium", tags: ["incident", "retro"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "docs-refresh",
+      description: "Audit, update, validate, and publish documentation changes.",
+      category: "docs",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "area", required: true, description: "Documentation area or product surface" }],
+      tasks: [
+        { position: 0, title_pattern: "Audit current docs for {area}", priority: "medium", tags: ["docs", "audit"] },
+        { position: 1, title_pattern: "Update examples and commands for {area}", priority: "medium", tags: ["docs", "examples"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Validate docs snippets for {area}", priority: "high", tags: ["docs", "verification"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Refresh screenshots or generated artifacts for {area}", priority: "medium", tags: ["docs", "assets"], depends_on_positions: [1] },
+        { position: 4, title_pattern: "Publish docs refresh for {area}", priority: "medium", tags: ["docs", "release"], depends_on_positions: [2, 3] }
+      ]
+    },
+    {
+      name: "qa",
+      description: "Build a focused QA plan, execute checks, file defects, and sign off.",
+      category: "qa",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "target", required: true, description: "Feature, release, or workflow under QA" }],
+      tasks: [
+        { position: 0, title_pattern: "Create QA matrix for {target}", priority: "high", tags: ["qa", "plan"] },
+        { position: 1, title_pattern: "Run happy-path QA for {target}", priority: "high", tags: ["qa", "manual"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Run edge-case QA for {target}", priority: "high", tags: ["qa", "edge-cases"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "File and dedupe QA defects for {target}", priority: "medium", tags: ["qa", "bugs"], depends_on_positions: [1, 2] },
+        { position: 4, title_pattern: "Verify QA fixes for {target}", priority: "high", tags: ["qa", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Record QA signoff for {target}", priority: "medium", tags: ["qa", "signoff"], depends_on_positions: [4] }
+      ]
+    },
     {
       name: "open-source-project",
       description: "Full open-source project bootstrap \u2014 scaffold to publish",
+      category: "open-source",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
       variables: [
         { name: "name", required: true, description: "Service name" },
         { name: "org", required: false, default: "hasna", description: "GitHub org" }
@@ -8971,45 +9174,6 @@ var init_builtin_templates = __esm(() => {
         { position: 11, title_pattern: "Publish @hasna/{name} to npm", priority: "high", depends_on_positions: [6, 7, 8] },
         { position: 12, title_pattern: "Install @hasna/{name} globally and verify", priority: "medium", depends_on_positions: [11] }
       ]
-    },
-    {
-      name: "bug-fix",
-      description: "Standard bug fix workflow",
-      variables: [{ name: "bug", required: true, description: "Bug description" }],
-      tasks: [
-        { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical" },
-        { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", depends_on_positions: [0] },
-        { position: 2, title_pattern: "Implement fix for {bug}", priority: "critical", depends_on_positions: [1] },
-        { position: 3, title_pattern: "Write regression test for {bug}", priority: "high", depends_on_positions: [2] },
-        { position: 4, title_pattern: "Publish fix and verify in production", priority: "high", depends_on_positions: [3] }
-      ]
-    },
-    {
-      name: "feature",
-      description: "Standard feature development workflow",
-      variables: [{ name: "feature", required: true }, { name: "scope", required: false, default: "medium" }],
-      tasks: [
-        { position: 0, title_pattern: "Write spec for {feature}", priority: "high" },
-        { position: 1, title_pattern: "Design implementation approach for {feature}", priority: "high", depends_on_positions: [0] },
-        { position: 2, title_pattern: "Implement {feature}", priority: "critical", depends_on_positions: [1] },
-        { position: 3, title_pattern: "Write tests for {feature}", priority: "high", depends_on_positions: [2] },
-        { position: 4, title_pattern: "Code review for {feature}", priority: "medium", depends_on_positions: [3] },
-        { position: 5, title_pattern: "Update docs for {feature}", priority: "medium", depends_on_positions: [2] },
-        { position: 6, title_pattern: "Deploy {feature}", priority: "high", depends_on_positions: [4] }
-      ]
-    },
-    {
-      name: "security-audit",
-      description: "Security audit workflow",
-      variables: [{ name: "target", required: true }],
-      tasks: [
-        { position: 0, title_pattern: "Scan {target} for vulnerabilities", priority: "critical" },
-        { position: 1, title_pattern: "Review {target} security findings", priority: "critical", depends_on_positions: [0] },
-        { position: 2, title_pattern: "Fix critical issues in {target}", priority: "critical", depends_on_positions: [1] },
-        { position: 3, title_pattern: "Retest {target} after fixes", priority: "high", depends_on_positions: [2] },
-        { position: 4, title_pattern: "Write security report for {target}", priority: "medium", depends_on_positions: [3] },
-        { position: 5, title_pattern: "Close audit for {target}", priority: "low", depends_on_positions: [4] }
-      ]
     }
   ];
 });
@@ -9277,7 +9441,7 @@ function registerPlanTemplateCommands(program2) {
       console.log(`  ${chalk3.dim(t.id.slice(0, 8))} ${chalk3.bold(t.name)} ${chalk3.cyan(`"${t.title_pattern}"`)} ${chalk3.yellow(t.priority)}${vars}`);
     }
   });
-  program2.command("template-init").alias("templates-init").description("Initialize built-in starter templates (open-source-project, bug-fix, feature, security-audit)").action(async () => {
+  program2.command("template-init").alias("templates-init").description("Initialize the bundled local template library").action(async () => {
     const globalOpts = program2.opts();
     const { initBuiltinTemplates: initBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
     const result = initBuiltinTemplates2();
@@ -9291,6 +9455,52 @@ function registerPlanTemplateCommands(program2) {
       console.log(chalk3.green(`Created ${result.created} template(s): ${result.names.join(", ")}. Skipped ${result.skipped} existing.`));
     }
   });
+  program2.command("template-library").alias("templates-library").description("List, show, or write the bundled local template library as editable JSON files").option("--show <name>", "Show one bundled template as JSON").option("--write <dir>", "Write all bundled templates to editable JSON files").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const {
+      exportBuiltinTemplate: exportBuiltinTemplate2,
+      listBuiltinTemplates: listBuiltinTemplates2,
+      writeBuiltinTemplateFiles: writeBuiltinTemplateFiles2
+    } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+    try {
+      if (opts.show) {
+        const template = exportBuiltinTemplate2(opts.show);
+        output(template, true);
+        return;
+      }
+      if (opts.write) {
+        const result = writeBuiltinTemplateFiles2(opts.write);
+        if (globalOpts.json) {
+          output(result, true);
+          return;
+        }
+        console.log(chalk3.green(`Wrote ${result.written} editable template file(s) to ${result.directory}`));
+        for (const file of result.files)
+          console.log(chalk3.dim(`  ${file}`));
+        return;
+      }
+      const templates = listBuiltinTemplates2().map((template) => ({
+        name: template.name,
+        description: template.description,
+        category: template.category,
+        version: template.version,
+        variables: template.variables,
+        task_count: template.tasks.length
+      }));
+      if (globalOpts.json) {
+        output(templates, true);
+        return;
+      }
+      console.log(chalk3.bold(`${templates.length} bundled local template(s):
+`));
+      for (const template of templates) {
+        console.log(`  ${chalk3.bold(template.name)} ${chalk3.dim(`[${template.category}]`)} ${chalk3.yellow(`${template.task_count} tasks`)}`);
+        console.log(chalk3.dim(`    ${template.description}`));
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
   program2.command("template-preview <id>").alias("templates-preview").description("Preview a template without creating tasks \u2014 shows resolved titles, deps, and priorities").option("--var <vars...>", "Variable substitution in key=value format (e.g. --var name=invoices)").action(async (id, opts) => {
     const globalOpts = program2.opts();
     const { previewTemplate: previewTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
@@ -10008,16 +10218,16 @@ var init_saved_search_views = __esm(() => {
 });
 
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 function getTaskListDir(taskListId) {
-  return join5(HOME, ".claude", "tasks", taskListId);
+  return join6(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join5(dir, filename));
+  return readJsonFile(join6(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join5(dir, `${task.id}.json`), task);
+  writeJsonFile(join6(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -10029,14 +10239,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join5(dir, ".prefix-counter");
+  const path = join6(dir, ".prefix-counter");
   if (!existsSync5(path))
     return 0;
   const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync2(join5(dir, ".prefix-counter"), String(value));
+  writeFileSync3(join6(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -10072,7 +10282,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join5(dir, f);
+    const path = join6(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -10179,7 +10389,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join5(dir, f);
+      const filePath = join6(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -10253,26 +10463,26 @@ var init_claude_tasks = __esm(() => {
 
 // src/lib/agent-tasks.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function getTodosGlobalDir2() {
-  const newDir = join6(HOME, ".hasna", "todos");
-  const legacyDir = join6(HOME, ".todos");
+  const newDir = join7(HOME, ".hasna", "todos");
+  const legacyDir = join7(HOME, ".todos");
   if (!existsSync6(newDir) && existsSync6(legacyDir))
     return legacyDir;
   return newDir;
 }
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join6(getTodosGlobalDir2(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join7(getTodosGlobalDir2(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join6(agentBaseDir(agent), agent, taskListId);
+  return join7(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join6(dir, filename));
+  return readJsonFile(join7(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join6(dir, `${task.id}.json`), task);
+  writeJsonFile(join7(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -10306,7 +10516,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join6(dir, f);
+    const path = join7(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -10399,7 +10609,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join6(dir, f);
+      const filePath = join7(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -10810,7 +11020,7 @@ __export(exports_extract, {
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
 import { readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { relative as relative3, resolve as resolve7, join as join7 } from "path";
+import { relative as relative3, resolve as resolve7, join as join8 } from "path";
 function tagToPriority(tag) {
   switch (tag) {
     case "BUG":
@@ -10882,7 +11092,7 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync3(basePath).isFile() ? basePath : join7(basePath, file);
+    const fullPath = statSync3(basePath).isFile() ? basePath : join8(basePath, file);
     try {
       const source = readFileSync5(fullPath, "utf-8");
       const relPath = statSync3(basePath).isFile() ? relative3(resolve7(basePath, ".."), fullPath) : file;
@@ -11009,8 +11219,8 @@ var init_extract = __esm(() => {
 
 // src/lib/artifact-store.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname6, join as join8, resolve as resolve8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, join as join9, resolve as resolve8 } from "path";
 import { tmpdir } from "os";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
@@ -11022,15 +11232,15 @@ function artifactStoreRoot() {
     return resolve8(process.env["TODOS_ARTIFACTS_DIR"]);
   const dbPath = getDatabasePath();
   if (isInMemoryDb2(dbPath))
-    return join8(tmpdir(), "hasna-todos-artifacts");
-  return join8(dirname6(resolve8(dbPath)), "artifacts");
+    return join9(tmpdir(), "hasna-todos-artifacts");
+  return join9(dirname6(resolve8(dbPath)), "artifacts");
 }
 function artifactStorePath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   if (normalized.includes("..") || normalized.startsWith("/") || normalized.length === 0) {
     throw new Error("Invalid artifact store path");
   }
-  return join8(artifactStoreRoot(), normalized);
+  return join9(artifactStoreRoot(), normalized);
 }
 function sha256(buffer) {
   return createHash2("sha256").update(buffer).digest("hex");
@@ -11088,11 +11298,11 @@ function storeArtifactContent(input) {
       redactionStatus = "redacted";
   }
   const storedSha = sha256(storedBuffer);
-  const relativePath = join8("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
+  const relativePath = join9("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
   const destination = artifactStorePath(relativePath);
   if (!existsSync8(destination)) {
-    mkdirSync4(dirname6(destination), { recursive: true });
-    writeFileSync3(destination, storedBuffer);
+    mkdirSync5(dirname6(destination), { recursive: true });
+    writeFileSync4(destination, storedBuffer);
   }
   const createdAt = input.created_at || new Date().toISOString();
   const retentionDays = input.retention_days ?? null;
@@ -11209,8 +11419,8 @@ function importStoredArtifactContent(content) {
     };
   }
   const destination = artifactStorePath(content.relative_path);
-  mkdirSync4(dirname6(destination), { recursive: true });
-  writeFileSync3(destination, buffer);
+  mkdirSync5(dirname6(destination), { recursive: true });
+  writeFileSync4(destination, buffer);
   return {
     id: content.artifact_id,
     path: content.relative_path,
@@ -13032,8 +13242,8 @@ function registerProjectCommands(program2) {
     const projectId = autoProject(globalOpts);
     const writeOutput = async (content) => {
       if (opts.output) {
-        const { writeFileSync: writeFileSync4 } = await import("fs");
-        writeFileSync4(resolve9(opts.output), content.endsWith(`
+        const { writeFileSync: writeFileSync5 } = await import("fs");
+        writeFileSync5(resolve9(opts.output), content.endsWith(`
 `) ? content : `${content}
 `);
       } else {
@@ -14822,8 +15032,8 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync5, statSync as statSync5 } from "fs";
-import { basename as basename4, dirname as dirname7, join as join9 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync6, statSync as statSync5 } from "fs";
+import { basename as basename4, dirname as dirname7, join as join10 } from "path";
 function tableExists(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
@@ -14980,13 +15190,13 @@ function createBackup(dbPath) {
   if (!existsSync9(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join9(dirname7(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
+  const backupDir = join10(dirname7(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
   const files = [];
-  mkdirSync5(backupDir, { recursive: true });
+  mkdirSync6(backupDir, { recursive: true });
   for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     if (!existsSync9(source))
       continue;
-    const target = join9(backupDir, basename4(source));
+    const target = join10(backupDir, basename4(source));
     copyFileSync(source, target);
     files.push(target);
   }
@@ -15212,7 +15422,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/server/routes.ts
-import { join as join10, resolve as resolve11, sep } from "path";
+import { join as join11, resolve as resolve11, sep } from "path";
 function parseFieldsParam(url) {
   const fieldsParam = url.searchParams.get("fields");
   return fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
@@ -15912,7 +16122,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
   if (!ctx.dashboardExists || method !== "GET" && method !== "HEAD")
     return null;
   if (path !== "/") {
-    const filePath = join10(ctx.dashboardDir, path);
+    const filePath = join11(ctx.dashboardDir, path);
     const resolvedFile = resolve11(filePath);
     const resolvedBase = resolve11(ctx.dashboardDir);
     if (!resolvedFile.startsWith(resolvedBase + sep) && resolvedFile !== resolvedBase) {
@@ -15922,7 +16132,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
     if (res2)
       return res2;
   }
-  const indexPath = join10(ctx.dashboardDir, "index.html");
+  const indexPath = join11(ctx.dashboardDir, "index.html");
   const res = serveStaticFile2(indexPath);
   if (res)
     return res;
@@ -15952,26 +16162,26 @@ __export(exports_serve, {
   MIME_TYPES: () => MIME_TYPES
 });
 import { existsSync as existsSync10 } from "fs";
-import { join as join11, dirname as dirname8, extname } from "path";
+import { join as join12, dirname as dirname8, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname8(fileURLToPath2(import.meta.url));
-    candidates.push(join11(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join11(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join12(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join12(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname8(process.argv[1]);
-    candidates.push(join11(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join11(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join12(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join12(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join11(process.cwd(), "dashboard", "dist"));
+  candidates.push(join12(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
     if (existsSync10(candidate))
       return candidate;
   }
-  return join11(process.cwd(), "dashboard", "dist");
+  return join12(process.cwd(), "dashboard", "dist");
 }
 function getProvidedApiKey(req) {
   const headerKey = req.headers.get("x-api-key");
@@ -17747,14 +17957,14 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk6 from "chalk";
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname9, join as join12 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname9, join as join13 } 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 home = process.env["HOME"] || "~";
-    const newPath = join12(home, ".hasna", "todos", "config.json");
-    const legacyPath = join12(home, ".todos", "config.json");
+    const newPath = join13(home, ".hasna", "todos", "config.json");
+    const legacyPath = join13(home, ".todos", "config.json");
     const configPath = !existsSync11(newPath) && existsSync11(legacyPath) ? legacyPath : newPath;
     if (opts.get) {
       const config2 = loadConfig();
@@ -17793,8 +18003,8 @@ function registerConfigServeCommands(program2) {
       obj[keys[keys.length - 1]] = parsedValue;
       const dir = dirname9(configPath);
       if (!existsSync11(dir))
-        mkdirSync6(dir, { recursive: true });
-      writeFileSync4(configPath, JSON.stringify(config2, null, 2));
+        mkdirSync7(dir, { recursive: true });
+      writeFileSync5(configPath, JSON.stringify(config2, null, 2));
       if (globalOpts.json) {
         output({ key, value: parsedValue }, true);
       } else {
@@ -20605,8 +20815,8 @@ Repairs`));
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
       const { statSync: statSync6 } = await import("fs");
-      const { join: join13 } = await import("path");
-      const dbPath = process.env["TODOS_DB_PATH"] || join13(process.env["HOME"] || "~", ".todos", "todos.db");
+      const { join: join14 } = await import("path");
+      const dbPath = process.env["TODOS_DB_PATH"] || join14(process.env["HOME"] || "~", ".todos", "todos.db");
       let size = "unknown";
       try {
         size = `${(statSync6(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
@@ -26403,6 +26613,8 @@ var init_token_utils = __esm(() => {
       "check_file_lock",
       "create_comment",
       "create_handoff",
+      "capture_environment_snapshot",
+      "compare_environment_snapshots",
       "create_inbox_item",
       "delete_comment",
       "detect_file_relationships",
@@ -26525,10 +26737,12 @@ var init_token_utils = __esm(() => {
       "export_template",
       "import_template",
       "init_templates",
+      "list_template_library",
       "list_templates",
       "preview_template",
       "template_history",
-      "update_template"
+      "update_template",
+      "write_template_library"
     ],
     webhooks: ["create_webhook", "delete_webhook", "list_webhooks"],
     machines: [
@@ -32670,6 +32884,587 @@ var init_agents2 = __esm(() => {
   init_database();
 });
 
+// src/mcp/tools/templates.ts
+function registerTemplateTools(server, { shouldRegisterTool, resolveId, formatError }) {
+  if (shouldRegisterTool("create_template")) {
+    server.tool("create_template", "Create a reusable task template. Optionally include a tasks array to define a multi-task template with dependencies and variable placeholders ({name} syntax). Use variables to define typed variable definitions with defaults and required flags.", {
+      name: exports_external.string(),
+      title_pattern: exports_external.string(),
+      description: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      project_id: exports_external.string().optional(),
+      plan_id: exports_external.string().optional(),
+      variables: exports_external.array(exports_external.object({
+        name: exports_external.string().describe("Variable name (used as {name} in patterns)"),
+        required: exports_external.boolean().describe("Whether this variable must be provided"),
+        default: exports_external.string().optional().describe("Default value if not provided"),
+        description: exports_external.string().optional().describe("Help text for the variable")
+      })).optional().describe("Typed variable definitions with defaults and required flags"),
+      tasks: exports_external.array(exports_external.object({
+        title_pattern: exports_external.string().describe("Title pattern with optional {variable} placeholders"),
+        description: exports_external.string().optional(),
+        priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+        tags: exports_external.array(exports_external.string()).optional(),
+        task_type: exports_external.string().optional(),
+        depends_on: exports_external.array(exports_external.number()).optional().describe("Position indices (0-based) of tasks this task depends on"),
+        metadata: exports_external.record(exports_external.unknown()).optional()
+      })).optional().describe("Multi-task template: ordered list of tasks to create together with dependencies")
+    }, async (params) => {
+      try {
+        const { createTemplate: createTemplate2, getTemplateWithTasks: getTemplateWithTasks2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const t = createTemplate2(params);
+        const withTasks = getTemplateWithTasks2(t.id);
+        const taskCount = withTasks?.tasks.length ?? 0;
+        const taskInfo = taskCount > 0 ? ` | ${taskCount} task(s)` : "";
+        return { content: [{ type: "text", text: `Template created: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}"${taskInfo}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_templates")) {
+    server.tool("list_templates", "List all task templates", {}, async () => {
+      try {
+        const { listTemplates: listTemplates2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const templates = listTemplates2();
+        if (templates.length === 0)
+          return { content: [{ type: "text", text: "No templates." }] };
+        const text = templates.map((t) => {
+          const vars = t.variables.length > 0 ? ` | vars: ${t.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")}` : "";
+          return `${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}${vars}`;
+        }).join(`
+`);
+        return { content: [{ type: "text", text: `${templates.length} template(s):
+${text}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("create_task_from_template")) {
+    server.tool("create_task_from_template", "Create task(s) from a template. For multi-task templates, creates all tasks with dependencies wired. Supports {variable} substitution in titles/descriptions.", {
+      template_id: exports_external.string(),
+      title: exports_external.string().optional().describe("Override title (single-task templates only)"),
+      description: exports_external.string().optional().describe("Override description (single-task templates only)"),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      assigned_to: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      task_list_id: exports_external.string().optional(),
+      variables: exports_external.record(exports_external.string()).optional().describe("Variable substitution map for {name} placeholders in multi-task templates")
+    }, async (params) => {
+      try {
+        const { taskFromTemplate: taskFromTemplate2, getTemplateWithTasks: getTemplateWithTasks2, tasksFromTemplate: tasksFromTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedTemplateId = resolveId(params.template_id, "task_templates");
+        const resolvedProjectId = params.project_id ? resolveId(params.project_id, "projects") : undefined;
+        const resolvedTaskListId = params.task_list_id ? resolveId(params.task_list_id, "task_lists") : undefined;
+        const templateWithTasks = getTemplateWithTasks2(resolvedTemplateId);
+        if (templateWithTasks && templateWithTasks.tasks.length > 0) {
+          const effectiveProjectId = resolvedProjectId || templateWithTasks.project_id || undefined;
+          const tasks = tasksFromTemplate2(resolvedTemplateId, effectiveProjectId, params.variables, resolvedTaskListId);
+          const text = tasks.map((t) => `${t.id.slice(0, 8)} | ${t.priority} | ${t.title}`).join(`
+`);
+          return { content: [{ type: "text", text: `${tasks.length} task(s) created from template:
+${text}` }] };
+        }
+        const input = taskFromTemplate2(resolvedTemplateId, {
+          title: params.title,
+          description: params.description,
+          priority: params.priority,
+          assigned_to: params.assigned_to,
+          project_id: resolvedProjectId,
+          task_list_id: resolvedTaskListId
+        });
+        const task = createTask(input);
+        return { content: [{ type: "text", text: `Task created from template:
+${task.id.slice(0, 8)} | ${task.priority} | ${task.title}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("delete_template")) {
+    server.tool("delete_template", "Delete a task template by ID.", { id: exports_external.string() }, async ({ id }) => {
+      try {
+        const { deleteTemplate: deleteTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(id, "task_templates");
+        const deleted = deleteTemplate2(resolvedId);
+        return { content: [{ type: "text", text: deleted ? "Template deleted." : "Template not found." }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("update_template")) {
+    server.tool("update_template", "Update a task template's name, title pattern, description, priority, tags, or other fields.", {
+      id: exports_external.string(),
+      name: exports_external.string().optional(),
+      title_pattern: exports_external.string().optional(),
+      description: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      project_id: exports_external.string().optional(),
+      plan_id: exports_external.string().optional()
+    }, async ({ id, ...updates }) => {
+      try {
+        const { updateTemplate: updateTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(id, "task_templates");
+        const t = updateTemplate2(resolvedId, updates);
+        if (!t)
+          return { content: [{ type: "text", text: `Template not found: ${id}` }], isError: true };
+        return { content: [{ type: "text", text: `Template updated: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("init_templates")) {
+    server.tool("init_templates", "Initialize the bundled local template library. Skips templates that already exist by name.", {}, async () => {
+      try {
+        const { initBuiltinTemplates: initBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        const result = initBuiltinTemplates2();
+        if (result.created === 0)
+          return { content: [{ type: "text", text: `All ${result.skipped} built-in template(s) already exist.` }] };
+        return { content: [{ type: "text", text: `Created ${result.created} template(s): ${result.names.join(", ")}. Skipped ${result.skipped} existing.` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_template_library")) {
+    server.tool("list_template_library", "List the bundled marketplace-free local template library without mutating the database.", {}, async () => {
+      try {
+        const { listBuiltinTemplates: listBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        const templates = listBuiltinTemplates2().map((template) => ({
+          name: template.name,
+          description: template.description,
+          category: template.category,
+          version: template.version,
+          variables: template.variables,
+          task_count: template.tasks.length
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(templates, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("write_template_library")) {
+    server.tool("write_template_library", "Write the bundled local template library to editable JSON files for review or import.", { directory: exports_external.string() }, async ({ directory }) => {
+      try {
+        const { writeBuiltinTemplateFiles: writeBuiltinTemplateFiles2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        return { content: [{ type: "text", text: JSON.stringify(writeBuiltinTemplateFiles2(directory), null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("preview_template")) {
+    server.tool("preview_template", "Preview a template without creating tasks. Shows resolved titles (variables substituted), dependencies, and priorities.", {
+      template_id: exports_external.string(),
+      variables: exports_external.record(exports_external.string()).optional().describe("Variable substitution map for {name} placeholders")
+    }, async (params) => {
+      try {
+        const { previewTemplate: previewTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(params.template_id, "task_templates");
+        const preview = previewTemplate2(resolvedId, params.variables);
+        const lines = preview.tasks.map((t) => {
+          const deps = t.depends_on_positions.length > 0 ? ` (after: ${t.depends_on_positions.join(", ")})` : "";
+          return `  [${t.position}] ${t.priority} | ${t.title}${deps}`;
+        });
+        const varsInfo = preview.variables.length > 0 ? `
+Variables: ${preview.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")}` : "";
+        const resolvedVars = Object.keys(preview.resolved_variables).length > 0 ? `
+Resolved: ${Object.entries(preview.resolved_variables).map(([k, v]) => `${k}=${v}`).join(", ")}` : "";
+        return { content: [{ type: "text", text: `Preview: ${preview.template_name} (${preview.tasks.length} tasks)${varsInfo}${resolvedVars}
+${lines.join(`
+`)}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("export_template")) {
+    server.tool("export_template", "Export a template as a full JSON object (template + tasks + variables). Useful for sharing or backup.", { template_id: exports_external.string() }, async ({ template_id }) => {
+      try {
+        const { exportTemplate: exportTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(template_id, "task_templates");
+        const json2 = exportTemplate2(resolvedId);
+        return { content: [{ type: "text", text: JSON.stringify(json2, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("import_template")) {
+    server.tool("import_template", "Import a template from a JSON string (as returned by export_template). Creates new template with new IDs.", { json: exports_external.string().describe("JSON string of the template export") }, async ({ json: json2 }) => {
+      try {
+        const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const parsed = JSON.parse(json2);
+        const t = importTemplate2(parsed);
+        return { content: [{ type: "text", text: `Template imported: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}"` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("template_history")) {
+    server.tool("template_history", "Show version history of a template. Each update creates a snapshot of the previous state.", { template_id: exports_external.string() }, async ({ template_id }) => {
+      try {
+        const { listTemplateVersions: listTemplateVersions2, getTemplate: getTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(template_id, "task_templates");
+        const template = getTemplate2(resolvedId);
+        if (!template)
+          return { content: [{ type: "text", text: `Template not found: ${template_id}` }], isError: true };
+        const versions = listTemplateVersions2(resolvedId);
+        if (versions.length === 0)
+          return { content: [{ type: "text", text: `${template.name} v${template.version} \u2014 no previous versions.` }] };
+        const lines = versions.map((v) => {
+          const snap = JSON.parse(v.snapshot);
+          return `v${v.version} | ${v.created_at} | ${snap.name} | "${snap.title_pattern}"`;
+        });
+        return { content: [{ type: "text", text: `${template.name} \u2014 current: v${template.version}
+${lines.join(`
+`)}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+var init_templates2 = __esm(() => {
+  init_zod();
+  init_tasks();
+});
+
+// src/lib/environment-snapshots.ts
+var exports_environment_snapshots = {};
+__export(exports_environment_snapshots, {
+  writeEnvironmentSnapshot: () => writeEnvironmentSnapshot,
+  recordEnvironmentSnapshot: () => recordEnvironmentSnapshot,
+  readEnvironmentSnapshot: () => readEnvironmentSnapshot,
+  compareEnvironmentSnapshots: () => compareEnvironmentSnapshots,
+  compareEnvironmentSnapshotFiles: () => compareEnvironmentSnapshotFiles,
+  captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
+});
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { hostname, platform, arch } from "os";
+import { dirname as dirname10, join as join14, resolve as resolve12 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+function sha2563(value) {
+  return createHash6("sha256").update(value).digest("hex");
+}
+function fileRecord(root, relativePath) {
+  const path = join14(root, relativePath);
+  if (!existsSync13(path))
+    return null;
+  const stat = statSync6(path);
+  if (!stat.isFile())
+    return null;
+  const content = readFileSync9(path);
+  return { path: relativePath, sha256: sha2563(content), size_bytes: content.length };
+}
+function manifestRecord(root, relativePath) {
+  const base = fileRecord(root, relativePath);
+  if (!base)
+    return null;
+  const parsed = readJsonFile(join14(root, relativePath));
+  if (!parsed)
+    return { ...base, redacted: {} };
+  const redacted = redactValue({
+    name: parsed["name"] ?? null,
+    version: parsed["version"] ?? null,
+    packageManager: parsed["packageManager"] ?? null,
+    scripts: parsed["scripts"] ?? {},
+    dependencies: parsed["dependencies"] ?? {},
+    devDependencies: parsed["devDependencies"] ?? {},
+    peerDependencies: parsed["peerDependencies"] ?? {},
+    optionalDependencies: parsed["optionalDependencies"] ?? {}
+  });
+  return { ...base, redacted };
+}
+function runLocalCommand(root, args) {
+  const result = Bun.spawnSync({
+    cmd: args,
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { PATH: process.env["PATH"] || "" }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: redactEvidenceText(result.stdout.toString("utf8").trim()),
+    stderr: redactEvidenceText(result.stderr.toString("utf8").trim())
+  };
+}
+function summarizeGitStatus(lines) {
+  const summary = { added: 0, modified: 0, deleted: 0, renamed: 0, untracked: 0 };
+  for (const line of lines) {
+    if (line.startsWith("??"))
+      summary.untracked += 1;
+    else if (line.includes("R"))
+      summary.renamed += 1;
+    else if (line.includes("D"))
+      summary.deleted += 1;
+    else if (line.includes("A"))
+      summary.added += 1;
+    else if (line.includes("M"))
+      summary.modified += 1;
+  }
+  return summary;
+}
+function captureGit(root, warnings) {
+  const inside = runLocalCommand(root, ["git", "rev-parse", "--is-inside-work-tree"]);
+  if (inside.exitCode !== 0 || inside.stdout !== "true") {
+    return { present: false, branch: null, commit: null, is_dirty: false, status_porcelain: [], status_summary: summarizeGitStatus([]) };
+  }
+  const branch = runLocalCommand(root, ["git", "branch", "--show-current"]);
+  const commit = runLocalCommand(root, ["git", "rev-parse", "HEAD"]);
+  const status = runLocalCommand(root, ["git", "status", "--porcelain=v1"]);
+  if (commit.exitCode !== 0)
+    warnings.push(`git commit unavailable: ${commit.stderr || commit.stdout || "unknown error"}`);
+  if (status.exitCode !== 0)
+    warnings.push(`git status unavailable: ${status.stderr || status.stdout || "unknown error"}`);
+  const lines = status.stdout ? status.stdout.split(/\r?\n/).filter(Boolean) : [];
+  return {
+    present: true,
+    branch: branch.stdout || null,
+    commit: commit.stdout || null,
+    is_dirty: lines.length > 0,
+    status_porcelain: lines,
+    status_summary: summarizeGitStatus(lines)
+  };
+}
+function packageManager(env, lockfiles) {
+  const userAgent = (env["npm_config_user_agent"] || "").toLowerCase();
+  if (userAgent.includes("bun"))
+    return "bun";
+  if (lockfiles.some((file) => file.path.startsWith("bun.lock")))
+    return "bun";
+  if (userAgent.includes("npm") || lockfiles.some((file) => file.path.includes("package-lock")))
+    return "npm";
+  return "unknown";
+}
+function isSecretEnvKey(key) {
+  return /api[_-]?key|token|secret|password|credential|private|session|cookie/i.test(key);
+}
+function commandEnv(env, includeValues) {
+  const keys = Object.keys(env).sort();
+  const interesting = keys.filter((key) => isSecretEnvKey(key) || ["CI", "NODE_ENV", "BUN_ENV", "SHELL", "TERM", "PATH", "PWD", "USER", "npm_config_user_agent"].includes(key) || key.startsWith("TODOS_") || key.startsWith("BUN_"));
+  const redactedKeys = interesting.filter(isSecretEnvKey);
+  const values = includeValues ? Object.fromEntries(interesting.map((key) => [key, isSecretEnvKey(key) ? "[REDACTED]" : redactEvidenceText(String(env[key] ?? ""))])) : null;
+  return {
+    command: null,
+    env_keys: interesting,
+    env: values,
+    redacted_keys: redactedKeys
+  };
+}
+function defaultSnapshotDir() {
+  const dbPath = getDatabasePath();
+  if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
+    return join14(tmpdir2(), "hasna-todos", "environment-snapshots");
+  return join14(dirname10(resolve12(dbPath)), "environment-snapshots");
+}
+function snapshotWithId(snapshot) {
+  const digest = sha2563(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest}`, ...snapshot };
+}
+function captureEnvironmentSnapshot(input = {}) {
+  const root = resolve12(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));
+  const lockfiles = LOCKFILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const configHashes = CONFIG_FILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const commandMetadata = commandEnv(env, Boolean(input.include_env_values));
+  commandMetadata.command = input.command ? redactEvidenceText(input.command) : null;
+  if (manifests.length === 0)
+    warnings.push("no package manifest found");
+  if (lockfiles.length === 0)
+    warnings.push("no package lockfile found");
+  return snapshotWithId({
+    schema_version: 1,
+    captured_at: input.now ? new Date(input.now).toISOString() : new Date().toISOString(),
+    root,
+    machine: { hostname: hostname(), platform: platform(), arch: arch() },
+    target: {
+      task_id: input.task_id ?? null,
+      run_id: input.run_id ?? null,
+      agent_id: input.agent_id ?? null
+    },
+    runtime: {
+      bun: Bun.version || null,
+      node: process.version,
+      executable: process.execPath
+    },
+    package_manager: {
+      manager: packageManager(env, lockfiles),
+      user_agent: env["npm_config_user_agent"] ? redactEvidenceText(env["npm_config_user_agent"]) : null,
+      manifests,
+      lockfiles
+    },
+    git: captureGit(root, warnings),
+    config_hashes: configHashes,
+    command_env: commandMetadata,
+    warnings
+  });
+}
+function writeEnvironmentSnapshot(snapshot, outputPath) {
+  const path = outputPath ? resolve12(outputPath) : join14(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname10(path));
+  writeJsonFile(path, snapshot);
+  return path;
+}
+function readEnvironmentSnapshot(path) {
+  const snapshot = readJsonFile(resolve12(path));
+  if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
+    throw new Error(`Invalid environment snapshot: ${path}`);
+  }
+  return snapshot;
+}
+function recordEnvironmentSnapshot(input = {}, db) {
+  let taskId = input.task_id;
+  let runId = input.run_id;
+  const needsDatabase = Boolean(taskId || runId);
+  const d = needsDatabase ? db || getDatabase() : null;
+  if (runId) {
+    runId = resolveTaskRunId(runId, d);
+    const run = getTaskRun(runId, d);
+    if (!run)
+      throw new Error(`Run not found: ${input.run_id}`);
+    taskId = taskId || run.task_id;
+  }
+  if (taskId && d) {
+    taskId = resolvePartialId(d, "tasks", taskId) || taskId;
+    if (!getTask(taskId, d))
+      throw new Error(`Task not found: ${taskId}`);
+  }
+  const snapshot = captureEnvironmentSnapshot({ ...input, task_id: taskId, run_id: runId });
+  const outputPath = writeEnvironmentSnapshot(snapshot, input.output_path);
+  let taskVerificationId = null;
+  let runArtifactId = null;
+  if (runId) {
+    const artifact = addTaskRunArtifact({
+      run_id: runId,
+      path: outputPath,
+      artifact_type: "environment_snapshot",
+      description: "Reproducible local environment snapshot",
+      metadata: { environment_snapshot_id: snapshot.id, schema_version: snapshot.schema_version },
+      store_content: input.store_content ?? true,
+      agent_id: input.agent_id
+    }, d);
+    runArtifactId = artifact.id;
+  } else if (taskId) {
+    const verification = addTaskVerification({
+      task_id: taskId,
+      command: input.command || "capture environment snapshot",
+      status: "unknown",
+      output_summary: `environment snapshot ${snapshot.id}`,
+      artifact_path: outputPath,
+      agent_id: input.agent_id,
+      run_at: snapshot.captured_at
+    }, d);
+    taskVerificationId = verification.id;
+  }
+  return { snapshot, output_path: outputPath, task_verification_id: taskVerificationId, run_artifact_id: runArtifactId };
+}
+function keyed(files) {
+  return new Map(files.map((file) => [file.path, file]));
+}
+function diffFiles(left, right) {
+  const leftMap = keyed(left);
+  const rightMap = keyed(right);
+  const paths = [...new Set([...leftMap.keys(), ...rightMap.keys()])].sort((a, b) => a.localeCompare(b));
+  return paths.map((path) => ({ path, left_sha256: leftMap.get(path)?.sha256 ?? null, right_sha256: rightMap.get(path)?.sha256 ?? null })).filter((entry) => entry.left_sha256 !== entry.right_sha256);
+}
+function compareEnvironmentSnapshots(left, right) {
+  const warnings = [];
+  if (left.schema_version !== right.schema_version)
+    warnings.push("snapshot schema versions differ");
+  return {
+    schema_version: 1,
+    left_id: left.id,
+    right_id: right.id,
+    same_root: left.root === right.root,
+    same_machine: left.machine.hostname === right.machine.hostname && left.machine.platform === right.machine.platform && left.machine.arch === right.machine.arch,
+    same_runtime: left.runtime.bun === right.runtime.bun && left.runtime.node === right.runtime.node,
+    same_git_commit: left.git.commit === right.git.commit,
+    dirty_state_changed: left.git.is_dirty !== right.git.is_dirty,
+    changed_config_hashes: diffFiles(left.config_hashes, right.config_hashes),
+    changed_lockfiles: diffFiles(left.package_manager.lockfiles, right.package_manager.lockfiles),
+    changed_manifests: diffFiles(left.package_manager.manifests, right.package_manager.manifests),
+    warnings
+  };
+}
+function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
+  return compareEnvironmentSnapshots(readEnvironmentSnapshot(leftPath), readEnvironmentSnapshot(rightPath));
+}
+var MANIFEST_FILES, LOCKFILES, CONFIG_FILES;
+var init_environment_snapshots = __esm(() => {
+  init_task_runs();
+  init_task_commits();
+  init_database();
+  init_tasks();
+  init_sync_utils();
+  MANIFEST_FILES = ["package.json", "dashboard/package.json", "sdk/package.json"];
+  LOCKFILES = ["bun.lock", "bun.lockb", "package-lock.json", "npm-shrinkwrap.json"];
+  CONFIG_FILES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "README.md",
+    "SECURITY.md",
+    "bunfig.toml",
+    "tsconfig.json",
+    "components.json",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "vite.config.ts",
+    "dashboard/vite.config.ts"
+  ];
+});
+
+// src/mcp/tools/environment-snapshots.ts
+function registerEnvironmentSnapshotTools(server, { shouldRegisterTool, formatError }) {
+  if (shouldRegisterTool("capture_environment_snapshot")) {
+    server.tool("capture_environment_snapshot", "Capture a local reproducible environment snapshot with Bun/node versions, package-manager state, git status, config hashes, command metadata, and redacted manifests. Optionally attach it to a local task or run.", {
+      root: exports_external.string().optional(),
+      task_id: exports_external.string().optional(),
+      run_id: exports_external.string().optional(),
+      agent_id: exports_external.string().optional(),
+      command: exports_external.string().optional(),
+      output_path: exports_external.string().optional(),
+      include_env_values: exports_external.boolean().optional()
+    }, async (params) => {
+      try {
+        const { recordEnvironmentSnapshot: recordEnvironmentSnapshot2 } = await Promise.resolve().then(() => (init_environment_snapshots(), exports_environment_snapshots));
+        const result = recordEnvironmentSnapshot2(params);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("compare_environment_snapshots")) {
+    server.tool("compare_environment_snapshots", "Compare two local environment snapshot JSON files and report runtime, git, manifest, lockfile, and config hash drift.", {
+      left_path: exports_external.string(),
+      right_path: exports_external.string()
+    }, async ({ left_path, right_path }) => {
+      try {
+        const { compareEnvironmentSnapshotFiles: compareEnvironmentSnapshotFiles2 } = await Promise.resolve().then(() => (init_environment_snapshots(), exports_environment_snapshots));
+        return { content: [{ type: "text", text: JSON.stringify(compareEnvironmentSnapshotFiles2(left_path, right_path), null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+var init_environment_snapshots2 = __esm(() => {
+  init_zod();
+});
+
 // src/mcp/index.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -32838,6 +33633,8 @@ var init_mcp = __esm(() => {
   init_code_tools();
   init_machines2();
   init_agents2();
+  init_templates2();
+  init_environment_snapshots2();
   init_package_version();
   init_token_utils();
   if (hasVersionFlag()) {
@@ -32868,6 +33665,8 @@ var init_mcp = __esm(() => {
   registerTaskRelTools(server, toolContext);
   registerCodeTools(server, toolContext);
   registerAgentTools(server, { ...toolContext, agentFocusMap });
+  registerTemplateTools(server, toolContext);
+  registerEnvironmentSnapshotTools(server, toolContext);
   registerMachineTools(server, { shouldRegisterTool, formatError });
   registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
   main().catch(async (err) => {
@@ -32887,45 +33686,45 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname10, join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname11, join as join15 } from "path";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join13(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync13(bunBin))
+  const bunBin = join15(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync14(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return {};
   try {
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname10(path);
-  if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, JSON.stringify(data, null, 2) + `
+  const dir = dirname11(path);
+  if (!existsSync14(dir))
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return "";
-  return readFileSync9(path, "utf-8");
+  return readFileSync10(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname10(path);
-  if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, content);
+  const dir = dirname11(path);
+  if (!existsSync14(dir))
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, content);
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -32989,7 +33788,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join15(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -33003,7 +33802,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join15(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}`));
@@ -33015,7 +33814,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join15(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -33029,7 +33828,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join15(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -33086,9 +33885,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join13(process.cwd(), ".claude", "hooks");
-    if (!existsSync13(hooksDir))
-      mkdirSync7(hooksDir, { recursive: true });
+    const hooksDir = join15(process.cwd(), ".claude", "hooks");
+    if (!existsSync14(hooksDir))
+      mkdirSync8(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.
@@ -33112,11 +33911,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join13(hooksDir, "todos-sync.sh");
-    writeFileSync5(hookPath, hookScript);
+    const hookPath = join15(hooksDir, "todos-sync.sh");
+    writeFileSync6(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join13(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join15(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -33859,18 +34658,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 (existsSync13(hookPath)) {
-        const existing = readFileSync9(hookPath, "utf-8");
+      if (existsSync14(hookPath)) {
+        const existing = readFileSync10(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk8.yellow("Hook already installed."));
           return;
         }
-        writeFileSync5(hookPath, existing + `
+        writeFileSync6(hookPath, existing + `
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
       } else {
-        writeFileSync5(hookPath, `#!/usr/bin/env bash
+        writeFileSync6(hookPath, `#!/usr/bin/env bash
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
@@ -33887,11 +34686,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 (!existsSync13(hookPath)) {
+      if (!existsSync14(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
-      const content = readFileSync9(hookPath, "utf-8");
+      const content = readFileSync10(hookPath, "utf-8");
       if (!content.includes(marker)) {
         console.log(chalk8.dim("Hook not managed by todos."));
         return;
@@ -33902,7 +34701,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       if (cleaned === "#!/usr/bin/env bash" || cleaned === "") {
         (await import("fs")).unlinkSync(hookPath);
       } else {
-        writeFileSync5(hookPath, cleaned + `
+        writeFileSync6(hookPath, cleaned + `
 `);
       }
       console.log(chalk8.green("Post-commit hook removed."));
@@ -34067,9 +34866,9 @@ __export(exports_machines2, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { writeFileSync as writeFileSync6 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { writeFileSync as writeFileSync7 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join16 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -34263,8 +35062,8 @@ Warning: No primary machine set.`));
       if (opts.push) {
         try {
           const localTasks = listTasks3();
-          const tmpFile = join14(tmpdir2(), `todos-export-${uuid()}.json`);
-          writeFileSync6(tmpFile, JSON.stringify(localTasks, null, 2));
+          const tmpFile = join16(tmpdir3(), `todos-export-${uuid()}.json`);
+          writeFileSync7(tmpFile, JSON.stringify(localTasks, null, 2));
           execSync4(`scp ${tmpFile} ${ssh}:/tmp/todos-import.json`, { timeout: 15000 });
           const importCmd = `ssh ${ssh} 'node -e "const fs=require(\\'fs\\');const tasks=JSON.parse(fs.readFileSync(\\'/tmp/todos-import.json\\',\\'utf-8\\'));console.log(JSON.stringify(tasks.length))"'`;
           const count = execSync4(importCmd, { encoding: "utf-8", timeout: 1e4 }).trim();
@@ -34413,6 +35212,84 @@ var init_api_key_commands = __esm(() => {
   init_helpers();
 });
 
+// src/cli/commands/environment-snapshots.ts
+var exports_environment_snapshots2 = {};
+__export(exports_environment_snapshots2, {
+  registerEnvironmentSnapshotCommands: () => registerEnvironmentSnapshotCommands
+});
+import chalk12 from "chalk";
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function registerEnvironmentSnapshotCommands(program2) {
+  const envCmd = program2.command("env-snapshot").alias("environment-snapshot").description("Capture and compare local reproducible environment snapshots");
+  envCmd.command("capture").description("Capture runtime, package-manager, git, config hash, and redacted environment metadata").option("--root <path>", "Project root to inspect").option("--task <id>", "Attach snapshot evidence to a task").option("--run <id>", "Attach snapshot artifact to a task run").option("--agent <name>", "Agent name for attached evidence").option("--command <command>", "Command or verification step this snapshot explains").option("--output <path>", "Write snapshot JSON to a specific path").option("--include-env-values", "Include nonsecret environment values; secret-like keys are still redacted").action((opts) => {
+    const globalOpts = program2.opts();
+    try {
+      const result = recordEnvironmentSnapshot({
+        root: opts.root,
+        task_id: opts.task,
+        run_id: opts.run,
+        agent_id: opts.agent || globalOpts.agent,
+        command: opts.command,
+        output_path: opts.output,
+        include_env_values: Boolean(opts.includeEnvValues)
+      });
+      if (globalOpts.json) {
+        printJson(result);
+        return;
+      }
+      console.log(chalk12.green("Captured") + ` ${result.snapshot.id}`);
+      console.log(`path: ${result.output_path}`);
+      console.log(`root: ${result.snapshot.root}`);
+      console.log(`git: ${result.snapshot.git.commit || "none"}${result.snapshot.git.is_dirty ? " dirty" : ""}`);
+      console.log(`runtime: bun ${result.snapshot.runtime.bun || "unknown"} / node ${result.snapshot.runtime.node}`);
+      if (result.run_artifact_id)
+        console.log(`run artifact: ${result.run_artifact_id}`);
+      if (result.task_verification_id)
+        console.log(`task verification: ${result.task_verification_id}`);
+      for (const warning of result.snapshot.warnings)
+        console.log(chalk12.yellow(`warning: ${warning}`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (globalOpts.json)
+        printJson({ error: message });
+      else
+        console.error(chalk12.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+  envCmd.command("compare").description("Compare two environment snapshot JSON files").argument("<left>", "Left snapshot JSON path").argument("<right>", "Right snapshot JSON path").action((left, right) => {
+    const globalOpts = program2.opts();
+    try {
+      const comparison = compareEnvironmentSnapshotFiles(left, right);
+      if (globalOpts.json) {
+        printJson(comparison);
+        return;
+      }
+      console.log(`left: ${comparison.left_id}`);
+      console.log(`right: ${comparison.right_id}`);
+      console.log(`same root: ${comparison.same_root}`);
+      console.log(`same machine: ${comparison.same_machine}`);
+      console.log(`same runtime: ${comparison.same_runtime}`);
+      console.log(`same git commit: ${comparison.same_git_commit}`);
+      console.log(`dirty state changed: ${comparison.dirty_state_changed}`);
+      const changed = comparison.changed_config_hashes.length + comparison.changed_lockfiles.length + comparison.changed_manifests.length;
+      console.log(`changed files: ${changed}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (globalOpts.json)
+        printJson({ error: message });
+      else
+        console.error(chalk12.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+var init_environment_snapshots3 = __esm(() => {
+  init_environment_snapshots();
+});
+
 // src/cli/index.tsx
 init_esm();
 init_package_version();
@@ -34428,7 +35305,8 @@ var [
   { registerMcpHooksCommands: registerMcpHooksCommands2 },
   { registerDispatchCommands: registerDispatchCommands2 },
   { registerMachineCommands: registerMachineCommands2 },
-  { registerApiKeyCommands: registerApiKeyCommands2 }
+  { registerApiKeyCommands: registerApiKeyCommands2 },
+  { registerEnvironmentSnapshotCommands: registerEnvironmentSnapshotCommands2 }
 ] = await Promise.all([
   Promise.resolve().then(() => (init_task_commands(), exports_task_commands)),
   Promise.resolve().then(() => (init_plan_template_commands(), exports_plan_template_commands)),
@@ -34439,7 +35317,8 @@ var [
   Promise.resolve().then(() => (init_mcp_hooks_commands(), exports_mcp_hooks_commands)),
   Promise.resolve().then(() => (init_dispatch3(), exports_dispatch2)),
   Promise.resolve().then(() => (init_machines3(), exports_machines2)),
-  Promise.resolve().then(() => (init_api_key_commands(), exports_api_key_commands))
+  Promise.resolve().then(() => (init_api_key_commands(), exports_api_key_commands)),
+  Promise.resolve().then(() => (init_environment_snapshots3(), exports_environment_snapshots2))
 ]);
 registerTaskCommands2(program2);
 registerPlanTemplateCommands2(program2);
@@ -34451,4 +35330,5 @@ registerMcpHooksCommands2(program2);
 registerDispatchCommands2(program2);
 registerMachineCommands2(program2);
 registerApiKeyCommands2(program2);
+registerEnvironmentSnapshotCommands2(program2);
 program2.parse();