@hasna/todos 0.11.10 → 0.11.13

package/dist/mcp/index.js

@@ -10954,6 +10954,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)");
@@ -11642,6 +11672,26 @@ var init_database = __esm(() => {
   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);
   `
   ];
 });
@@ -12080,18 +12130,37 @@ var init_recurrence = __esm(() => {
 var exports_webhooks = {};
 __export(exports_webhooks, {
   listWebhooks: () => listWebhooks,
+  listDeliveries: () => listDeliveries,
   getWebhook: () => getWebhook,
   dispatchWebhook: () => dispatchWebhook,
   deleteWebhook: () => deleteWebhook,
   createWebhook: () => createWebhook
 });
 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) {
@@ -12107,22 +12176,69 @@ 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(() => {});
   }
 }
+var MAX_RETRY_ATTEMPTS = 3, RETRY_BASE_DELAY_MS = 1000;
 var init_webhooks = __esm(() => {
   init_database();
 });
@@ -12133,10 +12249,17 @@ __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
@@ -12145,8 +12268,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) {
@@ -12155,7 +12280,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) {
@@ -12164,14 +12291,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 || {}),
@@ -12206,7 +12334,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 = ?");
@@ -12228,6 +12372,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);
@@ -12240,8 +12388,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);
@@ -12271,8 +12417,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,
@@ -12281,6 +12427,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()
@@ -12308,11 +12456,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);
@@ -12320,16 +12599,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,
@@ -12344,8 +12634,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) {
@@ -12355,6 +12651,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
+  };
+}
 var init_templates = __esm(() => {
   init_database();
   init_tasks();
@@ -14439,6 +14776,118 @@ var init_burndown = __esm(() => {
   init_database();
 });
 
+// src/db/builtin-templates.ts
+var exports_builtin_templates = {};
+__export(exports_builtin_templates, {
+  initBuiltinTemplates: () => initBuiltinTemplates,
+  BUILTIN_TEMPLATES: () => BUILTIN_TEMPLATES
+});
+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 };
+}
+var BUILTIN_TEMPLATES;
+var init_builtin_templates = __esm(() => {
+  init_database();
+  init_templates();
+  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] }
+      ]
+    }
+  ];
+});
+
 // src/lib/auto-assign.ts
 var exports_auto_assign = {};
 __export(exports_auto_assign, {
@@ -16146,6 +16595,26 @@ var init_pg_migrations = __esm(() => {
   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;
   `
   ];
 });
