@hasna/todos 0.11.42 → 0.11.43

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,279 @@ 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/mcp/index.ts
 init_agents();
 init_database();
@@ -13822,10 +14507,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,15 +21603,265 @@ 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/lib/package-version.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname7, join as join6 } from "path";
+import { dirname as dirname7, join as join7 } from "path";
 import { fileURLToPath } from "url";
 function getPackageVersion(fromUrl = import.meta.url) {
   try {
     let dir = dirname7(fileURLToPath(fromUrl));
     for (let i = 0;i < 5; i++) {
-      const pkgPath = join6(dir, "package.json");
+      const pkgPath = join7(dir, "package.json");
       if (existsSync8(pkgPath)) {
         return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
       }
@@ -21108,6 +22045,7 @@ registerTaskResources(server, toolContext);
 registerTaskRelTools(server, toolContext);
 registerCodeTools(server, toolContext);
 registerAgentTools(server, { ...toolContext, agentFocusMap });
+registerTemplateTools(server, toolContext);
 registerMachineTools(server, { shouldRegisterTool, formatError });
 registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
 async function main() {