@hasna/todos 0.11.41 → 0.11.43

package/dist/mcp/index.js

@@ -981,6 +981,19 @@ var init_migrations = __esm(() => {
   );
   CREATE INDEX IF NOT EXISTS idx_handoff_acks_agent ON handoff_acknowledgements(agent_id, acknowledged_at);
   INSERT OR IGNORE INTO _migrations (id) VALUES (54);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS saved_search_views (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    scope TEXT NOT NULL DEFAULT 'tasks' CHECK(scope IN ('all', 'tasks', 'projects', 'plans', 'runs', 'comments')),
+    filters TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_saved_search_views_scope ON saved_search_views(scope);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (55);
   `
   ];
 });
@@ -1157,6 +1170,17 @@ function ensureSchema(db) {
       PRIMARY KEY (handoff_id, agent_id)
     )`);
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_handoff_acks_agent ON handoff_acknowledgements(agent_id, acknowledged_at)");
+  ensureTable("saved_search_views", `
+    CREATE TABLE saved_search_views (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      scope TEXT NOT NULL DEFAULT 'tasks' CHECK(scope IN ('all', 'tasks', 'projects', 'plans', 'runs', 'comments')),
+      filters TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_saved_search_views_scope ON saved_search_views(scope)");
   ensureTable("task_relationships", `
     CREATE TABLE task_relationships (
       id TEXT PRIMARY KEY,
@@ -4412,6 +4436,26 @@ var init_recurrence = __esm(() => {
 });
 
 // src/db/templates.ts
+var exports_templates = {};
+__export(exports_templates, {
+  updateTemplate: () => updateTemplate,
+  tasksFromTemplate: () => tasksFromTemplate,
+  taskFromTemplate: () => taskFromTemplate,
+  resolveVariables: () => resolveVariables,
+  previewTemplate: () => previewTemplate,
+  listTemplates: () => listTemplates,
+  listTemplateVersions: () => listTemplateVersions,
+  importTemplate: () => importTemplate,
+  getTemplateWithTasks: () => getTemplateWithTasks,
+  getTemplateVersion: () => getTemplateVersion,
+  getTemplateTasks: () => getTemplateTasks,
+  getTemplate: () => getTemplate,
+  exportTemplate: () => exportTemplate,
+  evaluateCondition: () => evaluateCondition,
+  deleteTemplate: () => deleteTemplate,
+  createTemplate: () => createTemplate,
+  addTemplateTasks: () => addTemplateTasks
+});
 function rowToTemplate(row) {
   return {
     ...row,
@@ -4422,9 +4466,42 @@ function rowToTemplate(row) {
     version: row.version ?? 1
   };
 }
+function rowToTemplateTask(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    depends_on_positions: JSON.parse(row.depends_on_positions || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    priority: row.priority || "medium",
+    condition: row.condition ?? null,
+    include_template_id: row.include_template_id ?? null
+  };
+}
 function resolveTemplateId(id, d) {
   return resolvePartialId(d, "task_templates", id);
 }
+function createTemplate(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO task_templates (id, name, title_pattern, description, priority, tags, variables, project_id, plan_id, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.title_pattern,
+    input.description || null,
+    input.priority || "medium",
+    JSON.stringify(input.tags || []),
+    JSON.stringify(input.variables || []),
+    input.project_id || null,
+    input.plan_id || null,
+    JSON.stringify(input.metadata || {}),
+    now()
+  ]);
+  if (input.tasks && input.tasks.length > 0) {
+    addTemplateTasks(id, input.tasks, d);
+  }
+  return getTemplate(id, d);
+}
 function getTemplate(id, db) {
   const d = db || getDatabase();
   const resolved = resolveTemplateId(id, d);
@@ -4433,6 +4510,80 @@ function getTemplate(id, db) {
   const row = d.query("SELECT * FROM task_templates WHERE id = ?").get(resolved);
   return row ? rowToTemplate(row) : null;
 }
+function listTemplates(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_templates ORDER BY name").all().map(rowToTemplate);
+}
+function deleteTemplate(id, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return false;
+  return d.run("DELETE FROM task_templates WHERE id = ?", [resolved]).changes > 0;
+}
+function updateTemplate(id, updates, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const current = getTemplateWithTasks(resolved, d);
+  if (current) {
+    const snapshot = JSON.stringify({
+      name: current.name,
+      title_pattern: current.title_pattern,
+      description: current.description,
+      priority: current.priority,
+      tags: current.tags,
+      variables: current.variables,
+      project_id: current.project_id,
+      plan_id: current.plan_id,
+      metadata: current.metadata,
+      tasks: current.tasks
+    });
+    d.run(`INSERT INTO template_versions (id, template_id, version, snapshot, created_at) VALUES (?, ?, ?, ?, ?)`, [uuid(), resolved, current.version, snapshot, now()]);
+  }
+  const sets = ["version = version + 1"];
+  const values = [];
+  if (updates.name !== undefined) {
+    sets.push("name = ?");
+    values.push(updates.name);
+  }
+  if (updates.title_pattern !== undefined) {
+    sets.push("title_pattern = ?");
+    values.push(updates.title_pattern);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    values.push(updates.description);
+  }
+  if (updates.priority !== undefined) {
+    sets.push("priority = ?");
+    values.push(updates.priority);
+  }
+  if (updates.tags !== undefined) {
+    sets.push("tags = ?");
+    values.push(JSON.stringify(updates.tags));
+  }
+  if (updates.variables !== undefined) {
+    sets.push("variables = ?");
+    values.push(JSON.stringify(updates.variables));
+  }
+  if (updates.project_id !== undefined) {
+    sets.push("project_id = ?");
+    values.push(updates.project_id);
+  }
+  if (updates.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    values.push(updates.plan_id);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    values.push(JSON.stringify(updates.metadata));
+  }
+  values.push(resolved);
+  d.run(`UPDATE task_templates SET ${sets.join(", ")} WHERE id = ?`, values);
+  return getTemplate(resolved, d);
+}
 function taskFromTemplate(templateId, overrides = {}, db) {
   const t = getTemplate(templateId, db);
   if (!t)
@@ -4449,6 +4600,291 @@ function taskFromTemplate(templateId, overrides = {}, db) {
     ...cleanOverrides
   };
 }
+function addTemplateTasks(templateId, tasks, db) {
+  const d = db || getDatabase();
+  const template = getTemplate(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  d.run("DELETE FROM template_tasks WHERE template_id = ?", [templateId]);
+  const results = [];
+  for (let i = 0;i < tasks.length; i++) {
+    const task = tasks[i];
+    const id = uuid();
+    d.run(`INSERT INTO template_tasks (id, template_id, position, title_pattern, description, priority, tags, task_type, condition, include_template_id, depends_on_positions, metadata, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      templateId,
+      i,
+      task.title_pattern,
+      task.description || null,
+      task.priority || "medium",
+      JSON.stringify(task.tags || []),
+      task.task_type || null,
+      task.condition || null,
+      task.include_template_id || null,
+      JSON.stringify(task.depends_on || []),
+      JSON.stringify(task.metadata || {}),
+      now()
+    ]);
+    const row = d.query("SELECT * FROM template_tasks WHERE id = ?").get(id);
+    if (row)
+      results.push(rowToTemplateTask(row));
+  }
+  return results;
+}
+function getTemplateWithTasks(id, db) {
+  const d = db || getDatabase();
+  const template = getTemplate(id, d);
+  if (!template)
+    return null;
+  const rows = d.query("SELECT * FROM template_tasks WHERE template_id = ? ORDER BY position").all(template.id);
+  const tasks = rows.map(rowToTemplateTask);
+  return { ...template, tasks };
+}
+function getTemplateTasks(templateId, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(templateId, d);
+  if (!resolved)
+    return [];
+  const rows = d.query("SELECT * FROM template_tasks WHERE template_id = ? ORDER BY position").all(resolved);
+  return rows.map(rowToTemplateTask);
+}
+function evaluateCondition(condition, variables) {
+  if (!condition || condition.trim() === "")
+    return true;
+  const trimmed = condition.trim();
+  const eqMatch = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
+  if (eqMatch) {
+    const varName = eqMatch[1];
+    const expected = eqMatch[2].trim();
+    return (variables[varName] ?? "") === expected;
+  }
+  const neqMatch = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
+  if (neqMatch) {
+    const varName = neqMatch[1];
+    const expected = neqMatch[2].trim();
+    return (variables[varName] ?? "") !== expected;
+  }
+  const falsyMatch = trimmed.match(/^!\{([^}]+)\}$/);
+  if (falsyMatch) {
+    const varName = falsyMatch[1];
+    const val = variables[varName];
+    return !val || val === "" || val === "false";
+  }
+  const truthyMatch = trimmed.match(/^\{([^}]+)\}$/);
+  if (truthyMatch) {
+    const varName = truthyMatch[1];
+    const val = variables[varName];
+    return !!val && val !== "" && val !== "false";
+  }
+  return true;
+}
+function exportTemplate(id, db) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(id, d);
+  if (!template)
+    throw new Error(`Template not found: ${id}`);
+  return {
+    name: template.name,
+    title_pattern: template.title_pattern,
+    description: template.description,
+    priority: template.priority,
+    tags: template.tags,
+    variables: template.variables,
+    project_id: template.project_id,
+    plan_id: template.plan_id,
+    metadata: template.metadata,
+    tasks: template.tasks.map((t) => ({
+      position: t.position,
+      title_pattern: t.title_pattern,
+      description: t.description,
+      priority: t.priority,
+      tags: t.tags,
+      task_type: t.task_type,
+      condition: t.condition,
+      include_template_id: t.include_template_id,
+      depends_on_positions: t.depends_on_positions,
+      metadata: t.metadata
+    }))
+  };
+}
+function importTemplate(json, db) {
+  const d = db || getDatabase();
+  const taskInputs = (json.tasks || []).map((t) => ({
+    title_pattern: t.title_pattern,
+    description: t.description ?? undefined,
+    priority: t.priority,
+    tags: t.tags,
+    task_type: t.task_type ?? undefined,
+    condition: t.condition ?? undefined,
+    include_template_id: t.include_template_id ?? undefined,
+    depends_on: t.depends_on_positions,
+    metadata: t.metadata
+  }));
+  return createTemplate({
+    name: json.name,
+    title_pattern: json.title_pattern,
+    description: json.description ?? undefined,
+    priority: json.priority,
+    tags: json.tags,
+    variables: json.variables,
+    project_id: json.project_id ?? undefined,
+    plan_id: json.plan_id ?? undefined,
+    metadata: json.metadata,
+    tasks: taskInputs
+  }, d);
+}
+function getTemplateVersion(id, version, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return null;
+  const row = d.query("SELECT * FROM template_versions WHERE template_id = ? AND version = ?").get(resolved, version);
+  return row || null;
+}
+function listTemplateVersions(id, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTemplateId(id, d);
+  if (!resolved)
+    return [];
+  return d.query("SELECT * FROM template_versions WHERE template_id = ? ORDER BY version DESC").all(resolved);
+}
+function resolveVariables(templateVars, provided) {
+  const merged = { ...provided };
+  for (const v of templateVars) {
+    if (merged[v.name] === undefined && v.default !== undefined) {
+      merged[v.name] = v.default;
+    }
+  }
+  const missing = [];
+  for (const v of templateVars) {
+    if (v.required && merged[v.name] === undefined) {
+      missing.push(v.name);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
+  }
+  return merged;
+}
+function substituteVars(text, variables) {
+  let result = text;
+  for (const [key, val] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
+  }
+  return result;
+}
+function tasksFromTemplate(templateId, projectId, variables, taskListId, db, _visitedTemplateIds) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  const visited = _visitedTemplateIds || new Set;
+  if (visited.has(template.id)) {
+    throw new Error(`Circular template reference detected: ${template.id}`);
+  }
+  visited.add(template.id);
+  const resolved = resolveVariables(template.variables, variables);
+  if (template.tasks.length === 0) {
+    const input = taskFromTemplate(templateId, { project_id: projectId, task_list_id: taskListId }, d);
+    const task = createTask(input, d);
+    return [task];
+  }
+  const createdTasks = [];
+  const positionToId = new Map;
+  const skippedPositions = new Set;
+  for (const tt of template.tasks) {
+    if (tt.include_template_id) {
+      const includedTasks = tasksFromTemplate(tt.include_template_id, projectId, resolved, taskListId, d, visited);
+      createdTasks.push(...includedTasks);
+      if (includedTasks.length > 0) {
+        positionToId.set(tt.position, includedTasks[0].id);
+      } else {
+        skippedPositions.add(tt.position);
+      }
+      continue;
+    }
+    if (tt.condition && !evaluateCondition(tt.condition, resolved)) {
+      skippedPositions.add(tt.position);
+      continue;
+    }
+    let title = tt.title_pattern;
+    let desc = tt.description;
+    title = substituteVars(title, resolved);
+    if (desc)
+      desc = substituteVars(desc, resolved);
+    const task = createTask({
+      title,
+      description: desc ?? undefined,
+      priority: tt.priority,
+      tags: tt.tags,
+      task_type: tt.task_type ?? undefined,
+      project_id: projectId,
+      task_list_id: taskListId,
+      metadata: tt.metadata
+    }, d);
+    createdTasks.push(task);
+    positionToId.set(tt.position, task.id);
+  }
+  for (const tt of template.tasks) {
+    if (skippedPositions.has(tt.position))
+      continue;
+    if (tt.include_template_id)
+      continue;
+    const deps = tt.depends_on_positions;
+    for (const depPos of deps) {
+      if (skippedPositions.has(depPos))
+        continue;
+      const taskId = positionToId.get(tt.position);
+      const depId = positionToId.get(depPos);
+      if (taskId && depId) {
+        addDependency(taskId, depId, d);
+      }
+    }
+  }
+  return createdTasks;
+}
+function previewTemplate(templateId, variables, db) {
+  const d = db || getDatabase();
+  const template = getTemplateWithTasks(templateId, d);
+  if (!template)
+    throw new Error(`Template not found: ${templateId}`);
+  const resolved = resolveVariables(template.variables, variables);
+  const tasks = [];
+  if (template.tasks.length === 0) {
+    tasks.push({
+      position: 0,
+      title: substituteVars(template.title_pattern, resolved),
+      description: template.description ? substituteVars(template.description, resolved) : null,
+      priority: template.priority,
+      tags: template.tags,
+      task_type: null,
+      depends_on_positions: []
+    });
+  } else {
+    for (const tt of template.tasks) {
+      if (tt.condition && !evaluateCondition(tt.condition, resolved))
+        continue;
+      tasks.push({
+        position: tt.position,
+        title: substituteVars(tt.title_pattern, resolved),
+        description: tt.description ? substituteVars(tt.description, resolved) : null,
+        priority: tt.priority,
+        tags: tt.tags,
+        task_type: tt.task_type,
+        depends_on_positions: tt.depends_on_positions
+      });
+    }
+  }
+  return {
+    template_id: template.id,
+    template_name: template.name,
+    description: template.description,
+    variables: template.variables,
+    resolved_variables: resolved,
+    tasks
+  };
+}
 var init_templates = __esm(() => {
   init_database();
   init_tasks();
@@ -6611,6 +7047,101 @@ var init_task_runs = __esm(() => {
   init_tasks();
 });
 
+// src/lib/local-fields.ts
+function normalizeList(values) {
+  return [...new Set((values || []).map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function metadataFields(task) {
+  const value = task.metadata[LOCAL_FIELDS_KEY];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function sameCustomValue(actual, expected) {
+  return JSON.stringify(actual) === JSON.stringify(expected);
+}
+function hasOwnField(fields, key) {
+  return Object.prototype.hasOwnProperty.call(fields, key);
+}
+function getTaskLocalFields(taskId, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new TaskNotFoundError(taskId);
+  const fields = metadataFields(task);
+  return {
+    labels: normalizeList(fields.labels),
+    priority: task.priority,
+    severity: typeof fields.severity === "string" ? fields.severity : null,
+    owner: hasOwnField(fields, "owner") ? typeof fields.owner === "string" ? fields.owner : null : task.assigned_to,
+    area: typeof fields.area === "string" ? fields.area : null,
+    custom: fields.custom && typeof fields.custom === "object" && !Array.isArray(fields.custom) ? fields.custom : {}
+  };
+}
+function setTaskLocalFields(taskId, input, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new TaskNotFoundError(taskId);
+  const currentFields = getTaskLocalFields(taskId, d);
+  const labels = input.labels !== undefined ? normalizeList(input.labels) : currentFields.labels;
+  const custom2 = input.custom !== undefined ? redactValue(input.merge_custom === false ? input.custom : { ...currentFields.custom, ...input.custom }) : currentFields.custom;
+  const nextFields = {
+    labels,
+    priority: input.priority || task.priority,
+    severity: input.severity !== undefined ? input.severity : currentFields.severity,
+    owner: input.owner !== undefined ? input.owner : currentFields.owner,
+    area: input.area !== undefined ? input.area : currentFields.area,
+    custom: custom2
+  };
+  const nextMetadata = {
+    ...task.metadata,
+    [LOCAL_FIELDS_KEY]: nextFields
+  };
+  const previousLabels = new Set(currentFields.labels);
+  const nextTags = normalizeList([...task.tags.filter((tag) => !previousLabels.has(tag)), ...labels]);
+  const updates = {
+    version: task.version,
+    priority: input.priority,
+    tags: nextTags,
+    metadata: nextMetadata
+  };
+  if (input.owner !== undefined)
+    updates.assigned_to = nextFields.owner;
+  return updateTask(taskId, updates, d);
+}
+function queryTasksByLocalFields(query, db) {
+  const d = db || getDatabase();
+  const tasks = listTasks({
+    priority: query.priority,
+    tags: query.labels,
+    limit: 1e4
+  }, d);
+  const matches = tasks.filter((task) => {
+    const fields = getTaskLocalFields(task.id, d);
+    if (query.labels && !query.labels.every((label) => fields.labels.includes(label)))
+      return false;
+    if (query.severity && fields.severity !== query.severity)
+      return false;
+    if (query.owner && fields.owner !== query.owner)
+      return false;
+    if (query.area && fields.area !== query.area)
+      return false;
+    if (query.custom) {
+      for (const [key, expected] of Object.entries(query.custom)) {
+        if (!sameCustomValue(fields.custom[key], expected))
+          return false;
+      }
+    }
+    return true;
+  });
+  return matches.slice(0, query.limit || 100);
+}
+var LOCAL_FIELDS_KEY = "local_fields";
+var init_local_fields = __esm(() => {
+  init_database();
+  init_tasks();
+  init_types();
+});
+
 // src/db/task-relationships.ts
 var exports_task_relationships = {};
 __export(exports_task_relationships, {
@@ -6852,6 +7383,347 @@ var init_search = __esm(() => {
   init_database();
 });
 
+// src/lib/saved-search-views.ts
+var exports_saved_search_views = {};
+__export(exports_saved_search_views, {
+  saveSearchView: () => saveSearchView,
+  runSearchView: () => runSearchView,
+  runSavedSearch: () => runSavedSearch,
+  normalizeScope: () => normalizeScope,
+  listSearchViews: () => listSearchViews,
+  getSearchView: () => getSearchView,
+  deleteSearchView: () => deleteSearchView
+});
+function parseFilters(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rowToSavedSearchView(row) {
+  return {
+    ...row,
+    scope: normalizeScope(row.scope),
+    filters: parseFilters(row.filters)
+  };
+}
+function normalizeScope(scope) {
+  if (scope === "all" || scope === "tasks" || scope === "projects" || scope === "plans" || scope === "runs" || scope === "comments") {
+    return scope;
+  }
+  return "tasks";
+}
+function normalizeName(name) {
+  const normalized = name.trim();
+  if (!normalized)
+    throw new Error("Saved view name is required");
+  return normalized;
+}
+function normalizeLimit(limit) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0)
+    return 100;
+  return Math.min(Math.trunc(limit), 1000);
+}
+function valuesList(value) {
+  if (value === undefined)
+    return [];
+  return (Array.isArray(value) ? value : [value]).map((item) => item.trim()).filter(Boolean);
+}
+function addStatusFilter(sql, params, column, value) {
+  const values = valuesList(value);
+  if (values.length === 0)
+    return sql;
+  params.push(...values);
+  return `${sql} AND ${column} IN (${values.map(() => "?").join(",")})`;
+}
+function addDateFilter(sql, params, column, value) {
+  if (!value)
+    return sql;
+  params.push(value);
+  return `${sql} AND ${column} > ?`;
+}
+function likePattern(query) {
+  const trimmed = query?.trim();
+  if (!trimmed || trimmed === "*")
+    return null;
+  return `%${trimmed}%`;
+}
+function parseJsonObject(value) {
+  if (!value)
+    return {};
+  if (typeof value === "object" && !Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rowToTaskRun(row) {
+  return { ...row, metadata: parseJsonObject(row.metadata) };
+}
+function taskMatchesSavedFilters(task, filters, db) {
+  if (filters.plan_id && task.plan_id !== filters.plan_id)
+    return false;
+  if (filters.tags && !filters.tags.every((tag) => task.tags.includes(tag)))
+    return false;
+  if (filters.depends_on) {
+    const row = db.query("SELECT 1 FROM task_dependencies WHERE task_id = ? AND depends_on = ?").get(task.id, filters.depends_on);
+    if (!row)
+      return false;
+  }
+  if (filters.blocks) {
+    const row = db.query("SELECT 1 FROM task_dependencies WHERE task_id = ? AND depends_on = ?").get(filters.blocks, task.id);
+    if (!row)
+      return false;
+  }
+  return true;
+}
+function searchTaskEntities(filters, db) {
+  let tasks;
+  if (filters.local_fields) {
+    const localMatches = queryTasksByLocalFields({ ...filters.local_fields, limit: 1e4 }, db);
+    const allowedIds = new Set(localMatches.map((task) => task.id));
+    tasks = searchTasks({
+      query: filters.query,
+      project_id: filters.project_id,
+      task_list_id: filters.task_list_id,
+      status: filters.status,
+      priority: filters.priority,
+      assigned_to: filters.assigned_to,
+      agent_id: filters.agent_id,
+      created_after: filters.created_after,
+      updated_after: filters.updated_after,
+      has_dependencies: filters.has_dependencies,
+      is_blocked: filters.is_blocked
+    }, undefined, undefined, db).filter((task) => allowedIds.has(task.id));
+  } else {
+    tasks = searchTasks({
+      query: filters.query,
+      project_id: filters.project_id,
+      task_list_id: filters.task_list_id,
+      status: filters.status,
+      priority: filters.priority,
+      assigned_to: filters.assigned_to,
+      agent_id: filters.agent_id,
+      created_after: filters.created_after,
+      updated_after: filters.updated_after,
+      has_dependencies: filters.has_dependencies,
+      is_blocked: filters.is_blocked
+    }, undefined, undefined, db);
+  }
+  return tasks.filter((task) => taskMatchesSavedFilters(task, filters, db)).slice(0, normalizeLimit(filters.limit));
+}
+function searchProjects(filters, db) {
+  const params = [];
+  let sql = "SELECT * FROM projects WHERE 1=1";
+  if (filters.project_id) {
+    sql += " AND id = ?";
+    params.push(filters.project_id);
+  }
+  const pattern = likePattern(filters.query);
+  if (pattern) {
+    sql += " AND (name LIKE ? OR description LIKE ? OR path LIKE ?)";
+    params.push(pattern, pattern, pattern);
+  }
+  sql = addDateFilter(sql, params, "created_at", filters.created_after);
+  sql = addDateFilter(sql, params, "updated_at", filters.updated_after);
+  sql += " ORDER BY name LIMIT ?";
+  params.push(normalizeLimit(filters.limit));
+  return db.query(sql).all(...params);
+}
+function searchPlans(filters, db) {
+  const params = [];
+  let sql = "SELECT * FROM plans WHERE 1=1";
+  if (filters.project_id) {
+    sql += " AND project_id = ?";
+    params.push(filters.project_id);
+  }
+  if (filters.task_list_id) {
+    sql += " AND task_list_id = ?";
+    params.push(filters.task_list_id);
+  }
+  if (filters.agent_id) {
+    sql += " AND agent_id = ?";
+    params.push(filters.agent_id);
+  }
+  sql = addStatusFilter(sql, params, "status", filters.status);
+  const pattern = likePattern(filters.query);
+  if (pattern) {
+    sql += " AND (name LIKE ? OR description LIKE ?)";
+    params.push(pattern, pattern);
+  }
+  sql = addDateFilter(sql, params, "created_at", filters.created_after);
+  sql = addDateFilter(sql, params, "updated_at", filters.updated_after);
+  sql += " ORDER BY updated_at DESC, created_at DESC LIMIT ?";
+  params.push(normalizeLimit(filters.limit));
+  return db.query(sql).all(...params);
+}
+function searchRuns(filters, db) {
+  const params = [];
+  let sql = `SELECT r.* FROM task_runs r
+    JOIN tasks t ON t.id = r.task_id
+    WHERE 1=1`;
+  if (filters.project_id) {
+    sql += " AND t.project_id = ?";
+    params.push(filters.project_id);
+  }
+  if (filters.task_list_id) {
+    sql += " AND t.task_list_id = ?";
+    params.push(filters.task_list_id);
+  }
+  if (filters.plan_id) {
+    sql += " AND t.plan_id = ?";
+    params.push(filters.plan_id);
+  }
+  if (filters.task_id) {
+    sql += " AND r.task_id = ?";
+    params.push(filters.task_id);
+  }
+  if (filters.agent_id) {
+    sql += " AND r.agent_id = ?";
+    params.push(filters.agent_id);
+  }
+  sql = addStatusFilter(sql, params, "r.status", filters.status);
+  const pattern = likePattern(filters.query);
+  if (pattern) {
+    sql += " AND (r.title LIKE ? OR r.summary LIKE ? OR t.title LIKE ?)";
+    params.push(pattern, pattern, pattern);
+  }
+  sql = addDateFilter(sql, params, "r.created_at", filters.created_after);
+  sql = addDateFilter(sql, params, "r.updated_at", filters.updated_after);
+  sql += " ORDER BY r.started_at DESC, r.created_at DESC LIMIT ?";
+  params.push(normalizeLimit(filters.limit));
+  return db.query(sql).all(...params).map(rowToTaskRun);
+}
+function searchComments(filters, db) {
+  const params = [];
+  let sql = `SELECT c.* FROM task_comments c
+    JOIN tasks t ON t.id = c.task_id
+    WHERE 1=1`;
+  if (filters.project_id) {
+    sql += " AND t.project_id = ?";
+    params.push(filters.project_id);
+  }
+  if (filters.task_list_id) {
+    sql += " AND t.task_list_id = ?";
+    params.push(filters.task_list_id);
+  }
+  if (filters.plan_id) {
+    sql += " AND t.plan_id = ?";
+    params.push(filters.plan_id);
+  }
+  if (filters.task_id) {
+    sql += " AND c.task_id = ?";
+    params.push(filters.task_id);
+  }
+  if (filters.agent_id) {
+    sql += " AND c.agent_id = ?";
+    params.push(filters.agent_id);
+  }
+  const pattern = likePattern(filters.query);
+  if (pattern) {
+    sql += " AND (c.content LIKE ? OR t.title LIKE ?)";
+    params.push(pattern, pattern);
+  }
+  sql = addDateFilter(sql, params, "c.created_at", filters.created_after);
+  sql += " ORDER BY c.created_at DESC, c.id LIMIT ?";
+  params.push(normalizeLimit(filters.limit));
+  return db.query(sql).all(...params);
+}
+function toResults(entityType, rows) {
+  return rows.map((entity) => ({ entity_type: entityType, entity }));
+}
+function runSavedSearch(filters = {}, scope = "tasks", db) {
+  const d = db || getDatabase();
+  const normalizedScope = normalizeScope(scope);
+  const scopes = normalizedScope === "all" ? ["tasks", "projects", "plans", "runs", "comments"] : [normalizedScope];
+  const results = [];
+  for (const item of scopes) {
+    if (item === "tasks")
+      results.push(...toResults("tasks", searchTaskEntities(filters, d)));
+    if (item === "projects")
+      results.push(...toResults("projects", searchProjects(filters, d)));
+    if (item === "plans")
+      results.push(...toResults("plans", searchPlans(filters, d)));
+    if (item === "runs")
+      results.push(...toResults("runs", searchRuns(filters, d)));
+    if (item === "comments")
+      results.push(...toResults("comments", searchComments(filters, d)));
+  }
+  return {
+    scope: normalizedScope,
+    filters,
+    count: results.length,
+    results: results.slice(0, normalizeLimit(filters.limit))
+  };
+}
+function saveSearchView(input, db) {
+  const d = db || getDatabase();
+  const name = normalizeName(input.name);
+  const timestamp = now();
+  const existing = getSearchView(name, d);
+  if (existing) {
+    d.run(`UPDATE saved_search_views
+       SET description = ?, scope = ?, filters = ?, updated_at = ?
+       WHERE id = ?`, [
+      input.description ?? existing.description,
+      normalizeScope(input.scope ?? existing.scope),
+      JSON.stringify(input.filters ?? existing.filters),
+      timestamp,
+      existing.id
+    ]);
+    return getSearchView(existing.id, d);
+  }
+  const id = uuid();
+  d.run(`INSERT INTO saved_search_views (id, name, description, scope, filters, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    name,
+    input.description ?? null,
+    normalizeScope(input.scope),
+    JSON.stringify(input.filters ?? {}),
+    timestamp,
+    timestamp
+  ]);
+  return getSearchView(id, d);
+}
+function getSearchView(idOrName, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM saved_search_views WHERE id = ? OR name = ?").get(idOrName, idOrName);
+  return row ? rowToSavedSearchView(row) : null;
+}
+function listSearchViews(scope, db) {
+  const d = db || getDatabase();
+  const normalizedScope = scope ? normalizeScope(scope) : null;
+  const rows = normalizedScope ? d.query("SELECT * FROM saved_search_views WHERE scope = ? ORDER BY name").all(normalizedScope) : d.query("SELECT * FROM saved_search_views ORDER BY name").all();
+  return rows.map(rowToSavedSearchView);
+}
+function deleteSearchView(idOrName, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM saved_search_views WHERE id = ? OR name = ?", [idOrName, idOrName]);
+  return result.changes > 0;
+}
+function runSearchView(idOrName, db) {
+  const d = db || getDatabase();
+  const view = getSearchView(idOrName, d);
+  if (!view)
+    throw new Error(`Saved search view not found: ${idOrName}`);
+  return { ...runSavedSearch(view.filters, view.scope, d), view };
+}
+var init_saved_search_views = __esm(() => {
+  init_database();
+  init_local_fields();
+  init_search();
+});
+
 // src/db/handoffs.ts
 var exports_handoffs = {};
 __export(exports_handoffs, {
@@ -8869,6 +9741,279 @@ var init_extract = __esm(() => {
   ]);
 });
 
+// src/db/builtin-templates.ts
+var exports_builtin_templates = {};
+__export(exports_builtin_templates, {
+  writeBuiltinTemplateFiles: () => writeBuiltinTemplateFiles,
+  listBuiltinTemplates: () => listBuiltinTemplates,
+  initBuiltinTemplates: () => initBuiltinTemplates,
+  getBuiltinTemplate: () => getBuiltinTemplate,
+  exportBuiltinTemplateFiles: () => exportBuiltinTemplateFiles,
+  exportBuiltinTemplate: () => exportBuiltinTemplate,
+  BUILTIN_TEMPLATE_LIBRARY_VERSION: () => BUILTIN_TEMPLATE_LIBRARY_VERSION,
+  BUILTIN_TEMPLATE_LIBRARY_SOURCE: () => BUILTIN_TEMPLATE_LIBRARY_SOURCE,
+  BUILTIN_TEMPLATES: () => BUILTIN_TEMPLATES
+});
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+function templateMetadata(template) {
+  return {
+    source: BUILTIN_TEMPLATE_LIBRARY_SOURCE,
+    library_version: template.version,
+    category: template.category,
+    template_file: `${template.name}.json`,
+    local_only: true,
+    marketplace_free: true
+  };
+}
+function listBuiltinTemplates() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    ...template,
+    variables: template.variables.map((variable) => ({ ...variable })),
+    tasks: template.tasks.map((task) => ({ ...task, tags: task.tags ? [...task.tags] : undefined }))
+  }));
+}
+function getBuiltinTemplate(name) {
+  return listBuiltinTemplates().find((template) => template.name === name) ?? null;
+}
+function exportBuiltinTemplate(name) {
+  const template = getBuiltinTemplate(name);
+  if (!template)
+    throw new Error(`Built-in template not found: ${name}`);
+  return {
+    name: template.name,
+    title_pattern: `${template.name}: {${template.variables[0]?.name ?? "name"}}`,
+    description: template.description,
+    priority: "medium",
+    tags: [template.category, "local-template"],
+    variables: template.variables,
+    project_id: null,
+    plan_id: null,
+    metadata: templateMetadata(template),
+    tasks: template.tasks.map((task) => ({
+      position: task.position,
+      title_pattern: task.title_pattern,
+      description: task.description ?? null,
+      priority: task.priority ?? "medium",
+      tags: task.tags ?? [template.category],
+      task_type: task.task_type ?? null,
+      condition: task.condition ?? null,
+      include_template_id: task.include_template_id ?? null,
+      depends_on_positions: task.depends_on_positions ?? task.depends_on ?? [],
+      metadata: task.metadata ?? { category: template.category }
+    }))
+  };
+}
+function exportBuiltinTemplateFiles() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    filename: `${template.name}.json`,
+    template: exportBuiltinTemplate(template.name)
+  }));
+}
+function writeBuiltinTemplateFiles(directory) {
+  mkdirSync6(directory, { recursive: true });
+  const files = [];
+  for (const entry of exportBuiltinTemplateFiles()) {
+    const path = join6(directory, entry.filename);
+    writeFileSync3(path, `${JSON.stringify(entry.template, null, 2)}
+`, "utf-8");
+    files.push(path);
+  }
+  return { directory, written: files.length, files };
+}
+function initBuiltinTemplates(db) {
+  const d = db || getDatabase();
+  const existing = listTemplates(d);
+  const existingNames = new Set(existing.map((t) => t.name));
+  let created = 0;
+  let skipped = 0;
+  const names = [];
+  for (const bt of BUILTIN_TEMPLATES) {
+    if (existingNames.has(bt.name)) {
+      skipped++;
+      continue;
+    }
+    const tasks = bt.tasks.map((t) => ({
+      title_pattern: t.title_pattern,
+      description: t.description,
+      priority: t.priority,
+      tags: t.tags,
+      task_type: t.task_type,
+      depends_on: t.depends_on_positions || t.depends_on,
+      metadata: t.metadata
+    }));
+    createTemplate({
+      name: bt.name,
+      title_pattern: `${bt.name}: {${bt.variables[0]?.name || "name"}}`,
+      description: bt.description,
+      tags: [bt.category, "local-template"],
+      variables: bt.variables,
+      metadata: templateMetadata(bt),
+      tasks
+    }, d);
+    created++;
+    names.push(bt.name);
+  }
+  return { created, skipped, names };
+}
+var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21", BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library", BUILTIN_TEMPLATES;
+var init_builtin_templates = __esm(() => {
+  init_database();
+  init_templates();
+  BUILTIN_TEMPLATES = [
+    {
+      name: "bug-fix",
+      description: "Reproduce, diagnose, fix, test, and release a defect.",
+      category: "bug-fix",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "bug", required: true, description: "Bug description" }],
+      tasks: [
+        { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical", tags: ["bug", "repro"] },
+        { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", tags: ["bug", "diagnosis"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Write regression test for {bug}", priority: "high", tags: ["bug", "test"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Implement fix for {bug}", priority: "critical", tags: ["bug", "implementation"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Run full verification for {bug}", priority: "high", tags: ["bug", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Publish and smoke test fix for {bug}", priority: "high", tags: ["bug", "release"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "feature-implementation",
+      description: "Plan, build, test, document, and release a product feature.",
+      category: "feature",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [
+        { name: "feature", required: true, description: "Feature name" },
+        { name: "scope", required: false, default: "medium", description: "Implementation size or risk" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Define acceptance criteria for {feature}", priority: "high", tags: ["feature", "spec"] },
+        { position: 1, title_pattern: "Design {scope} implementation plan for {feature}", priority: "high", tags: ["feature", "design"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement {feature}", priority: "critical", tags: ["feature", "implementation"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Add tests for {feature}", priority: "high", tags: ["feature", "test"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Update docs for {feature}", priority: "medium", tags: ["feature", "docs"], depends_on_positions: [2] },
+        { position: 5, title_pattern: "Run release checks for {feature}", priority: "high", tags: ["feature", "verification"], depends_on_positions: [3, 4] }
+      ]
+    },
+    {
+      name: "security-review",
+      description: "Threat model, test, remediate, and report on security posture.",
+      category: "security",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "target", required: true, description: "System, package, or change under review" }],
+      tasks: [
+        { position: 0, title_pattern: "Map trust boundaries for {target}", priority: "critical", tags: ["security", "threat-model"] },
+        { position: 1, title_pattern: "Scan {target} for vulnerabilities and secret exposure", priority: "critical", tags: ["security", "scan"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Review authz, data access, and dependency risks in {target}", priority: "critical", tags: ["security", "review"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Fix critical security findings in {target}", priority: "critical", tags: ["security", "fix"], depends_on_positions: [1, 2] },
+        { position: 4, title_pattern: "Retest {target} security fixes", priority: "high", tags: ["security", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Write local security review report for {target}", priority: "medium", tags: ["security", "report"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "release",
+      description: "Prepare, verify, publish, install, and smoke test a package release.",
+      category: "release",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [
+        { name: "package", required: true, description: "Package name" },
+        { name: "version", required: false, default: "patch", description: "Release version or bump type" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Prepare {package} {version} release notes", priority: "medium", tags: ["release", "docs"] },
+        { position: 1, title_pattern: "Run full tests for {package}", priority: "critical", tags: ["release", "test"] },
+        { position: 2, title_pattern: "Run build and release verification for {package}", priority: "critical", tags: ["release", "verification"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Scan {package} release diff for secrets", priority: "critical", tags: ["release", "security"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Publish {package} {version}", priority: "high", tags: ["release", "publish"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Install and smoke test published {package}", priority: "high", tags: ["release", "smoke"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "migration",
+      description: "Plan, test, apply, and verify a schema or data migration.",
+      category: "migration",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "migration", required: true, description: "Migration name or objective" }],
+      tasks: [
+        { position: 0, title_pattern: "Design migration plan for {migration}", priority: "critical", tags: ["migration", "plan"] },
+        { position: 1, title_pattern: "Write rollback plan for {migration}", priority: "critical", tags: ["migration", "rollback"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement migration {migration}", priority: "critical", tags: ["migration", "implementation"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Test migration {migration} on fixture data", priority: "high", tags: ["migration", "test"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Run migration {migration} verification and drift checks", priority: "high", tags: ["migration", "verification"], depends_on_positions: [1, 3] },
+        { position: 5, title_pattern: "Document migration {migration} evidence", priority: "medium", tags: ["migration", "docs"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "incident",
+      description: "Triage, mitigate, repair, verify, and retrospect an incident.",
+      category: "incident",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "incident", required: true, description: "Incident summary" }],
+      tasks: [
+        { position: 0, title_pattern: "Triage incident: {incident}", priority: "critical", tags: ["incident", "triage"] },
+        { position: 1, title_pattern: "Mitigate customer impact for {incident}", priority: "critical", tags: ["incident", "mitigation"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Diagnose root cause for {incident}", priority: "critical", tags: ["incident", "diagnosis"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "Implement durable repair for {incident}", priority: "critical", tags: ["incident", "repair"], depends_on_positions: [2] },
+        { position: 4, title_pattern: "Verify recovery from {incident}", priority: "high", tags: ["incident", "verification"], depends_on_positions: [1, 3] },
+        { position: 5, title_pattern: "Write retrospective for {incident}", priority: "medium", tags: ["incident", "retro"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "docs-refresh",
+      description: "Audit, update, validate, and publish documentation changes.",
+      category: "docs",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "area", required: true, description: "Documentation area or product surface" }],
+      tasks: [
+        { position: 0, title_pattern: "Audit current docs for {area}", priority: "medium", tags: ["docs", "audit"] },
+        { position: 1, title_pattern: "Update examples and commands for {area}", priority: "medium", tags: ["docs", "examples"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Validate docs snippets for {area}", priority: "high", tags: ["docs", "verification"], depends_on_positions: [1] },
+        { position: 3, title_pattern: "Refresh screenshots or generated artifacts for {area}", priority: "medium", tags: ["docs", "assets"], depends_on_positions: [1] },
+        { position: 4, title_pattern: "Publish docs refresh for {area}", priority: "medium", tags: ["docs", "release"], depends_on_positions: [2, 3] }
+      ]
+    },
+    {
+      name: "qa",
+      description: "Build a focused QA plan, execute checks, file defects, and sign off.",
+      category: "qa",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [{ name: "target", required: true, description: "Feature, release, or workflow under QA" }],
+      tasks: [
+        { position: 0, title_pattern: "Create QA matrix for {target}", priority: "high", tags: ["qa", "plan"] },
+        { position: 1, title_pattern: "Run happy-path QA for {target}", priority: "high", tags: ["qa", "manual"], depends_on_positions: [0] },
+        { position: 2, title_pattern: "Run edge-case QA for {target}", priority: "high", tags: ["qa", "edge-cases"], depends_on_positions: [0] },
+        { position: 3, title_pattern: "File and dedupe QA defects for {target}", priority: "medium", tags: ["qa", "bugs"], depends_on_positions: [1, 2] },
+        { position: 4, title_pattern: "Verify QA fixes for {target}", priority: "high", tags: ["qa", "verification"], depends_on_positions: [3] },
+        { position: 5, title_pattern: "Record QA signoff for {target}", priority: "medium", tags: ["qa", "signoff"], depends_on_positions: [4] }
+      ]
+    },
+    {
+      name: "open-source-project",
+      description: "Full open-source project bootstrap \u2014 scaffold to publish",
+      category: "open-source",
+      version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+      variables: [
+        { name: "name", required: true, description: "Service name" },
+        { name: "org", required: false, default: "hasna", description: "GitHub org" }
+      ],
+      tasks: [
+        { position: 0, title_pattern: "Scaffold {name} package structure", priority: "critical" },
+        { position: 1, title_pattern: "Create {name} SQLite database + migrations", priority: "critical", depends_on_positions: [0] },
+        { position: 2, title_pattern: "Implement {name} CRUD operations", priority: "high", depends_on_positions: [1] },
+        { position: 3, title_pattern: "Build {name} MCP server with standard tools", priority: "high", depends_on_positions: [2] },
+        { position: 4, title_pattern: "Build {name} CLI with Commander.js", priority: "high", depends_on_positions: [2] },
+        { position: 5, title_pattern: "Build {name} REST API", priority: "medium", depends_on_positions: [2] },
+        { position: 6, title_pattern: "Write unit tests for {name}", priority: "high", depends_on_positions: [2, 3, 4] },
+        { position: 7, title_pattern: "Add Apache 2.0 license and README", priority: "medium", depends_on_positions: [0] },
+        { position: 8, title_pattern: "Create GitHub repo {org}/{name}", priority: "medium", depends_on_positions: [7] },
+        { position: 9, title_pattern: "Add local backup and restore workflow for {name}", priority: "medium", depends_on_positions: [1] },
+        { position: 10, title_pattern: "Add agent tools (register_agent, heartbeat, set_focus, list_agents)", priority: "medium", depends_on_positions: [3] },
+        { position: 11, title_pattern: "Publish @hasna/{name} to npm", priority: "high", depends_on_positions: [6, 7, 8] },
+        { position: 12, title_pattern: "Install @hasna/{name} globally and verify", priority: "medium", depends_on_positions: [11] }
+      ]
+    }
+  ];
+});
+
 // src/mcp/index.ts
 init_agents();
 init_database();
@@ -13169,6 +14314,10 @@ var MCP_TOOL_GROUPS = {
     "request_task_review",
     "reschedule_task",
     "search_tasks",
+    "save_search_view",
+    "list_search_views",
+    "run_search_view",
+    "delete_search_view",
     "standup",
     "set_task_contract",
     "task_context",
@@ -13358,10 +14507,12 @@ var MCP_TOOL_GROUPS = {
     "export_template",
     "import_template",
     "init_templates",
+    "list_template_library",
     "list_templates",
     "preview_template",
     "template_history",
-    "update_template"
+    "update_template",
+    "write_template_library"
   ],
   webhooks: ["create_webhook", "delete_webhook", "list_webhooks"],
   machines: [
@@ -14854,98 +16005,8 @@ function getLocalActivityTimeline(options = {}, db) {
   };
 }
 
-// src/lib/local-fields.ts
-init_database();
-init_tasks();
-init_types();
-var LOCAL_FIELDS_KEY = "local_fields";
-function normalizeList(values) {
-  return [...new Set((values || []).map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
-}
-function metadataFields(task) {
-  const value = task.metadata[LOCAL_FIELDS_KEY];
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function sameCustomValue(actual, expected) {
-  return JSON.stringify(actual) === JSON.stringify(expected);
-}
-function hasOwnField(fields, key) {
-  return Object.prototype.hasOwnProperty.call(fields, key);
-}
-function getTaskLocalFields(taskId, db) {
-  const d = db || getDatabase();
-  const task = getTask(taskId, d);
-  if (!task)
-    throw new TaskNotFoundError(taskId);
-  const fields = metadataFields(task);
-  return {
-    labels: normalizeList(fields.labels),
-    priority: task.priority,
-    severity: typeof fields.severity === "string" ? fields.severity : null,
-    owner: hasOwnField(fields, "owner") ? typeof fields.owner === "string" ? fields.owner : null : task.assigned_to,
-    area: typeof fields.area === "string" ? fields.area : null,
-    custom: fields.custom && typeof fields.custom === "object" && !Array.isArray(fields.custom) ? fields.custom : {}
-  };
-}
-function setTaskLocalFields(taskId, input, db) {
-  const d = db || getDatabase();
-  const task = getTask(taskId, d);
-  if (!task)
-    throw new TaskNotFoundError(taskId);
-  const currentFields = getTaskLocalFields(taskId, d);
-  const labels = input.labels !== undefined ? normalizeList(input.labels) : currentFields.labels;
-  const custom2 = input.custom !== undefined ? redactValue(input.merge_custom === false ? input.custom : { ...currentFields.custom, ...input.custom }) : currentFields.custom;
-  const nextFields = {
-    labels,
-    priority: input.priority || task.priority,
-    severity: input.severity !== undefined ? input.severity : currentFields.severity,
-    owner: input.owner !== undefined ? input.owner : currentFields.owner,
-    area: input.area !== undefined ? input.area : currentFields.area,
-    custom: custom2
-  };
-  const nextMetadata = {
-    ...task.metadata,
-    [LOCAL_FIELDS_KEY]: nextFields
-  };
-  const previousLabels = new Set(currentFields.labels);
-  const nextTags = normalizeList([...task.tags.filter((tag) => !previousLabels.has(tag)), ...labels]);
-  const updates = {
-    version: task.version,
-    priority: input.priority,
-    tags: nextTags,
-    metadata: nextMetadata
-  };
-  if (input.owner !== undefined)
-    updates.assigned_to = nextFields.owner;
-  return updateTask(taskId, updates, d);
-}
-function queryTasksByLocalFields(query, db) {
-  const d = db || getDatabase();
-  const tasks = listTasks({
-    priority: query.priority,
-    tags: query.labels,
-    limit: 1e4
-  }, d);
-  const matches = tasks.filter((task) => {
-    const fields = getTaskLocalFields(task.id, d);
-    if (query.labels && !query.labels.every((label) => fields.labels.includes(label)))
-      return false;
-    if (query.severity && fields.severity !== query.severity)
-      return false;
-    if (query.owner && fields.owner !== query.owner)
-      return false;
-    if (query.area && fields.area !== query.area)
-      return false;
-    if (query.custom) {
-      for (const [key, expected] of Object.entries(query.custom)) {
-        if (!sameCustomValue(fields.custom[key], expected))
-          return false;
-      }
-    }
-    return true;
-  });
-  return matches.slice(0, query.limit || 100);
-}
+// src/mcp/tools/task-project-tools.ts
+init_local_fields();
 
 // src/lib/task-dedupe.ts
 init_audit();
@@ -16737,6 +17798,76 @@ ${lines.join(`
       }
     });
   }
+  if (shouldRegisterTool("save_search_view")) {
+    server.tool("save_search_view", "Save a local search view for tasks, projects, plans, runs, comments, or all records.", {
+      name: exports_external.string().describe("Saved view name"),
+      query: exports_external.string().optional().describe("Search query"),
+      scope: exports_external.enum(["all", "tasks", "projects", "plans", "runs", "comments"]).optional(),
+      description: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      status: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+      priority: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+      assigned_to: exports_external.string().optional(),
+      agent_id: exports_external.string().optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      limit: exports_external.number().optional()
+    }, async ({ name, scope, description, ...filters }) => {
+      try {
+        const { saveSearchView: saveSearchView2 } = (init_saved_search_views(), __toCommonJS(exports_saved_search_views));
+        const view = saveSearchView2({
+          name,
+          description,
+          scope,
+          filters: {
+            ...filters,
+            project_id: filters.project_id ? resolveId(filters.project_id, "projects") : undefined
+          }
+        });
+        return { content: [{ type: "text", text: JSON.stringify(view, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_search_views")) {
+    server.tool("list_search_views", "List local saved search views.", {
+      scope: exports_external.enum(["all", "tasks", "projects", "plans", "runs", "comments"]).optional()
+    }, async ({ scope }) => {
+      try {
+        const { listSearchViews: listSearchViews2 } = (init_saved_search_views(), __toCommonJS(exports_saved_search_views));
+        const views = listSearchViews2(scope);
+        return { content: [{ type: "text", text: JSON.stringify(views, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("run_search_view")) {
+    server.tool("run_search_view", "Run a local saved search view and return stable JSON results.", {
+      name: exports_external.string().describe("Saved view name or id")
+    }, async ({ name }) => {
+      try {
+        const { runSearchView: runSearchView2 } = (init_saved_search_views(), __toCommonJS(exports_saved_search_views));
+        const result = runSearchView2(name);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("delete_search_view")) {
+    server.tool("delete_search_view", "Delete a local saved search view.", {
+      name: exports_external.string().describe("Saved view name or id")
+    }, async ({ name }) => {
+      try {
+        const { deleteSearchView: deleteSearchView2 } = (init_saved_search_views(), __toCommonJS(exports_saved_search_views));
+        const deleted = deleteSearchView2(name);
+        return { content: [{ type: "text", text: JSON.stringify({ deleted }, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
 }
 
 // src/mcp/tools/task-workflow-tools.ts
@@ -17828,6 +18959,10 @@ function registerTaskMetaTools(server, ctx) {
           reschedule_task: "reschedule_task \u2014 Update deadline. Params: task_id, deadline, version",
           prioritize_task: "prioritize_task \u2014 Set priority. Params: task_id, priority, version",
           search_tasks: "search_tasks \u2014 Full-text search. Params: query, project_id, status, limit",
+          save_search_view: "save_search_view \u2014 Save a local search view across tasks, projects, plans, runs, comments, or all records. Params: name, query, scope, description, project_id, status, priority, assigned_to, agent_id, tags, limit",
+          list_search_views: "list_search_views \u2014 List local saved search views. Params: scope",
+          run_search_view: "run_search_view \u2014 Run a local saved search view and return stable JSON results. Params: name",
+          delete_search_view: "delete_search_view \u2014 Delete a local saved search view. Params: name",
           get_my_tasks: "get_my_tasks \u2014 Get tasks for calling agent. Params: agent_id, status, project_id, limit",
           get_next_task: "get_next_task \u2014 Get the next available task without claiming it. Params: agent_id, project_id, task_list_id, plan_id, tags",
           claim_next_task: "claim_next_task \u2014 Atomically claim and start the next available task. Params: agent_id, project_id, task_list_id, plan_id, tags, steal_stale, stale_minutes",
@@ -18158,7 +19293,7 @@ var DEFAULT_CAPABILITIES = {
   browser: ["browser", "screenshot", "artifact", "evidence"],
   script: ["script", "command", "retry", "evidence"]
 };
-function normalizeName(name) {
+function normalizeName2(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
     throw new Error("verification provider name must use lowercase letters, numbers, dashes, or underscores");
@@ -18177,10 +19312,10 @@ function timeoutMs(value) {
   return Math.max(1, Math.min(24 * 60 * 60000, Math.floor(value)));
 }
 function getProvider(name) {
-  return loadConfig().verification_providers?.[normalizeName(name)] || null;
+  return loadConfig().verification_providers?.[normalizeName2(name)] || null;
 }
 function upsertVerificationProvider(input) {
-  const name = normalizeName(input.name);
+  const name = normalizeName2(input.name);
   const config = loadConfig();
   const existing = config.verification_providers?.[name];
   const timestamp = new Date().toISOString();
@@ -18210,7 +19345,7 @@ function listVerificationProviders() {
   return Object.values(loadConfig().verification_providers || {}).sort((a, b) => a.name.localeCompare(b.name));
 }
 function removeVerificationProvider(name) {
-  const normalized = normalizeName(name);
+  const normalized = normalizeName2(name);
   const config = loadConfig();
   if (!config.verification_providers?.[normalized])
     return false;
@@ -20468,15 +21603,265 @@ ID: ${updated.id}${taskNote}`
   }
 }
 
+// src/mcp/tools/templates.ts
+init_tasks();
+function registerTemplateTools(server, { shouldRegisterTool, resolveId, formatError }) {
+  if (shouldRegisterTool("create_template")) {
+    server.tool("create_template", "Create a reusable task template. Optionally include a tasks array to define a multi-task template with dependencies and variable placeholders ({name} syntax). Use variables to define typed variable definitions with defaults and required flags.", {
+      name: exports_external.string(),
+      title_pattern: exports_external.string(),
+      description: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      project_id: exports_external.string().optional(),
+      plan_id: exports_external.string().optional(),
+      variables: exports_external.array(exports_external.object({
+        name: exports_external.string().describe("Variable name (used as {name} in patterns)"),
+        required: exports_external.boolean().describe("Whether this variable must be provided"),
+        default: exports_external.string().optional().describe("Default value if not provided"),
+        description: exports_external.string().optional().describe("Help text for the variable")
+      })).optional().describe("Typed variable definitions with defaults and required flags"),
+      tasks: exports_external.array(exports_external.object({
+        title_pattern: exports_external.string().describe("Title pattern with optional {variable} placeholders"),
+        description: exports_external.string().optional(),
+        priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+        tags: exports_external.array(exports_external.string()).optional(),
+        task_type: exports_external.string().optional(),
+        depends_on: exports_external.array(exports_external.number()).optional().describe("Position indices (0-based) of tasks this task depends on"),
+        metadata: exports_external.record(exports_external.unknown()).optional()
+      })).optional().describe("Multi-task template: ordered list of tasks to create together with dependencies")
+    }, async (params) => {
+      try {
+        const { createTemplate: createTemplate2, getTemplateWithTasks: getTemplateWithTasks2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const t = createTemplate2(params);
+        const withTasks = getTemplateWithTasks2(t.id);
+        const taskCount = withTasks?.tasks.length ?? 0;
+        const taskInfo = taskCount > 0 ? ` | ${taskCount} task(s)` : "";
+        return { content: [{ type: "text", text: `Template created: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}"${taskInfo}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_templates")) {
+    server.tool("list_templates", "List all task templates", {}, async () => {
+      try {
+        const { listTemplates: listTemplates2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const templates = listTemplates2();
+        if (templates.length === 0)
+          return { content: [{ type: "text", text: "No templates." }] };
+        const text = templates.map((t) => {
+          const vars = t.variables.length > 0 ? ` | vars: ${t.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")}` : "";
+          return `${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}${vars}`;
+        }).join(`
+`);
+        return { content: [{ type: "text", text: `${templates.length} template(s):
+${text}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("create_task_from_template")) {
+    server.tool("create_task_from_template", "Create task(s) from a template. For multi-task templates, creates all tasks with dependencies wired. Supports {variable} substitution in titles/descriptions.", {
+      template_id: exports_external.string(),
+      title: exports_external.string().optional().describe("Override title (single-task templates only)"),
+      description: exports_external.string().optional().describe("Override description (single-task templates only)"),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      assigned_to: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      task_list_id: exports_external.string().optional(),
+      variables: exports_external.record(exports_external.string()).optional().describe("Variable substitution map for {name} placeholders in multi-task templates")
+    }, async (params) => {
+      try {
+        const { taskFromTemplate: taskFromTemplate2, getTemplateWithTasks: getTemplateWithTasks2, tasksFromTemplate: tasksFromTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedTemplateId = resolveId(params.template_id, "task_templates");
+        const resolvedProjectId = params.project_id ? resolveId(params.project_id, "projects") : undefined;
+        const resolvedTaskListId = params.task_list_id ? resolveId(params.task_list_id, "task_lists") : undefined;
+        const templateWithTasks = getTemplateWithTasks2(resolvedTemplateId);
+        if (templateWithTasks && templateWithTasks.tasks.length > 0) {
+          const effectiveProjectId = resolvedProjectId || templateWithTasks.project_id || undefined;
+          const tasks = tasksFromTemplate2(resolvedTemplateId, effectiveProjectId, params.variables, resolvedTaskListId);
+          const text = tasks.map((t) => `${t.id.slice(0, 8)} | ${t.priority} | ${t.title}`).join(`
+`);
+          return { content: [{ type: "text", text: `${tasks.length} task(s) created from template:
+${text}` }] };
+        }
+        const input = taskFromTemplate2(resolvedTemplateId, {
+          title: params.title,
+          description: params.description,
+          priority: params.priority,
+          assigned_to: params.assigned_to,
+          project_id: resolvedProjectId,
+          task_list_id: resolvedTaskListId
+        });
+        const task = createTask(input);
+        return { content: [{ type: "text", text: `Task created from template:
+${task.id.slice(0, 8)} | ${task.priority} | ${task.title}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("delete_template")) {
+    server.tool("delete_template", "Delete a task template by ID.", { id: exports_external.string() }, async ({ id }) => {
+      try {
+        const { deleteTemplate: deleteTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(id, "task_templates");
+        const deleted = deleteTemplate2(resolvedId);
+        return { content: [{ type: "text", text: deleted ? "Template deleted." : "Template not found." }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("update_template")) {
+    server.tool("update_template", "Update a task template's name, title pattern, description, priority, tags, or other fields.", {
+      id: exports_external.string(),
+      name: exports_external.string().optional(),
+      title_pattern: exports_external.string().optional(),
+      description: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      project_id: exports_external.string().optional(),
+      plan_id: exports_external.string().optional()
+    }, async ({ id, ...updates }) => {
+      try {
+        const { updateTemplate: updateTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(id, "task_templates");
+        const t = updateTemplate2(resolvedId, updates);
+        if (!t)
+          return { content: [{ type: "text", text: `Template not found: ${id}` }], isError: true };
+        return { content: [{ type: "text", text: `Template updated: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}" | ${t.priority}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("init_templates")) {
+    server.tool("init_templates", "Initialize the bundled local template library. Skips templates that already exist by name.", {}, async () => {
+      try {
+        const { initBuiltinTemplates: initBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        const result = initBuiltinTemplates2();
+        if (result.created === 0)
+          return { content: [{ type: "text", text: `All ${result.skipped} built-in template(s) already exist.` }] };
+        return { content: [{ type: "text", text: `Created ${result.created} template(s): ${result.names.join(", ")}. Skipped ${result.skipped} existing.` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_template_library")) {
+    server.tool("list_template_library", "List the bundled marketplace-free local template library without mutating the database.", {}, async () => {
+      try {
+        const { listBuiltinTemplates: listBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        const templates = listBuiltinTemplates2().map((template) => ({
+          name: template.name,
+          description: template.description,
+          category: template.category,
+          version: template.version,
+          variables: template.variables,
+          task_count: template.tasks.length
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(templates, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("write_template_library")) {
+    server.tool("write_template_library", "Write the bundled local template library to editable JSON files for review or import.", { directory: exports_external.string() }, async ({ directory }) => {
+      try {
+        const { writeBuiltinTemplateFiles: writeBuiltinTemplateFiles2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+        return { content: [{ type: "text", text: JSON.stringify(writeBuiltinTemplateFiles2(directory), null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("preview_template")) {
+    server.tool("preview_template", "Preview a template without creating tasks. Shows resolved titles (variables substituted), dependencies, and priorities.", {
+      template_id: exports_external.string(),
+      variables: exports_external.record(exports_external.string()).optional().describe("Variable substitution map for {name} placeholders")
+    }, async (params) => {
+      try {
+        const { previewTemplate: previewTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(params.template_id, "task_templates");
+        const preview = previewTemplate2(resolvedId, params.variables);
+        const lines = preview.tasks.map((t) => {
+          const deps = t.depends_on_positions.length > 0 ? ` (after: ${t.depends_on_positions.join(", ")})` : "";
+          return `  [${t.position}] ${t.priority} | ${t.title}${deps}`;
+        });
+        const varsInfo = preview.variables.length > 0 ? `
+Variables: ${preview.variables.map((v) => `${v.name}${v.required ? "*" : ""}${v.default ? `=${v.default}` : ""}`).join(", ")}` : "";
+        const resolvedVars = Object.keys(preview.resolved_variables).length > 0 ? `
+Resolved: ${Object.entries(preview.resolved_variables).map(([k, v]) => `${k}=${v}`).join(", ")}` : "";
+        return { content: [{ type: "text", text: `Preview: ${preview.template_name} (${preview.tasks.length} tasks)${varsInfo}${resolvedVars}
+${lines.join(`
+`)}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("export_template")) {
+    server.tool("export_template", "Export a template as a full JSON object (template + tasks + variables). Useful for sharing or backup.", { template_id: exports_external.string() }, async ({ template_id }) => {
+      try {
+        const { exportTemplate: exportTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(template_id, "task_templates");
+        const json = exportTemplate2(resolvedId);
+        return { content: [{ type: "text", text: JSON.stringify(json, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("import_template")) {
+    server.tool("import_template", "Import a template from a JSON string (as returned by export_template). Creates new template with new IDs.", { json: exports_external.string().describe("JSON string of the template export") }, async ({ json }) => {
+      try {
+        const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const parsed = JSON.parse(json);
+        const t = importTemplate2(parsed);
+        return { content: [{ type: "text", text: `Template imported: ${t.id.slice(0, 8)} | ${t.name} | "${t.title_pattern}"` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("template_history")) {
+    server.tool("template_history", "Show version history of a template. Each update creates a snapshot of the previous state.", { template_id: exports_external.string() }, async ({ template_id }) => {
+      try {
+        const { listTemplateVersions: listTemplateVersions2, getTemplate: getTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const resolvedId = resolveId(template_id, "task_templates");
+        const template = getTemplate2(resolvedId);
+        if (!template)
+          return { content: [{ type: "text", text: `Template not found: ${template_id}` }], isError: true };
+        const versions = listTemplateVersions2(resolvedId);
+        if (versions.length === 0)
+          return { content: [{ type: "text", text: `${template.name} v${template.version} \u2014 no previous versions.` }] };
+        const lines = versions.map((v) => {
+          const snap = JSON.parse(v.snapshot);
+          return `v${v.version} | ${v.created_at} | ${snap.name} | "${snap.title_pattern}"`;
+        });
+        return { content: [{ type: "text", text: `${template.name} \u2014 current: v${template.version}
+${lines.join(`
+`)}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+
 // src/lib/package-version.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname7, join as join6 } from "path";
+import { dirname as dirname7, join as join7 } from "path";
 import { fileURLToPath } from "url";
 function getPackageVersion(fromUrl = import.meta.url) {
   try {
     let dir = dirname7(fileURLToPath(fromUrl));
     for (let i = 0;i < 5; i++) {
-      const pkgPath = join6(dir, "package.json");
+      const pkgPath = join7(dir, "package.json");
       if (existsSync8(pkgPath)) {
         return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
       }
@@ -20660,6 +22045,7 @@ registerTaskResources(server, toolContext);
 registerTaskRelTools(server, toolContext);
 registerCodeTools(server, toolContext);
 registerAgentTools(server, { ...toolContext, agentFocusMap });
+registerTemplateTools(server, toolContext);
 registerMachineTools(server, { shouldRegisterTool, formatError });
 registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
 async function main() {