@hasna/todos 0.11.10 → 0.11.13

package/dist/index.js

@@ -846,6 +846,26 @@ var MIGRATIONS = [
   CREATE INDEX IF NOT EXISTS idx_template_tasks_template ON template_tasks(template_id);
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (37);
+  `,
+  `
+  ALTER TABLE task_templates ADD COLUMN variables TEXT DEFAULT '[]';
+  INSERT OR IGNORE INTO _migrations (id) VALUES (38);
+  `,
+  `
+  ALTER TABLE template_tasks ADD COLUMN condition TEXT;
+  ALTER TABLE template_tasks ADD COLUMN include_template_id TEXT;
+  ALTER TABLE task_templates ADD COLUMN version INTEGER NOT NULL DEFAULT 1;
+
+  CREATE TABLE IF NOT EXISTS template_versions (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+    version INTEGER NOT NULL,
+    snapshot TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_template_versions_template ON template_versions(template_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (39);
   `
 ];
 var _db = null;
@@ -1060,6 +1080,36 @@ function ensureSchema(db) {
   ensureColumn("projects", "org_id", "TEXT");
   ensureColumn("plans", "task_list_id", "TEXT");
   ensureColumn("plans", "agent_id", "TEXT");
+  ensureColumn("task_templates", "variables", "TEXT DEFAULT '[]'");
+  ensureColumn("task_templates", "version", "INTEGER NOT NULL DEFAULT 1");
+  ensureColumn("template_tasks", "condition", "TEXT");
+  ensureColumn("template_tasks", "include_template_id", "TEXT");
+  ensureTable("template_versions", `
+    CREATE TABLE template_versions (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+      version INTEGER NOT NULL,
+      snapshot TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_template_versions_template ON template_versions(template_id)");
+  ensureColumn("webhooks", "project_id", "TEXT");
+  ensureColumn("webhooks", "task_list_id", "TEXT");
+  ensureColumn("webhooks", "agent_id", "TEXT");
+  ensureColumn("webhooks", "task_id", "TEXT");
+  ensureTable("webhook_deliveries", `
+    CREATE TABLE webhook_deliveries (
+      id TEXT PRIMARY KEY,
+      webhook_id TEXT NOT NULL REFERENCES webhooks(id) ON DELETE CASCADE,
+      event TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status_code INTEGER,
+      response TEXT,
+      attempt INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_webhook_deliveries_webhook ON webhook_deliveries(webhook_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_webhook_deliveries_event ON webhook_deliveries(event)");
   ensureColumn("task_comments", "type", "TEXT DEFAULT 'comment'");
   ensureColumn("task_comments", "progress_pct", "INTEGER");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id)");
@@ -1750,13 +1800,33 @@ function nextOccurrence(rule, from) {
 }
 
 // src/db/webhooks.ts
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_BASE_DELAY_MS = 1000;
 function rowToWebhook(row) {
-  return { ...row, events: JSON.parse(row.events || "[]"), active: !!row.active };
+  return {
+    ...row,
+    events: JSON.parse(row.events || "[]"),
+    active: !!row.active,
+    project_id: row.project_id || null,
+    task_list_id: row.task_list_id || null,
+    agent_id: row.agent_id || null,
+    task_id: row.task_id || null
+  };
 }
 function createWebhook(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  d.run(`INSERT INTO webhooks (id, url, events, secret, created_at) VALUES (?, ?, ?, ?, ?)`, [id, input.url, JSON.stringify(input.events || []), input.secret || null, now()]);
+  d.run(`INSERT INTO webhooks (id, url, events, secret, project_id, task_list_id, agent_id, task_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.url,
+    JSON.stringify(input.events || []),
+    input.secret || null,
+    input.project_id || null,
+    input.task_list_id || null,
+    input.agent_id || null,
+    input.task_id || null,
+    now()
+  ]);
   return getWebhook(id, d);
 }
 function getWebhook(id, db) {
@@ -1772,20 +1842,66 @@ function deleteWebhook(id, db) {
   const d = db || getDatabase();
   return d.run("DELETE FROM webhooks WHERE id = ?", [id]).changes > 0;
 }
+function listDeliveries(webhookId, limit = 50, db) {
+  const d = db || getDatabase();
+  if (webhookId) {
+    return d.query("SELECT * FROM webhook_deliveries WHERE webhook_id = ? ORDER BY created_at DESC LIMIT ?").all(webhookId, limit);
+  }
+  return d.query("SELECT * FROM webhook_deliveries ORDER BY created_at DESC LIMIT ?").all(limit);
+}
+function logDelivery(d, webhookId, event, payload, statusCode, response, attempt) {
+  const id = uuid();
+  d.run(`INSERT INTO webhook_deliveries (id, webhook_id, event, payload, status_code, response, attempt, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, webhookId, event, payload, statusCode, response, attempt, now()]);
+}
+function matchesScope(wh, payload) {
+  if (wh.project_id && payload.project_id !== wh.project_id)
+    return false;
+  if (wh.task_list_id && payload.task_list_id !== wh.task_list_id)
+    return false;
+  if (wh.agent_id && payload.agent_id !== wh.agent_id && payload.assigned_to !== wh.agent_id)
+    return false;
+  if (wh.task_id && payload.id !== wh.task_id)
+    return false;
+  return true;
+}
+async function deliverWebhook(wh, event, body, attempt, db) {
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (wh.secret) {
+      const encoder = new TextEncoder;
+      const key = await crypto.subtle.importKey("raw", encoder.encode(wh.secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+      const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+      headers["X-Webhook-Signature"] = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    const resp = await fetch(wh.url, { method: "POST", headers, body });
+    const respText = await resp.text().catch(() => "");
+    logDelivery(db, wh.id, event, body, resp.status, respText.slice(0, 1000), attempt);
+    if (resp.status >= 400 && attempt < MAX_RETRY_ATTEMPTS) {
+      const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+      setTimeout(() => {
+        deliverWebhook(wh, event, body, attempt + 1, db).catch(() => {});
+      }, delay);
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logDelivery(db, wh.id, event, body, null, errorMsg.slice(0, 1000), attempt);
+    if (attempt < MAX_RETRY_ATTEMPTS) {
+      const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+      setTimeout(() => {
+        deliverWebhook(wh, event, body, attempt + 1, db).catch(() => {});
+      }, delay);
+    }
+  }
+}
 async function dispatchWebhook(event, payload, db) {
-  const webhooks = listWebhooks(db).filter((w) => w.active && (w.events.length === 0 || w.events.includes(event)));
+  const d = db || getDatabase();
+  const webhooks = listWebhooks(d).filter((w) => w.active && (w.events.length === 0 || w.events.includes(event)));
+  const payloadObj = typeof payload === "object" && payload !== null ? payload : {};
   for (const wh of webhooks) {
-    try {
-      const body = JSON.stringify({ event, payload, timestamp: now() });
-      const headers = { "Content-Type": "application/json" };
-      if (wh.secret) {
-        const encoder = new TextEncoder;
-        const key = await crypto.subtle.importKey("raw", encoder.encode(wh.secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-        const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
-        headers["X-Webhook-Signature"] = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
-      }
-      fetch(wh.url, { method: "POST", headers, body }).catch(() => {});
-    } catch {}
+    if (!matchesScope(wh, payloadObj))
+      continue;
+    const body = JSON.stringify({ event, payload, timestamp: now() });
+    deliverWebhook(wh, event, body, 1, d).catch(() => {});
   }
 }
 
@@ -1794,8 +1910,10 @@ function rowToTemplate(row) {
   return {
     ...row,
     tags: JSON.parse(row.tags || "[]"),
+    variables: JSON.parse(row.variables || "[]"),
     metadata: JSON.parse(row.metadata || "{}"),
-    priority: row.priority || "medium"
+    priority: row.priority || "medium",
+    version: row.version ?? 1
   };
 }
 function rowToTemplateTask(row) {
@@ -1804,7 +1922,9 @@ function rowToTemplateTask(row) {
     tags: JSON.parse(row.tags || "[]"),
     depends_on_positions: JSON.parse(row.depends_on_positions || "[]"),
     metadata: JSON.parse(row.metadata || "{}"),
-    priority: row.priority || "medium"
+    priority: row.priority || "medium",
+    condition: row.condition ?? null,
+    include_template_id: row.include_template_id ?? null
   };
 }
 function resolveTemplateId(id, d) {
@@ -1813,14 +1933,15 @@ function resolveTemplateId(id, d) {
 function createTemplate(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  d.run(`INSERT INTO task_templates (id, name, title_pattern, description, priority, tags, project_id, plan_id, metadata, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  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 || {}),
@@ -1855,7 +1976,23 @@ function updateTemplate(id, updates, db) {
   const resolved = resolveTemplateId(id, d);
   if (!resolved)
     return null;
-  const sets = [];
+  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 = ?");
@@ -1877,6 +2014,10 @@ function updateTemplate(id, updates, db) {
     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);
@@ -1889,8 +2030,6 @@ function updateTemplate(id, updates, db) {
     sets.push("metadata = ?");
     values.push(JSON.stringify(updates.metadata));
   }
-  if (sets.length === 0)
-    return getTemplate(resolved, d);
   values.push(resolved);
   d.run(`UPDATE task_templates SET ${sets.join(", ")} WHERE id = ?`, values);
   return getTemplate(resolved, d);
@@ -1920,8 +2059,8 @@ function addTemplateTasks(templateId, tasks, db) {
   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, depends_on_positions, metadata, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    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,
@@ -1930,6 +2069,8 @@ function addTemplateTasks(templateId, tasks, db) {
       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()
@@ -1957,11 +2098,142 @@ function getTemplateTasks(templateId, db) {
   const rows = d.query("SELECT * FROM template_tasks WHERE template_id = ? ORDER BY position").all(resolved);
   return rows.map(rowToTemplateTask);
 }
-function tasksFromTemplate(templateId, projectId, variables, taskListId, db) {
+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);
@@ -1969,16 +2241,27 @@ function tasksFromTemplate(templateId, projectId, variables, taskListId, db) {
   }
   const createdTasks = [];
   const positionToId = new Map;
+  const skippedPositions = new Set;
   for (const tt of template.tasks) {
-    let title = tt.title_pattern;
-    let desc = tt.description;
-    if (variables) {
-      for (const [key, val] of Object.entries(variables)) {
-        title = title.replace(new RegExp(`\\{${key}\\}`, "g"), val);
-        if (desc)
-          desc = desc.replace(new RegExp(`\\{${key}\\}`, "g"), val);
+    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,
@@ -1993,8 +2276,14 @@ function tasksFromTemplate(templateId, projectId, variables, taskListId, db) {
     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) {
@@ -2004,6 +2293,47 @@ function tasksFromTemplate(templateId, projectId, variables, taskListId, db) {
   }
   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
+  };
+}
 
 // src/db/checklists.ts
 function rowToItem(row) {
@@ -3798,6 +4128,107 @@ function clearActiveModel() {
   delete config.activeModel;
   writeConfig(config);
 }
+// src/db/builtin-templates.ts
+var BUILTIN_TEMPLATES = [
+  {
+    name: "open-source-project",
+    description: "Full open-source project bootstrap \u2014 scaffold to publish",
+    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 @hasna/cloud adapter", priority: "medium", depends_on_positions: [1] },
+      { position: 10, title_pattern: "Write PostgreSQL migrations for {name}", priority: "medium", depends_on_positions: [1] },
+      { position: 11, title_pattern: "Add feedback system + send_feedback MCP tool", priority: "medium", depends_on_positions: [3] },
+      { position: 12, title_pattern: "Add agent tools (register_agent, heartbeat, set_focus, list_agents)", priority: "medium", depends_on_positions: [3] },
+      { position: 13, title_pattern: "Create RDS database for {name}", priority: "low", depends_on_positions: [10] },
+      { position: 14, title_pattern: "Publish @hasna/{name} to npm", priority: "high", depends_on_positions: [6, 7, 8] },
+      { position: 15, title_pattern: "Install @hasna/{name} globally and verify", priority: "medium", depends_on_positions: [14] }
+    ]
+  },
+  {
+    name: "bug-fix",
+    description: "Standard bug fix workflow",
+    variables: [{ name: "bug", required: true, description: "Bug description" }],
+    tasks: [
+      { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical" },
+      { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", depends_on_positions: [0] },
+      { position: 2, title_pattern: "Implement fix for {bug}", priority: "critical", depends_on_positions: [1] },
+      { position: 3, title_pattern: "Write regression test for {bug}", priority: "high", depends_on_positions: [2] },
+      { position: 4, title_pattern: "Publish fix and verify in production", priority: "high", depends_on_positions: [3] }
+    ]
+  },
+  {
+    name: "feature",
+    description: "Standard feature development workflow",
+    variables: [{ name: "feature", required: true }, { name: "scope", required: false, default: "medium" }],
+    tasks: [
+      { position: 0, title_pattern: "Write spec for {feature}", priority: "high" },
+      { position: 1, title_pattern: "Design implementation approach for {feature}", priority: "high", depends_on_positions: [0] },
+      { position: 2, title_pattern: "Implement {feature}", priority: "critical", depends_on_positions: [1] },
+      { position: 3, title_pattern: "Write tests for {feature}", priority: "high", depends_on_positions: [2] },
+      { position: 4, title_pattern: "Code review for {feature}", priority: "medium", depends_on_positions: [3] },
+      { position: 5, title_pattern: "Update docs for {feature}", priority: "medium", depends_on_positions: [2] },
+      { position: 6, title_pattern: "Deploy {feature}", priority: "high", depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "security-audit",
+    description: "Security audit workflow",
+    variables: [{ name: "target", required: true }],
+    tasks: [
+      { position: 0, title_pattern: "Scan {target} for vulnerabilities", priority: "critical" },
+      { position: 1, title_pattern: "Review {target} security findings", priority: "critical", depends_on_positions: [0] },
+      { position: 2, title_pattern: "Fix critical issues in {target}", priority: "critical", depends_on_positions: [1] },
+      { position: 3, title_pattern: "Retest {target} after fixes", priority: "high", depends_on_positions: [2] },
+      { position: 4, title_pattern: "Write security report for {target}", priority: "medium", depends_on_positions: [3] },
+      { position: 5, title_pattern: "Close audit for {target}", priority: "low", depends_on_positions: [4] }
+    ]
+  }
+];
+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,
+      variables: bt.variables,
+      tasks
+    }, d);
+    created++;
+    names.push(bt.name);
+  }
+  return { created, skipped, names };
+}
 // src/db/handoffs.ts
 function createHandoff(input, db) {
   const d = db || getDatabase();
@@ -14751,6 +15182,26 @@ var PG_MIGRATIONS = [
   CREATE INDEX IF NOT EXISTS idx_template_tasks_template ON template_tasks(template_id);
 
   INSERT INTO _migrations (id) VALUES (37) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE task_templates ADD COLUMN IF NOT EXISTS variables TEXT DEFAULT '[]';
+  INSERT INTO _migrations (id) VALUES (38) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE template_tasks ADD COLUMN IF NOT EXISTS condition TEXT;
+  ALTER TABLE template_tasks ADD COLUMN IF NOT EXISTS include_template_id TEXT;
+  ALTER TABLE task_templates ADD COLUMN IF NOT EXISTS version INTEGER NOT NULL DEFAULT 1;
+
+  CREATE TABLE IF NOT EXISTS template_versions (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+    version INTEGER NOT NULL,
+    snapshot TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  CREATE INDEX IF NOT EXISTS idx_template_versions_template ON template_versions(template_id);
+
+  INSERT INTO _migrations (id) VALUES (39) ON CONFLICT DO NOTHING;
   `
 ];
 
@@ -15325,6 +15776,7 @@ export {
   searchTasks,
   scoreTask,
   saveSnapshot,
+  resolveVariables,
   resolvePartialId,
   resetDatabase,
   removeTaskRelationshipByPair,
@@ -15338,6 +15790,7 @@ export {
   releaseAgent,
   registerAgent,
   redistributeStaleTasks,
+  previewTemplate,
   patrolTasks,
   parseRecurrenceRule,
   parseGitHubUrl,
@@ -15354,6 +15807,7 @@ export {
   loadConfig,
   listWebhooks,
   listTemplates,
+  listTemplateVersions,
   listTasks,
   listTaskLists,
   listTaskFiles,
@@ -15364,14 +15818,18 @@ export {
   listPlans,
   listOrgs,
   listHandoffs,
+  listDeliveries,
   listComments,
   listAgents,
   issueToTask,
   isValidRecurrenceRule,
   isAgentConflict,
+  initBuiltinTemplates,
+  importTemplate,
   getWebhook,
   getTraceStats,
   getTemplateWithTasks,
+  getTemplateVersion,
   getTemplateTasks,
   getTemplate,
   getTasksChangedSince,
@@ -15432,6 +15890,8 @@ export {
   failTask,
   extractTodos,
   extractFromSource,
+  exportTemplate,
+  evaluateCondition,
   ensureTaskList,
   ensureProject,
   dispatchWebhook,
@@ -15501,5 +15961,6 @@ export {
   DependencyCycleError,
   DEFAULT_MODEL,
   CompletionGuardError,
+  BUILTIN_TEMPLATES,
   AgentNotFoundError
 };