@hasna/todos 0.11.42 → 0.11.44

package/dist/mcp/index.js

@@ -4436,6 +4436,26 @@ var init_recurrence = __esm(() => {
 });
 
 // src/db/templates.ts
+var exports_templates = {};
+__export(exports_templates, {
+  updateTemplate: () => updateTemplate,
+  tasksFromTemplate: () => tasksFromTemplate,
+  taskFromTemplate: () => taskFromTemplate,
+  resolveVariables: () => resolveVariables,
+  previewTemplate: () => previewTemplate,
+  listTemplates: () => listTemplates,
+  listTemplateVersions: () => listTemplateVersions,
+  importTemplate: () => importTemplate,
+  getTemplateWithTasks: () => getTemplateWithTasks,
+  getTemplateVersion: () => getTemplateVersion,
+  getTemplateTasks: () => getTemplateTasks,
+  getTemplate: () => getTemplate,
+  exportTemplate: () => exportTemplate,
+  evaluateCondition: () => evaluateCondition,
+  deleteTemplate: () => deleteTemplate,
+  createTemplate: () => createTemplate,
+  addTemplateTasks: () => addTemplateTasks
+});
 function rowToTemplate(row) {
   return {
     ...row,
@@ -4446,9 +4466,42 @@ function rowToTemplate(row) {
     version: row.version ?? 1
   };
 }
+function rowToTemplateTask(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    depends_on_positions: JSON.parse(row.depends_on_positions || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    priority: row.priority || "medium",
+    condition: row.condition ?? null,
+    include_template_id: row.include_template_id ?? null
+  };
+}
 function resolveTemplateId(id, d) {
   return resolvePartialId(d, "task_templates", id);
 }
+function createTemplate(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO task_templates (id, name, title_pattern, description, priority, tags, variables, project_id, plan_id, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.title_pattern,
+    input.description || null,
+    input.priority || "medium",
+    JSON.stringify(input.tags || []),
+    JSON.stringify(input.variables || []),
+    input.project_id || null,
+    input.plan_id || null,
+    JSON.stringify(input.metadata || {}),
+    now()
+  ]);
+  if (input.tasks && input.tasks.length > 0) {
+    addTemplateTasks(id, input.tasks, d);
+  }
+  return getTemplate(id, d);
+}
 function getTemplate(id, db) {
   const d = db || getDatabase();
   const resolved = resolveTemplateId(id, d);
@@ -4457,6 +4510,80 @@ function getTemplate(id, db) {
   const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(resolved);
   return row ? rowToTemplate(row) : null;
 }
+function listTemplates(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_templates ORDER BY name").all().map(rowToTemplate);
+}
+function deleteTemplate(id, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return false;
+  return d.run("DELETE FROM task_templates WHERE id = ?", [resolved]).changes > 0;
+}
+function updateTemplate(id, updates, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const current = getTemplateWithTasks(resolved, d);
+  if (current) {
+    const snapshot = JSON.stringify({
+      name: current.name,
+      title_pattern: current.title_pattern,
+      description: current.description,
+      priority: current.priority,
+      tags: current.tags,
+      variables: current.variables,
+      project_id: current.project_id,
+      plan_id: current.plan_id,
+      metadata: current.metadata,
+      tasks: current.tasks
+    });
+    d.run(`INSERT INTO template_versions (id, template_id, version, snapshot, created_at) VALUES (?, ?, ?, ?, ?)`, [uuid(), resolved, current.version, snapshot, now()]);
+  }
+  const sets = ["version = version + 1"];
+  const values = [];
+  if (updates.name !== undefined) {
+    sets.push("name = ?");
+    values.push(updates.name);
+  }
+  if (updates.title_pattern !== undefined) {
+    sets.push("title_pattern = ?");
+    values.push(updates.title_pattern);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    values.push(updates.description);
+  }
+  if (updates.priority !== undefined) {
+    sets.push("priority = ?");
+    values.push(updates.priority);
+  }
+  if (updates.tags !== undefined) {
+    sets.push("tags = ?");
+    values.push(JSON.stringify(updates.tags));
+  }
+  if (updates.variables !== undefined) {
+    sets.push("variables = ?");
+    values.push(JSON.stringify(updates.variables));
+  }
+  if (updates.project_id !== undefined) {
+    sets.push("project_id = ?");
+    values.push(updates.project_id);
+  }
+  if (updates.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    values.push(updates.plan_id);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    values.push(JSON.stringify(updates.metadata));
+  }
+  values.push(resolved);
+  d.run(`UPDATE task_templates SET ${sets.join(", ")} WHERE id = ?`, values);
+  return getTemplate(resolved, d);
+}
 function taskFromTemplate(templateId, overrides = {}, db) {
   const t = getTemplate(templateId, db);
   if (!t)
@@ -4473,6 +4600,291 @@ function taskFromTemplate(templateId, overrides = {}, db) {
     ...cleanOverrides
   };
 }
+function addTemplateTasks(templateId, tasks, db) {
+  const d = db || getDatabase();
+  const template = getTemplate(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  d.run("DELETE FROM template_tasks WHERE template_id = ?", [templateId]);
+  const results = [];
+  for (let i = 0;i < tasks.length; i++) {
+    const task = tasks[i];
+    const id = uuid();
+    d.run(`INSERT INTO template_tasks (id, template_id, position, title_pattern, description, priority, tags, task_type, condition, include_template_id, depends_on_positions, metadata, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      templateId,
+      i,
+      task.title_pattern,
+      task.description || null,
+      task.priority || "medium",
+      JSON.stringify(task.tags || []),
+      task.task_type || null,
+      task.condition || null,
+      task.include_template_id || null,
+      JSON.stringify(task.depends_on || []),
+      JSON.stringify(task.metadata || {}),
+      now()
+    ]);
+    const row = d.query("SELECT * FROM template_tasks WHERE id = ?").get(id);
+    if (row)
+      results.push(rowToTemplateTask(row));
+  }
+  return results;
+}
+function getTemplateWithTasks(id, db) {
+  const d = db || getDatabase();
+  const template = getTemplate(id, d);
+  if (!template)
+    return null;
+  const rows = d.query("SELECT * FROM template_tasks WHERE template_id = ? ORDER BY position").all(template.id);
+  const tasks = rows.map(rowToTemplateTask);
+  return { ...template, tasks };
+}
+function getTemplateTasks(templateId, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(templateId, d);
+  if (!resolved)
+    return [];
+  const rows = d.query("SELECT * FROM template_tasks WHERE template_id = ? ORDER BY position").all(resolved);
+  return rows.map(rowToTemplateTask);
+}
+function evaluateCondition(condition, variables) {
+  if (!condition || condition.trim() === "")
+    return true;
+  const trimmed = condition.trim();
+  const eqMatch = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
+  if (eqMatch) {
+    const varName = eqMatch[1];
+    const expected = eqMatch[2].trim();
+    return (variables[varName] ?? "") === expected;
+  }
+  const neqMatch = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
+  if (neqMatch) {
+    const varName = neqMatch[1];
+    const expected = neqMatch[2].trim();
+    return (variables[varName] ?? "") !== expected;
+  }
+  const falsyMatch = trimmed.match(/^!\{([^}]+)\}$/);
+  if (falsyMatch) {
+    const varName = falsyMatch[1];
+    const val = variables[varName];
+    return !val || val === "" || val === "false";
+  }
+  const truthyMatch = trimmed.match(/^\{([^}]+)\}$/);
+  if (truthyMatch) {
+    const varName = truthyMatch[1];
+    const val = variables[varName];
+    return !!val && val !== "" && val !== "false";
+  }
+  return true;
+}
+function exportTemplate(id, db) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(id, d);
+  if (!template)
+    throw new Error(`Template not found: ${id}`);
+  return {
+    name: template.name,
+    title_pattern: template.title_pattern,
+    description: template.description,
+    priority: template.priority,
+    tags: template.tags,
+    variables: template.variables,
+    project_id: template.project_id,
+    plan_id: template.plan_id,
+    metadata: template.metadata,
+    tasks: template.tasks.map((t) => ({
+      position: t.position,
+      title_pattern: t.title_pattern,
+      description: t.description,
+      priority: t.priority,
+      tags: t.tags,
+      task_type: t.task_type,
+      condition: t.condition,
+      include_template_id: t.include_template_id,
+      depends_on_positions: t.depends_on_positions,
+      metadata: t.metadata
+    }))
+  };
+}
+function importTemplate(json, db) {
+  const d = db || getDatabase();
+  const taskInputs = (json.tasks || []).map((t) => ({
+    title_pattern: t.title_pattern,
+    description: t.description ?? undefined,
+    priority: t.priority,
+    tags: t.tags,
+    task_type: t.task_type ?? undefined,
+    condition: t.condition ?? undefined,
+    include_template_id: t.include_template_id ?? undefined,
+    depends_on: t.depends_on_positions,
+    metadata: t.metadata
+  }));
+  return createTemplate({
+    name: json.name,
+    title_pattern: json.title_pattern,
+    description: json.description ?? undefined,
+    priority: json.priority,
+    tags: json.tags,
+    variables: json.variables,
+    project_id: json.project_id ?? undefined,
+    plan_id: json.plan_id ?? undefined,
+    metadata: json.metadata,
+    tasks: taskInputs
+  }, d);
+}
+function getTemplateVersion(id, version, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const row = d.query("SELECT * FROM template_versions WHERE template_id = ? AND version = ?").get(resolved, version);
+  return row || null;
+}
+function listTemplateVersions(id, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return [];
+  return d.query("SELECT * FROM template_versions WHERE template_id = ? ORDER BY version DESC").all(resolved);
+}
+function resolveVariables(templateVars, provided) {
+  const merged = { ...provided };
+  for (const v of templateVars) {
+    if (merged[v.name] === undefined && v.default !== undefined) {
+      merged[v.name] = v.default;
+    }
+  }
+  const missing = [];
+  for (const v of templateVars) {
+    if (v.required && merged[v.name] === undefined) {
+      missing.push(v.name);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
+  }
+  return merged;
+}
+function substituteVars(text, variables) {
+  let result = text;
+  for (const [key, val] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
+  }
+  return result;
+}
+function tasksFromTemplate(templateId, projectId, variables, taskListId, db, _visitedTemplateIds) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  const visited = _visitedTemplateIds || new Set;
+  if (visited.has(template.id)) {
+    throw new Error(`Circular template reference detected: ${template.id}`);
+  }
+  visited.add(template.id);
+  const resolved = resolveVariables(template.variables, variables);
+  if (template.tasks.length === 0) {
+    const input = taskFromTemplate(templateId, { project_id: projectId, task_list_id: taskListId }, d);
+    const task = createTask(input, d);
+    return [task];
+  }
+  const createdTasks = [];
+  const positionToId = new Map;
+  const skippedPositions = new Set;
+  for (const tt of template.tasks) {
+    if (tt.include_template_id) {
+      const includedTasks = tasksFromTemplate(tt.include_template_id, projectId, resolved, taskListId, d, visited);
+      createdTasks.push(...includedTasks);
+      if (includedTasks.length > 0) {
+        positionToId.set(tt.position, includedTasks[0].id);
+      } else {
+        skippedPositions.add(tt.position);
+      }
+      continue;
+    }
+    if (tt.condition && !evaluateCondition(tt.condition, resolved)) {
+      skippedPositions.add(tt.position);
+      continue;
+    }
+    let title = tt.title_pattern;
+    let desc = tt.description;
+    title = substituteVars(title, resolved);
+    if (desc)
+      desc = substituteVars(desc, resolved);
+    const task = createTask({
+      title,
+      description: desc ?? undefined,
+      priority: tt.priority,
+      tags: tt.tags,
+      task_type: tt.task_type ?? undefined,
+      project_id: projectId,
+      task_list_id: taskListId,
+      metadata: tt.metadata
+    }, d);
+    createdTasks.push(task);
+    positionToId.set(tt.position, task.id);
+  }
+  for (const tt of template.tasks) {
+    if (skippedPositions.has(tt.position))
+      continue;
+    if (tt.include_template_id)
+      continue;
+    const deps = tt.depends_on_positions;
+    for (const depPos of deps) {
+      if (skippedPositions.has(depPos))
+        continue;
+      const taskId = positionToId.get(tt.position);
+      const depId = positionToId.get(depPos);
+      if (taskId && depId) {
+        addDependency(taskId, depId, d);
+      }
+    }
+  }
+  return createdTasks;
+}
+function previewTemplate(templateId, variables, db) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  const resolved = resolveVariables(template.variables, variables);
+  const tasks = [];
+  if (template.tasks.length === 0) {
+    tasks.push({
+      position: 0,
+      title: substituteVars(template.title_pattern, resolved),
+      description: template.description ? substituteVars(template.description, resolved) : null,
+      priority: template.priority,
+      tags: template.tags,
+      task_type: null,
+      depends_on_positions: []
+    });
+  } else {
+    for (const tt of template.tasks) {
+      if (tt.condition && !evaluateCondition(tt.condition, resolved))
+        continue;
+      tasks.push({
+        position: tt.position,
+        title: substituteVars(tt.title_pattern, resolved),
+        description: tt.description ? substituteVars(tt.description, resolved) : null,
+        priority: tt.priority,
+        tags: tt.tags,
+        task_type: tt.task_type,
+        depends_on_positions: tt.depends_on_positions
+      });
+    }
+  }
+  return {
+    template_id: template.id,
+    template_name: template.name,
+    description: template.description,
+    variables: template.variables,
+    resolved_variables: resolved,
+    tasks
+  };
+}
 var init_templates = __esm(() => {
   init_database();
   init_tasks();
@@ -9329,6 +9741,568 @@ var init_extract = __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 mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } 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) {
+  mkdirSync6(directory, { recursive: true });
+  const files = [];
+  for (const entry of exportBuiltinTemplateFiles()) {
+    const path = join6(directory, entry.filename);
+    writeFileSync3(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);
+  const existingNames = new Set(existing.map((t) => t.name));
+  let created = 0;
+  let skipped = 0;
+  const names = [];
+  for (const bt of BUILTIN_TEMPLATES) {
+    if (existingNames.has(bt.name)) {
+      skipped++;
+      continue;
+    }
+    const tasks = bt.tasks.map((t) => ({
+      title_pattern: t.title_pattern,
+      description: t.description,
+      priority: t.priority,
+      tags: t.tags,
+      task_type: t.task_type,
+      depends_on: t.depends_on_positions || t.depends_on,
+      metadata: t.metadata
+    }));
+    createTemplate({
+      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++;
+    names.push(bt.name);
+  }
+  return { created, skipped, names };
+}
+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" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Scaffold {name} package structure", priority: "critical" },
+        { position: 1, title_pattern: "Create {name} SQLite database + migrations", priority: "critical", depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement {name} CRUD operations", priority: "high", depends_on_positions: [1] },
+        { position: 3, title_pattern: "Build {name} MCP server with standard tools", priority: "high", depends_on_positions: [2] },
+        { position: 4, title_pattern: "Build {name} CLI with Commander.js", priority: "high", depends_on_positions: [2] },
+        { position: 5, title_pattern: "Build {name} REST API", priority: "medium", depends_on_positions: [2] },
+        { position: 6, title_pattern: "Write unit tests for {name}", priority: "high", depends_on_positions: [2, 3, 4] },
+        { position: 7, title_pattern: "Add Apache 2.0 license and README", priority: "medium", depends_on_positions: [0] },
+        { position: 8, title_pattern: "Create GitHub repo {org}/{name}", priority: "medium", depends_on_positions: [7] },
+        { position: 9, title_pattern: "Add local backup and restore workflow for {name}", priority: "medium", depends_on_positions: [1] },
+        { position: 10, title_pattern: "Add agent tools (register_agent, heartbeat, set_focus, list_agents)", priority: "medium", depends_on_positions: [3] },
+        { 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] }
+      ]
+    }
+  ];
+});
+
+// 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 createHash5 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync6 } from "fs";
+import { hostname, platform, arch } from "os";
+import { dirname as dirname7, join as join7, resolve as resolve9 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+function sha2563(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function fileRecord(root, relativePath) {
+  const path = join7(root, relativePath);
+  if (!existsSync8(path))
+    return null;
+  const stat = statSync6(path);
+  if (!stat.isFile())
+    return null;
+  const content = readFileSync6(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(join7(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 join7(tmpdir2(), "hasna-todos", "environment-snapshots");
+  return join7(dirname7(resolve9(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 = resolve9(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 ? resolve9(outputPath) : join7(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname7(path));
+  writeJsonFile(path, snapshot);
+  return path;
+}
+function readEnvironmentSnapshot(path) {
+  const snapshot = readJsonFile(resolve9(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/index.ts
 init_agents();
 init_database();
@@ -13700,6 +14674,8 @@ var MCP_TOOL_GROUPS = {
     "check_file_lock",
     "create_comment",
     "create_handoff",
+    "capture_environment_snapshot",
+    "compare_environment_snapshots",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",
@@ -13822,10 +14798,12 @@ var MCP_TOOL_GROUPS = {
     "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: [
@@ -20916,19 +21894,305 @@ ID: ${updated.id}${taskNote}`
   }
 }
 
+// src/mcp/tools/templates.ts
+init_tasks();
+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 json = exportTemplate2(resolvedId);
+        return { content: [{ type: "text", text: JSON.stringify(json, 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 }) => {
+      try {
+        const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const parsed = JSON.parse(json);
+        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 };
+      }
+    });
+  }
+}
+
+// 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 };
+      }
+    });
+  }
+}
+
 // src/lib/package-version.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname7, join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname8, join as join8 } from "path";
 import { fileURLToPath } from "url";
 function getPackageVersion(fromUrl = import.meta.url) {
   try {
-    let dir = dirname7(fileURLToPath(fromUrl));
+    let dir = dirname8(fileURLToPath(fromUrl));
     for (let i = 0;i < 5; i++) {
-      const pkgPath = join6(dir, "package.json");
-      if (existsSync8(pkgPath)) {
-        return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
+      const pkgPath = join8(dir, "package.json");
+      if (existsSync9(pkgPath)) {
+        return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
       }
-      const parent = dirname7(dir);
+      const parent = dirname8(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -21108,6 +22372,8 @@ registerTaskResources(server, toolContext);
 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 });
 async function main() {