@hasna/todos 0.11.9 → 0.11.12

package/dist/cli/index.js

@@ -2290,6 +2290,20 @@ function ensureSchema(db) {
       metadata TEXT DEFAULT '{}',
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     )`);
+  ensureTable("template_tasks", `
+    CREATE TABLE template_tasks (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+      position INTEGER NOT NULL,
+      title_pattern TEXT NOT NULL,
+      description TEXT,
+      priority TEXT DEFAULT 'medium',
+      tags TEXT DEFAULT '[]',
+      task_type TEXT,
+      depends_on_positions TEXT DEFAULT '[]',
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
   ensureTable("task_checklists", `
     CREATE TABLE task_checklists (
       id TEXT PRIMARY KEY,
@@ -2374,6 +2388,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)");
@@ -2400,6 +2444,7 @@ function ensureSchema(db) {
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_source ON task_relationships(source_task_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_target ON task_relationships(target_task_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_type ON task_relationships(relationship_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_template_tasks_template ON template_tasks(template_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_source ON kg_edges(source_id, source_type)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_target ON kg_edges(target_id, target_type)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_relation ON kg_edges(relation_type)");
@@ -3043,6 +3088,44 @@ var init_database = __esm(() => {
   );
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (36);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS template_tasks (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+    position INTEGER NOT NULL,
+    title_pattern TEXT NOT NULL,
+    description TEXT,
+    priority TEXT DEFAULT 'medium',
+    tags TEXT DEFAULT '[]',
+    task_type TEXT,
+    depends_on_positions TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  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);
   `
   ];
 });
@@ -3680,18 +3763,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) {
@@ -3707,22 +3809,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();
 });
@@ -3731,18 +3880,42 @@ var init_webhooks = __esm(() => {
 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
+  createTemplate: () => createTemplate,
+  addTemplateTasks: () => addTemplateTasks
 });
 function rowToTemplate(row) {
   return {
     ...row,
     tags: JSON.parse(row.tags || "[]"),
+    variables: JSON.parse(row.variables || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    priority: row.priority || "medium",
+    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"
+    priority: row.priority || "medium",
+    condition: row.condition ?? null,
+    include_template_id: row.include_template_id ?? null
   };
 }
 function resolveTemplateId(id, d) {
@@ -3751,19 +3924,23 @@ 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 || {}),
     now()
   ]);
+  if (input.tasks && input.tasks.length > 0) {
+    addTemplateTasks(id, input.tasks, d);
+  }
   return getTemplate(id, d);
 }
 function getTemplate(id, db) {
@@ -3790,7 +3967,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 = ?");
@@ -3812,6 +4005,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);
@@ -3824,8 +4021,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);
@@ -3845,8 +4040,294 @@ function taskFromTemplate(templateId, overrides = {}, db) {
     ...overrides
   };
 }
+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();
 });
 
 // src/db/checklists.ts
@@ -6406,6 +6887,118 @@ var init_task_commits = __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/extract.ts
 var exports_extract = {};
 __export(exports_extract, {
@@ -22940,6 +23533,44 @@ var init_pg_migrations = __esm(() => {
   );
 
   INSERT INTO _migrations (id) VALUES (36) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS template_tasks (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    template_id TEXT NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+    position INTEGER NOT NULL,
+    title_pattern TEXT NOT NULL,
+    description TEXT,
+    priority TEXT DEFAULT 'medium',
+    tags TEXT DEFAULT '[]',
+    task_type TEXT,
+    depends_on_positions TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+  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;
   `
   ];
 });
@@ -23199,6 +23830,11 @@ var init_mcp = __esm(() => {
     "create_task_from_template",
     "delete_template",
     "update_template",
+    "init_templates",
+    "preview_template",
+    "export_template",
+    "import_template",
+    "template_history",
     "approve_task"
   ]);
   agentFocusMap = new Map;
@@ -24792,15 +25428,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 };
       }
@@ -24836,19 +25477,37 @@ ${text}` }] };
     });
   }
   if (shouldRegisterTool("create_template")) {
-    server.tool("create_template", "Create a reusable task 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()
+      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 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const { createTemplate: createTemplate2, getTemplateWithTasks: getTemplateWithTasks2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
         const t = createTemplate2(params);
-        return { content: [{ type: "text", text: `Template created: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}"` }] };
+        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 };
       }
@@ -24861,7 +25520,10 @@ ${text}` }] };
         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}` }] };
