@hasna/todos 0.11.42 → 0.11.43

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`;
@@ -26525,10 +26735,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 +32882,259 @@ 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/mcp/index.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -32838,6 +33303,7 @@ var init_mcp = __esm(() => {
   init_code_tools();
   init_machines2();
   init_agents2();
+  init_templates2();
   init_package_version();
   init_token_utils();
   if (hasVersionFlag()) {
@@ -32868,6 +33334,7 @@ var init_mcp = __esm(() => {
   registerTaskRelTools(server, toolContext);
   registerCodeTools(server, toolContext);
   registerAgentTools(server, { ...toolContext, agentFocusMap });
+  registerTemplateTools(server, toolContext);
   registerMachineTools(server, { shouldRegisterTool, formatError });
   registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
   main().catch(async (err) => {
@@ -32887,15 +33354,15 @@ __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 existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname10, join as join14 } 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");
+  const bunBin = join14(HOME2, ".bun", "bin", "todos-mcp");
   if (existsSync13(bunBin))
     return bunBin;
   return "todos-mcp";
@@ -32912,8 +33379,8 @@ function readJsonFile2(path) {
 function writeJsonFile2(path, data) {
   const dir = dirname10(path);
   if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, JSON.stringify(data, null, 2) + `
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
@@ -32924,8 +33391,8 @@ function readTomlFile(path) {
 function writeTomlFile(path, content) {
   const dir = dirname10(path);
   if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, content);
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, content);
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -32989,7 +33456,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join14(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -33003,7 +33470,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join14(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 +33482,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join14(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -33029,7 +33496,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join14(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -33086,9 +33553,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join13(process.cwd(), ".claude", "hooks");
+    const hooksDir = join14(process.cwd(), ".claude", "hooks");
     if (!existsSync13(hooksDir))
-      mkdirSync7(hooksDir, { recursive: true });
+      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 +33579,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join13(hooksDir, "todos-sync.sh");
-    writeFileSync5(hookPath, hookScript);
+    const hookPath = join14(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 = join14(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -33865,12 +34332,12 @@ Artifacts:`));
           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
 `);
@@ -33902,7 +34369,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 +34534,9 @@ __export(exports_machines2, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -34263,8 +34730,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 = join15(tmpdir2(), `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();