@@ -21034,6 +21503,11 @@ var STANDARD_EXCLUDED = new Set([
   "create_task_from_template",
   "delete_template",
   "update_template",
+  "init_templates",
+  "preview_template",
+  "export_template",
+  "import_template",
+  "template_history",
   "approve_task"
 ]);
 function shouldRegisterTool(name) {
@@ -22766,15 +23240,20 @@ ${data.chart}` }] };
   });
 }
 if (shouldRegisterTool("create_webhook")) {
-  server.tool("create_webhook", "Register a webhook for task change events.", {
+  server.tool("create_webhook", "Register a webhook for task change events. Optionally scope to a project, task list, agent, or specific task.", {
     url: exports_external.string(),
-    events: exports_external.array(exports_external.string()).optional(),
-    secret: exports_external.string().optional()
+    events: exports_external.array(exports_external.string()).optional().describe("Event types to subscribe to (empty = all). E.g. task.created, task.completed, task.failed, task.started, task.assigned, task.status_changed"),
+    secret: exports_external.string().optional().describe("HMAC secret for signing webhook payloads"),
+    project_id: exports_external.string().optional().describe("Only fire for events in this project"),
+    task_list_id: exports_external.string().optional().describe("Only fire for events in this task list"),
+    agent_id: exports_external.string().optional().describe("Only fire for events involving this agent"),
+    task_id: exports_external.string().optional().describe("Only fire for events on this specific task")
   }, async (params) => {
     try {
       const { createWebhook: createWebhook2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
       const wh = createWebhook2(params);
-      return { content: [{ type: "text", text: `Webhook created: ${wh.id.slice(0, 8)} | ${wh.url} | events: ${wh.events.length === 0 ? "all" : wh.events.join(",")}` }] };
+      const scope = [wh.project_id && `project:${wh.project_id}`, wh.task_list_id && `list:${wh.task_list_id}`, wh.agent_id && `agent:${wh.agent_id}`, wh.task_id && `task:${wh.task_id}`].filter(Boolean).join(", ");
+      return { content: [{ type: "text", text: `Webhook created: ${wh.id.slice(0, 8)} | ${wh.url} | events: ${wh.events.length === 0 ? "all" : wh.events.join(",")}${scope ? ` | scope: ${scope}` : ""}` }] };
     } catch (e) {
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
@@ -22810,7 +23289,7 @@ if (shouldRegisterTool("delete_webhook")) {
   });
 }
 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).", {
+  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(),
@@ -22818,6 +23297,12 @@ if (shouldRegisterTool("create_template")) {
     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(),
@@ -22847,7 +23332,10 @@ if (shouldRegisterTool("list_templates")) {
       const templates = listTemplates2();
       if (templates.length === 0)
         return { content: [{ type: "text", text: "No templates." }] };
-      const text = templates.map((t) => `${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}`).join(`
+      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}` }] };
@@ -22872,7 +23360,8 @@ if (shouldRegisterTool("create_task_from_template")) {
       const resolvedTemplateId = resolveId(params.template_id, "task_templates");
       const templateWithTasks = getTemplateWithTasks2(resolvedTemplateId);
       if (templateWithTasks && templateWithTasks.tasks.length > 0) {
-        const tasks = tasksFromTemplate2(resolvedTemplateId, params.project_id || templateWithTasks.project_id || "", params.variables, params.task_list_id);
+        const effectiveProjectId = params.project_id || templateWithTasks.project_id || undefined;
+        const tasks = tasksFromTemplate2(resolvedTemplateId, effectiveProjectId, params.variables, params.task_list_id);
         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:
@@ -22929,6 +23418,93 @@ if (shouldRegisterTool("update_template")) {
     }
   });
 }
+if (shouldRegisterTool("init_templates")) {
+  server.tool("init_templates", "Initialize built-in starter templates (open-source-project, bug-fix, feature, security-audit). 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("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 };
+    }
+  });
+}
 if (shouldRegisterTool("approve_task")) {
   server.tool("approve_task", "Approve a task with requires_approval=true.", {
     id: exports_external.string(),
@@ -24046,6 +24622,11 @@ if (shouldRegisterTool("search_tools")) {
       "create_task_from_template",
       "delete_template",
       "update_template",
+      "init_templates",
+      "preview_template",
+      "export_template",
+      "import_template",
+      "template_history",
       "bulk_update_tasks",
       "bulk_create_tasks",
       "get_task_stats",
@@ -24285,8 +24866,21 @@ if (shouldRegisterTool("describe_tools")) {
   Params: id(string, req)
   Example: {id: 'a1b2c3d4'}`,
       update_template: `Update a task template's name, title pattern, or other fields.
-  Params: id(string, req), name(string), title_pattern(string), description(string), priority(low|medium|high|critical), tags(string[]), project_id(string), plan_id(string)
+  Params: id(string, req), name(string), title_pattern(string), description(string), priority(low|medium|high|critical), tags(string[]), variables(TemplateVariable[]), project_id(string), plan_id(string)
   Example: {id: 'a1b2c3d4', name: 'Renamed Template', priority: 'critical'}`,
+      init_templates: "Initialize built-in starter templates (open-source-project, bug-fix, feature, security-audit). Skips already existing. No params.",
+      preview_template: `Preview a template without creating tasks. Shows resolved titles, deps, priorities.
+  Params: template_id(string, req), variables(Record<string,string>)
+  Example: {template_id: 'a1b2c3d4', variables: {name: 'invoices'}}`,
+      export_template: `Export a template as JSON (template + tasks + variables). Use for sharing or backup.
+  Params: template_id(string, req)
+  Example: {template_id: 'a1b2c3d4'}`,
+      import_template: `Import a template from a JSON string (as returned by export_template). Creates new template with new IDs.
+  Params: json(string, req)
+  Example: {json: '{"name":"My Template",...}'}`,
+      template_history: `Show version history of a template. Each update creates a snapshot of the previous state.
+  Params: template_id(string, req)
+  Example: {template_id: 'a1b2c3d4'}`,
       get_active_work: `See all in-progress tasks and who is working on them.
   Params: project_id(string, optional), task_list_id(string, optional)
   Example: {project_id: 'a1b2c3d4'}`,