@@ -24871,23 +25533,35 @@ ${text}` }] };
     });
   }
   if (shouldRegisterTool("create_task_from_template")) {
-    server.tool("create_task_from_template", "Create a task from a template with optional overrides.", {
+    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(),
-      description: exports_external.string().optional(),
+      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()
+      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 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const { taskFromTemplate: taskFromTemplate2, getTemplateWithTasks: getTemplateWithTasks2, tasksFromTemplate: tasksFromTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
         const resolvedTemplateId = resolveId(params.template_id, "task_templates");
+        const templateWithTasks = getTemplateWithTasks2(resolvedTemplateId);
+        if (templateWithTasks && templateWithTasks.tasks.length > 0) {
+          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:
+${text}` }] };
+        }
         const input = taskFromTemplate2(resolvedTemplateId, {
           title: params.title,
           description: params.description,
           priority: params.priority,
           assigned_to: params.assigned_to,
-          project_id: params.project_id
+          project_id: params.project_id,
+          task_list_id: params.task_list_id
         });
         const task = createTask(input);
         return { content: [{ type: "text", text: `Task created from template:
@@ -24932,6 +25606,93 @@ ${task.id.slice(0, 8)} | ${task.priority} | ${task.title}` }] };
       }
     });
   }
+  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(),
@@ -26049,6 +26810,11 @@ ${stack_trace.slice(0, 1500)}
         "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",
@@ -26275,19 +27041,34 @@ ${stack_trace.slice(0, 1500)}
         delete_webhook: `Delete a webhook by ID.
   Params: id(string, req)
   Example: {id: 'a1b2c3d4'}`,
-        create_template: `Create a reusable task template.
-  Params: name(string, req), title_pattern(string, req \u2014 e.g. 'Fix: {description}'), description(string), priority(low|medium|high|critical), tags(string[]), project_id(string), plan_id(string)
-  Example: {name: 'Bug Report', title_pattern: 'Bug: {description}', priority: 'high', tags: ['bug']}`,
+        create_template: `Create a reusable task template. Supports multi-task templates with dependencies.
+  Params: name(string, req), title_pattern(string, req), description(string), priority(low|medium|high|critical), tags(string[]), project_id(string), plan_id(string), tasks(array of {title_pattern, description, priority, tags, task_type, depends_on(number[]), metadata})
+  Example single: {name: 'Bug Report', title_pattern: 'Bug: {description}', priority: 'high', tags: ['bug']}
+  Example multi: {name: 'Feature', title_pattern: 'Feature: {name}', tasks: [{title_pattern: 'Design {name}'}, {title_pattern: 'Implement {name}', depends_on: [0]}, {title_pattern: 'Test {name}', depends_on: [1]}]}`,
         list_templates: "List all task templates. No params.",
-        create_task_from_template: `Create a task from a template with optional overrides.
-  Params: template_id(string, req), title(string), description(string), priority(low|medium|high|critical), assigned_to(string), project_id(string)
-  Example: {template_id: 'a1b2c3d4', assigned_to: 'maximus'}`,
+        create_task_from_template: `Create task(s) from a template. Multi-task templates create all tasks with dependencies wired. Supports {variable} substitution.
+  Params: template_id(string, req), title(string \u2014 single-task override), description(string), priority(low|medium|high|critical), assigned_to(string), project_id(string), task_list_id(string), variables(Record<string,string> \u2014 {name} substitution)
+  Example single: {template_id: 'a1b2c3d4', assigned_to: 'maximus'}
+  Example multi: {template_id: 'a1b2c3d4', project_id: 'proj1', variables: {name: 'OAuth login'}}`,
         delete_template: `Delete a task template.
   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'}`,
@@ -27307,6 +28088,8 @@ async function startServer(port, options) {
         continue;
       if (client.agentId && event.agent_id !== client.agentId)
         continue;
+      if (client.projectId && event.project_id !== client.projectId)
+        continue;
       try {
         client.controller.enqueue(`event: ${eventName}
 data: ${data}
@@ -27345,6 +28128,31 @@ Dashboard not found at: ${dashboardDir}`);
         });
       }
       if (path === "/api/events" && method === "GET") {
+        const agentId = url.searchParams.get("agent_id") || undefined;
+        const projectId = url.searchParams.get("project_id") || undefined;
+        if (agentId || projectId) {
+          const client = { controller: null, agentId, projectId, events: undefined };
+          const stream2 = new ReadableStream({
+            start(controller) {
+              client.controller = controller;
+              filteredSseClients.add(client);
+              controller.enqueue(`data: ${JSON.stringify({ type: "connected", agent_id: agentId, project_id: projectId, timestamp: new Date().toISOString() })}
+
+`);
+            },
+            cancel() {
+              filteredSseClients.delete(client);
+            }
+          });
+          return new Response(stream2, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive",
+              "Access-Control-Allow-Origin": "*"
+            }
+          });
+        }
         const stream = new ReadableStream({
           start(controller) {
             sseClients.add(controller);
@@ -27453,7 +28261,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
             priority: body.priority,
             project_id: body.project_id
           });
-          broadcastEvent({ type: "task", task_id: task.id, action: "created", agent_id: task.agent_id });
+          broadcastEvent({ type: "task", task_id: task.id, action: "created", agent_id: task.agent_id, project_id: task.project_id });
           return json(taskToSummary(task), 201, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to create task" }, 500, port);
@@ -27674,7 +28482,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
         const id = startMatch[1];
         try {
           const task = startTask(id, "dashboard");
-          broadcastEvent({ type: "task", task_id: task.id, action: "started", agent_id: "dashboard" });
+          broadcastEvent({ type: "task", task_id: task.id, action: "started", agent_id: "dashboard", project_id: task.project_id });
           return json(taskToSummary(task), 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to start task" }, 500, port);
@@ -27687,7 +28495,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
           const body = await req.json().catch(() => ({}));
           const { failTask: failTask2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
           const result = failTask2(id, body.agent_id, body.reason, { retry: body.retry, error_code: body.error_code });
-          broadcastEvent({ type: "task", task_id: id, action: "failed", agent_id: body.agent_id || null });
+          broadcastEvent({ type: "task", task_id: id, action: "failed", agent_id: body.agent_id || null, project_id: result.task.project_id });
           return json({ task: taskToSummary(result.task), retry_task: result.retryTask ? taskToSummary(result.retryTask) : null }, 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to fail task" }, 500, port);
@@ -27698,7 +28506,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
         const id = completeMatch[1];
         try {
           const task = completeTask(id, "dashboard");
-          broadcastEvent({ type: "task", task_id: task.id, action: "completed", agent_id: "dashboard" });
+          broadcastEvent({ type: "task", task_id: task.id, action: "completed", agent_id: "dashboard", project_id: task.project_id });
           return json(taskToSummary(task), 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to complete task" }, 500, port);
@@ -30699,7 +31507,117 @@ program2.command("templates").description("List and manage task templates").opti
   console.log(chalk2.bold(`${templates.length} template(s):
 `));
   for (const t of templates) {
-    console.log(`  ${chalk2.dim(t.id.slice(0, 8))} ${chalk2.bold(t.name)} ${chalk2.cyan(`"${t.title_pattern}"`)} ${chalk2.yellow(t.priority)}`);
+    const vars = t.variables && t.variables.length > 0 ? ` ${chalk2.dim(`(${t.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")})`)}` : "";
+    console.log(`  ${chalk2.dim(t.id.slice(0, 8))} ${chalk2.bold(t.name)} ${chalk2.cyan(`"${t.title_pattern}"`)} ${chalk2.yellow(t.priority)}${vars}`);
+  }
+});
+program2.command("template-init").alias("templates-init").description("Initialize built-in starter templates (open-source-project, bug-fix, feature, security-audit)").action(() => {
+  const globalOpts = program2.opts();
+  const { initBuiltinTemplates: initBuiltinTemplates2 } = (init_builtin_templates(), __toCommonJS(exports_builtin_templates));
+  const result = initBuiltinTemplates2();
+  if (globalOpts.json) {
+    output(result, true);
+    return;
+  }
+  if (result.created === 0) {
+    console.log(chalk2.dim(`All ${result.skipped} built-in template(s) already exist.`));
+  } else {
+    console.log(chalk2.green(`Created ${result.created} template(s): ${result.names.join(", ")}. Skipped ${result.skipped} existing.`));
+  }
+});
+program2.command("template-preview <id>").alias("templates-preview").description("Preview a template without creating tasks \u2014 shows resolved titles, deps, and priorities").option("--var <vars...>", "Variable substitution in key=value format (e.g. --var name=invoices)").action((id, opts) => {
+  const globalOpts = program2.opts();
+  const { previewTemplate: previewTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
+  const variables = {};
+  if (opts.var) {
+    for (const v of opts.var) {
+      const eq = v.indexOf("=");
+      if (eq === -1) {
+        console.error(chalk2.red(`Invalid variable format: ${v} (expected key=value)`));
+        process.exit(1);
+      }
+      variables[v.slice(0, eq)] = v.slice(eq + 1);
+    }
+  }
+  try {
+    const preview = previewTemplate2(id, Object.keys(variables).length > 0 ? variables : undefined);
+    if (globalOpts.json) {
+      output(preview, true);
+      return;
+    }
+    console.log(chalk2.bold(`Preview: ${preview.template_name} (${preview.tasks.length} tasks)`));
+    if (preview.description)
+      console.log(chalk2.dim(`  ${preview.description}`));
+    if (preview.variables.length > 0) {
+      console.log(chalk2.dim(`  Variables: ${preview.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")}`));
+    }
+    if (Object.keys(preview.resolved_variables).length > 0) {
+      console.log(chalk2.dim(`  Resolved: ${Object.entries(preview.resolved_variables).map(([k, v]) => `${k}=${v}`).join(", ")}`));
+    }
+    console.log();
+    for (const t of preview.tasks) {
+      const deps = t.depends_on_positions.length > 0 ? chalk2.dim(` (after: ${t.depends_on_positions.join(", ")})`) : "";
+      console.log(`  ${chalk2.dim(`[${t.position}]`)} ${chalk2.yellow(t.priority)} | ${t.title}${deps}`);
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("template-export <id>").alias("templates-export").description("Export a template as JSON to stdout").action((id) => {
+  const { exportTemplate: exportTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
+  try {
+    const json2 = exportTemplate2(id);
+    console.log(JSON.stringify(json2, null, 2));
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("template-import").alias("templates-import").description("Import a template from a JSON file").option("--file <path>", "Path to template JSON file").action((opts) => {
+  const globalOpts = program2.opts();
+  const { importTemplate: importTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
+  const { readFileSync: readFileSync8 } = __require("fs");
+  try {
+    if (!opts.file) {
+      console.error(chalk2.red("--file is required"));
+      process.exit(1);
+    }
+    const content = readFileSync8(opts.file, "utf-8");
+    const json2 = JSON.parse(content);
+    const template = importTemplate2(json2);
+    if (globalOpts.json) {
+      output(template, true);
+    } else {
+      console.log(chalk2.green(`Template imported: ${template.id.slice(0, 8)} | ${template.name} | "${template.title_pattern}"`));
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("template-history <id>").alias("templates-history").description("Show version history of a template").action((id) => {
+  const globalOpts = program2.opts();
+  const { listTemplateVersions: listTemplateVersions2, getTemplate: getTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
+  try {
+    const template = getTemplate2(id);
+    if (!template) {
+      console.error(chalk2.red("Template not found."));
+      process.exit(1);
+    }
+    const versions = listTemplateVersions2(id);
+    if (globalOpts.json) {
+      output({ current_version: template.version, versions }, true);
+      return;
+    }
+    console.log(chalk2.bold(`${template.name} \u2014 current version: ${template.version}`));
+    if (versions.length === 0) {
+      console.log(chalk2.dim("  No previous versions."));
+    } else {
+      for (const v of versions) {
+        const snap = JSON.parse(v.snapshot);
+        console.log(`  ${chalk2.dim(`v${v.version}`)} | ${v.created_at} | ${snap.name} | "${snap.title_pattern}"`);
+      }
+    }
+  } catch (e) {
+    handleError(e);
   }
 });
 program2.command("comment <id> <text>").description("Add a comment to a task").action((id, text) => {