@hasna/todos 0.11.41 → 0.11.43

package/dist/cli/index.js

@@ -3083,6 +3083,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);
   `
   ];
 });
@@ -3259,6 +3272,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,
@@ -8884,9 +8908,83 @@ var init_plans = __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 mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } 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) {
+  mkdirSync4(directory, { recursive: true });
+  const files = [];
+  for (const entry of exportBuiltinTemplateFiles()) {
+    const path = join5(directory, entry.filename);
+    writeFileSync2(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);
@@ -8912,7 +9010,9 @@ function initBuiltinTemplates(db) {
       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++;
@@ -8920,14 +9020,141 @@ function initBuiltinTemplates(db) {
   }
   return { created, skipped, names };
 }
-var BUILTIN_TEMPLATES;
+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" }
@@ -8947,45 +9174,6 @@ var init_builtin_templates = __esm(() => {
         { 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] }
       ]
-    },
-    {
-      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] }
-      ]
     }
   ];
 });
@@ -9253,7 +9441,7 @@ function registerPlanTemplateCommands(program2) {
       console.log(`  ${chalk3.dim(t.id.slice(0, 8))} ${chalk3.bold(t.name)} ${chalk3.cyan(`"${t.title_pattern}"`)} ${chalk3.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(async () => {
+  program2.command("template-init").alias("templates-init").description("Initialize the bundled local template library").action(async () => {
     const globalOpts = program2.opts();
     const { initBuiltinTemplates: initBuiltinTemplates2 } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
     const result = initBuiltinTemplates2();
@@ -9267,6 +9455,52 @@ function registerPlanTemplateCommands(program2) {
       console.log(chalk3.green(`Created ${result.created} template(s): ${result.names.join(", ")}. Skipped ${result.skipped} existing.`));
     }
   });
+  program2.command("template-library").alias("templates-library").description("List, show, or write the bundled local template library as editable JSON files").option("--show <name>", "Show one bundled template as JSON").option("--write <dir>", "Write all bundled templates to editable JSON files").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const {
+      exportBuiltinTemplate: exportBuiltinTemplate2,
+      listBuiltinTemplates: listBuiltinTemplates2,
+      writeBuiltinTemplateFiles: writeBuiltinTemplateFiles2
+    } = await Promise.resolve().then(() => (init_builtin_templates(), exports_builtin_templates));
+    try {
+      if (opts.show) {
+        const template = exportBuiltinTemplate2(opts.show);
+        output(template, true);
+        return;
+      }
+      if (opts.write) {
+        const result = writeBuiltinTemplateFiles2(opts.write);
+        if (globalOpts.json) {
+          output(result, true);
+          return;
+        }
+        console.log(chalk3.green(`Wrote ${result.written} editable template file(s) to ${result.directory}`));
+        for (const file of result.files)
+          console.log(chalk3.dim(`  ${file}`));
+        return;
+      }
+      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
+      }));
+      if (globalOpts.json) {
+        output(templates, true);
+        return;
+      }
+      console.log(chalk3.bold(`${templates.length} bundled local template(s):
+`));
+      for (const template of templates) {
+        console.log(`  ${chalk3.bold(template.name)} ${chalk3.dim(`[${template.category}]`)} ${chalk3.yellow(`${template.task_count} tasks`)}`);
+        console.log(chalk3.dim(`    ${template.description}`));
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
   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(async (id, opts) => {
     const globalOpts = program2.opts();
     const { previewTemplate: previewTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
@@ -9432,6 +9666,101 @@ var init_comments = __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 custom = 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
+  };
+  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/lib/search.ts
 var exports_search = {};
 __export(exports_search, {
@@ -9547,17 +9876,358 @@ 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/lib/claude-tasks.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 function getTaskListDir(taskListId) {
-  return join5(HOME, ".claude", "tasks", taskListId);
+  return join6(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join5(dir, filename));
+  return readJsonFile(join6(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join5(dir, `${task.id}.json`), task);
+  writeJsonFile(join6(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -9569,14 +10239,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join5(dir, ".prefix-counter");
+  const path = join6(dir, ".prefix-counter");
   if (!existsSync5(path))
     return 0;
   const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync2(join5(dir, ".prefix-counter"), String(value));
+  writeFileSync3(join6(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -9612,7 +10282,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join5(dir, f);
+    const path = join6(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -9719,7 +10389,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join5(dir, f);
+      const filePath = join6(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -9793,26 +10463,26 @@ var init_claude_tasks = __esm(() => {
 
 // src/lib/agent-tasks.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function getTodosGlobalDir2() {
-  const newDir = join6(HOME, ".hasna", "todos");
-  const legacyDir = join6(HOME, ".todos");
+  const newDir = join7(HOME, ".hasna", "todos");
+  const legacyDir = join7(HOME, ".todos");
   if (!existsSync6(newDir) && existsSync6(legacyDir))
     return legacyDir;
   return newDir;
 }
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join6(getTodosGlobalDir2(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join7(getTodosGlobalDir2(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join6(agentBaseDir(agent), agent, taskListId);
+  return join7(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join6(dir, filename));
+  return readJsonFile(join7(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join6(dir, `${task.id}.json`), task);
+  writeJsonFile(join7(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -9846,7 +10516,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join6(dir, f);
+    const path = join7(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -9939,7 +10609,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join6(dir, f);
+      const filePath = join7(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -10350,7 +11020,7 @@ __export(exports_extract, {
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
 import { readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { relative as relative3, resolve as resolve7, join as join7 } from "path";
+import { relative as relative3, resolve as resolve7, join as join8 } from "path";
 function tagToPriority(tag) {
   switch (tag) {
     case "BUG":
@@ -10422,7 +11092,7 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync3(basePath).isFile() ? basePath : join7(basePath, file);
+    const fullPath = statSync3(basePath).isFile() ? basePath : join8(basePath, file);
     try {
       const source = readFileSync5(fullPath, "utf-8");
       const relPath = statSync3(basePath).isFile() ? relative3(resolve7(basePath, ".."), fullPath) : file;
@@ -10549,8 +11219,8 @@ var init_extract = __esm(() => {
 
 // src/lib/artifact-store.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname6, join as join8, resolve as resolve8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, join as join9, resolve as resolve8 } from "path";
 import { tmpdir } from "os";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
@@ -10562,15 +11232,15 @@ function artifactStoreRoot() {
     return resolve8(process.env["TODOS_ARTIFACTS_DIR"]);
   const dbPath = getDatabasePath();
   if (isInMemoryDb2(dbPath))
-    return join8(tmpdir(), "hasna-todos-artifacts");
-  return join8(dirname6(resolve8(dbPath)), "artifacts");
+    return join9(tmpdir(), "hasna-todos-artifacts");
+  return join9(dirname6(resolve8(dbPath)), "artifacts");
 }
 function artifactStorePath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   if (normalized.includes("..") || normalized.startsWith("/") || normalized.length === 0) {
     throw new Error("Invalid artifact store path");
   }
-  return join8(artifactStoreRoot(), normalized);
+  return join9(artifactStoreRoot(), normalized);
 }
 function sha256(buffer) {
   return createHash2("sha256").update(buffer).digest("hex");
@@ -10628,11 +11298,11 @@ function storeArtifactContent(input) {
       redactionStatus = "redacted";
   }
   const storedSha = sha256(storedBuffer);
-  const relativePath = join8("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
+  const relativePath = join9("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
   const destination = artifactStorePath(relativePath);
   if (!existsSync8(destination)) {
-    mkdirSync4(dirname6(destination), { recursive: true });
-    writeFileSync3(destination, storedBuffer);
+    mkdirSync5(dirname6(destination), { recursive: true });
+    writeFileSync4(destination, storedBuffer);
   }
   const createdAt = input.created_at || new Date().toISOString();
   const retentionDays = input.retention_days ?? null;
@@ -10749,8 +11419,8 @@ function importStoredArtifactContent(content) {
     };
   }
   const destination = artifactStorePath(content.relative_path);
-  mkdirSync4(dirname6(destination), { recursive: true });
-  writeFileSync3(destination, buffer);
+  mkdirSync5(dirname6(destination), { recursive: true });
+  writeFileSync4(destination, buffer);
   return {
     id: content.artifact_id,
     path: content.relative_path,
@@ -10786,7 +11456,7 @@ function packageSource(version) {
 function emptyCounts() {
   return Object.fromEntries(dataKeys.map((key) => [key, 0]));
 }
-function parseJsonObject(value) {
+function parseJsonObject2(value) {
   if (!value)
     return {};
   if (typeof value === "object" && !Array.isArray(value))
@@ -10832,22 +11502,25 @@ function rowToTask3(row) {
   return {
     ...row,
     tags: parseJsonArray(row.tags),
-    metadata: parseJsonObject(row.metadata),
+    metadata: parseJsonObject2(row.metadata),
     requires_approval: Boolean(row.requires_approval)
   };
 }
 function rowToTaskList2(row) {
-  return { ...row, metadata: parseJsonObject(row.metadata) };
+  return { ...row, metadata: parseJsonObject2(row.metadata) };
 }
 function rowWithMetadata(row) {
-  return { ...row, metadata: parseJsonObject(row.metadata) };
+  return { ...row, metadata: parseJsonObject2(row.metadata) };
 }
 function rowToRunEvent(row) {
-  return { ...row, data: parseJsonObject(row.data) };
+  return { ...row, data: parseJsonObject2(row.data) };
 }
 function rowToCommit2(row) {
   return { ...row, files_changed: row.files_changed ? parseJsonArray(row.files_changed) : null };
 }
+function rowToSavedView(row) {
+  return { ...row, filters: parseJsonObject2(row.filters) };
+}
 function bridgeStats(data) {
   return Object.fromEntries(dataKeys.map((key) => [key, data[key].length]));
 }
@@ -10871,7 +11544,8 @@ function createLocalBridgeBundle(options = {}, db) {
     task_files: queryByTaskIds(d, "SELECT * FROM task_files WHERE task_id IN (__TASK_IDS__) ORDER BY path, id", taskIds),
     task_commits: queryByTaskIds(d, "SELECT * FROM task_commits WHERE task_id IN (__TASK_IDS__) ORDER BY created_at, id", taskIds).map(rowToCommit2),
     task_git_refs: queryByTaskIds(d, "SELECT * FROM task_git_refs WHERE task_id IN (__TASK_IDS__) ORDER BY created_at, id", taskIds).map(rowWithMetadata),
-    task_verifications: queryByTaskIds(d, "SELECT * FROM task_verifications WHERE task_id IN (__TASK_IDS__) ORDER BY run_at, id", taskIds)
+    task_verifications: queryByTaskIds(d, "SELECT * FROM task_verifications WHERE task_id IN (__TASK_IDS__) ORDER BY run_at, id", taskIds),
+    saved_views: (options.project_id ? d.query("SELECT * FROM saved_search_views WHERE json_extract(filters, '$.project_id') = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM saved_search_views ORDER BY name").all()).map(rowToSavedView)
   };
   const artifactContents = data.run_artifacts.map((artifact) => exportStoredArtifactContent({
     id: artifact.id,
@@ -10910,6 +11584,8 @@ function validateLocalBridgeBundle(value) {
     issues.push("data must be an object");
   } else {
     for (const key of dataKeys) {
+      if (key === "saved_views" && data[key] === undefined)
+        continue;
       if (!Array.isArray(data[key]))
         issues.push(`data.${key} must be an array`);
     }
@@ -11082,7 +11758,8 @@ function importLocalBridgeBundle(bundle, options = {}, db) {
   const conflictStrategy = options.conflictStrategy ?? "skip";
   const data = {
     ...bundle.data,
-    tasks: sortedTasks(bundle.data.tasks)
+    tasks: sortedTasks(bundle.data.tasks),
+    saved_views: bundle.data.saved_views ?? []
   };
   for (const key of dataKeys) {
     for (const row of data[key]) {
@@ -11153,7 +11830,8 @@ var init_local_bridge = __esm(() => {
     "task_files",
     "task_commits",
     "task_git_refs",
-    "task_verifications"
+    "task_verifications",
+    "saved_views"
   ];
   insertColumns = {
     projects: ["id", "name", "path", "description", "task_list_id", "task_prefix", "task_counter", "created_at", "updated_at", "machine_id", "synced_at"],
@@ -11225,7 +11903,8 @@ var init_local_bridge = __esm(() => {
     task_files: ["id", "task_id", "path", "status", "agent_id", "note", "created_at", "updated_at", "machine_id"],
     task_commits: ["id", "task_id", "sha", "message", "author", "files_changed", "committed_at", "created_at"],
     task_git_refs: ["id", "task_id", "ref_type", "name", "url", "provider", "metadata", "created_at", "updated_at"],
-    task_verifications: ["id", "task_id", "command", "status", "output_summary", "artifact_path", "agent_id", "run_at", "created_at"]
+    task_verifications: ["id", "task_id", "command", "status", "output_summary", "artifact_path", "agent_id", "run_at", "created_at"],
+    saved_views: ["id", "name", "description", "scope", "filters", "created_at", "updated_at"]
   };
   tableByKey = {
     projects: "projects",
@@ -11241,9 +11920,10 @@ var init_local_bridge = __esm(() => {
     task_files: "task_files",
     task_commits: "task_commits",
     task_git_refs: "task_git_refs",
-    task_verifications: "task_verifications"
+    task_verifications: "task_verifications",
+    saved_views: "saved_search_views"
   };
-  jsonColumns = new Set(["metadata", "tags", "data", "files_changed"]);
+  jsonColumns = new Set(["metadata", "tags", "data", "files_changed", "filters"]);
 });
 
 // src/lib/local-encryption.ts
@@ -11818,7 +12498,8 @@ function emptyCounts2() {
     task_files: 0,
     task_commits: 0,
     task_git_refs: 0,
-    task_verifications: 0
+    task_verifications: 0,
+    saved_views: 0
   };
 }
 function bridgeToMarkdownPayload(bundle) {
@@ -12069,6 +12750,61 @@ __export(exports_project_commands, {
 });
 import chalk4 from "chalk";
 import { basename as basename3, resolve as resolve9 } from "path";
+function collectOption(value, previous = []) {
+  return [...previous, value];
+}
+function splitList(value) {
+  if (!value)
+    return;
+  const values = Array.isArray(value) ? value : [value];
+  const items = values.flatMap((item) => item.split(",").map((part) => part.trim()).filter(Boolean));
+  return items.length > 0 ? items : undefined;
+}
+function parseJsonObjectOption(value, label) {
+  if (!value)
+    return;
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+      return parsed;
+  } catch {}
+  throw new Error(`${label} must be a JSON object`);
+}
+function buildSearchFilters(query, opts, projectId) {
+  const filterPatch = parseJsonObjectOption(opts.filter, "--filter");
+  const customFields = parseJsonObjectOption(opts.fieldCustom, "--field-custom");
+  const labels = splitList(opts.fieldLabel);
+  const tags = splitList(opts.tag);
+  const statuses = splitList(opts.status)?.map(normalizeStatus);
+  const filters = {
+    query: query || opts.query,
+    project_id: opts.allProjects ? undefined : projectId,
+    status: statuses,
+    priority: splitList(opts.priority),
+    assigned_to: opts.assigned,
+    agent_id: opts.agentId,
+    task_list_id: opts.taskList,
+    plan_id: opts.plan,
+    task_id: opts.task,
+    tags,
+    created_after: opts.createdAfter,
+    updated_after: opts.since || opts.updatedAfter,
+    has_dependencies: opts.hasDeps ? true : undefined,
+    is_blocked: opts.blocked ? true : undefined,
+    depends_on: opts.dependsOn,
+    blocks: opts.blocks,
+    limit: opts.limit ? Number(opts.limit) : undefined,
+    local_fields: labels || opts.fieldOwner || opts.fieldArea || opts.fieldSeverity || customFields ? {
+      labels,
+      owner: opts.fieldOwner,
+      area: opts.fieldArea,
+      severity: opts.fieldSeverity,
+      custom: customFields
+    } : undefined,
+    ...filterPatch
+  };
+  return Object.fromEntries(Object.entries(filters).filter(([, value]) => value !== undefined));
+}
 function registerProjectCommands(program2) {
   program2.command("project-bootstrap [path]").description("Discover a local workspace and initialize project task state").option("--name <name>", "Project display name").option("--task-list <slug>", "Default task list slug").option("--dry-run", "Show discovery without writing local state").action(async (inputPath, opts) => {
     const globalOpts = program2.opts();
@@ -12121,35 +12857,126 @@ function registerProjectCommands(program2) {
       console.log(chalk4.green("Comment added."));
     }
   });
-  program2.command("search <query>").description("Search tasks").option("--status <status>", "Filter by status").option("--priority <p>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--since <date>", "Only tasks updated after this date (ISO)").option("--blocked", "Only blocked tasks (incomplete dependencies)").option("--has-deps", "Only tasks with dependencies").action((query, opts) => {
+  program2.command("search <query>").description("Search local tasks, or run/save a cross-entity search view").option("--status <status>", "Filter by status").option("--priority <p>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--agent-id <agent>", "Filter by creator/run/comment agent").option("--task-list <id>", "Filter by task list").option("--plan <id>", "Filter by plan").option("--task <id>", "Filter runs/comments by task").option("--tag <tag>", "Filter by task tag (repeatable or comma-separated)", collectOption, []).option("--field-label <label>", "Filter by local field label (repeatable or comma-separated)", collectOption, []).option("--field-owner <owner>", "Filter by local field owner").option("--field-area <area>", "Filter by local field area").option("--field-severity <severity>", "Filter by local field severity").option("--field-custom <json>", "Filter by local custom fields as JSON").option("--since <date>", "Only tasks updated after this date (ISO)").option("--created-after <date>", "Only records created after this date (ISO)").option("--blocked", "Only blocked tasks (incomplete dependencies)").option("--has-deps", "Only tasks with dependencies").option("--depends-on <id>", "Only tasks that depend on a task").option("--blocks <id>", "Only tasks that block a task").option("--scope <scope>", "Search scope: tasks, projects, plans, runs, comments, all", "tasks").option("--limit <n>", "Maximum results", "100").option("--filter <json>", "Merge an advanced saved-search filter JSON object").option("--save-as <name>", "Save this search as a named view").option("--description <text>", "Saved view description").option("--all-projects", "Do not auto-scope the search to the current project").action((query, opts) => {
+    const globalOpts = program2.opts();
+    try {
+      const projectId = opts.allProjects ? undefined : autoProject(globalOpts);
+      const scope = normalizeScope(opts.scope);
+      const searchOpts = buildSearchFilters(query, opts, projectId);
+      if (opts.saveAs) {
+        const view = saveSearchView({
+          name: opts.saveAs,
+          description: opts.description,
+          scope,
+          filters: searchOpts
+        });
+        output(view, Boolean(globalOpts.json));
+        if (!globalOpts.json)
+          console.log(chalk4.green(`Saved view ${view.name}.`));
+        return;
+      }
+      if (scope !== "tasks") {
+        const result = runSavedSearch(searchOpts, scope);
+        if (globalOpts.json) {
+          output(result, true);
+          return;
+        }
+        if (result.count === 0) {
+          console.log(chalk4.dim(`No ${scope} results matching "${query}".`));
+          return;
+        }
+        console.log(chalk4.bold(`${result.count} ${scope} result(s) for "${query}":
+`));
+        for (const item of result.results) {
+          const entity = item.entity;
+          console.log(`${chalk4.cyan(item.entity_type)} ${entity.id?.slice?.(0, 8) || ""} ${entity.name || entity.title || entity.content || entity.summary || ""}`);
+        }
+        return;
+      }
+      const tasks = runSavedSearch(searchOpts, "tasks").results.map((item) => item.entity);
+      if (globalOpts.json) {
+        output(tasks, true);
+        return;
+      }
+      if (tasks.length === 0) {
+        console.log(chalk4.dim(`No tasks matching "${query}".`));
+        return;
+      }
+      console.log(chalk4.bold(`${tasks.length} result(s) for "${query}":
+`));
+      for (const t of tasks) {
+        console.log(formatTaskLine(t));
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  const views = program2.command("views").description("Manage local saved search views");
+  views.command("save <name>").description("Save a local search view").option("--query <query>", "Search query").option("--scope <scope>", "Search scope: tasks, projects, plans, runs, comments, all", "tasks").option("--description <text>", "Description").option("--status <status>", "Filter by status").option("--priority <p>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--agent-id <agent>", "Filter by creator/run/comment agent").option("--task-list <id>", "Filter by task list").option("--plan <id>", "Filter by plan").option("--task <id>", "Filter runs/comments by task").option("--tag <tag>", "Filter by task tag (repeatable or comma-separated)", collectOption, []).option("--field-label <label>", "Filter by local field label (repeatable or comma-separated)", collectOption, []).option("--field-owner <owner>", "Filter by local field owner").option("--field-area <area>", "Filter by local field area").option("--field-severity <severity>", "Filter by local field severity").option("--field-custom <json>", "Filter by local custom fields as JSON").option("--since <date>", "Only records updated after this date (ISO)").option("--created-after <date>", "Only records created after this date (ISO)").option("--blocked", "Only blocked tasks").option("--has-deps", "Only tasks with dependencies").option("--depends-on <id>", "Only tasks that depend on a task").option("--blocks <id>", "Only tasks that block a task").option("--limit <n>", "Maximum results", "100").option("--filter <json>", "Merge an advanced saved-search filter JSON object").option("--all-projects", "Do not auto-scope the view to the current project").action((name, opts) => {
+    const globalOpts = program2.opts();
+    try {
+      const projectId = opts.allProjects ? undefined : autoProject(globalOpts);
+      const view = saveSearchView({
+        name,
+        description: opts.description,
+        scope: normalizeScope(opts.scope),
+        filters: buildSearchFilters(opts.query, opts, projectId)
+      });
+      output(view, Boolean(globalOpts.json));
+      if (!globalOpts.json)
+        console.log(chalk4.green(`Saved view ${view.name}.`));
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  views.command("list").description("List local saved search views").option("--scope <scope>", "Filter by scope").action((opts) => {
+    const globalOpts = program2.opts();
+    try {
+      const rows = listSearchViews(opts.scope ? normalizeScope(opts.scope) : undefined);
+      output(rows, Boolean(globalOpts.json));
+      if (!globalOpts.json) {
+        if (rows.length === 0) {
+          console.log(chalk4.dim("No saved search views."));
+          return;
+        }
+        for (const row of rows)
+          console.log(`${chalk4.cyan(row.name)} ${chalk4.dim(`[${row.scope}]`)} ${JSON.stringify(row.filters)}`);
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  views.command("run <name>").description("Run a local saved search view").action((name) => {
+    const globalOpts = program2.opts();
+    try {
+      const result = runSearchView(name);
+      if (globalOpts.json) {
+        output(result, true);
+        return;
+      }
+      console.log(chalk4.bold(`${result.count} result(s) for view "${result.view?.name || name}":
+`));
+      for (const item of result.results) {
+        if (item.entity_type === "tasks") {
+          console.log(formatTaskLine(item.entity));
+          continue;
+        }
+        const entity = item.entity;
+        console.log(`${chalk4.cyan(item.entity_type)} ${entity.id?.slice?.(0, 8) || ""} ${entity.name || entity.title || entity.content || entity.summary || ""}`);
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  views.command("delete <name>").description("Delete a local saved search view").action((name) => {
     const globalOpts = program2.opts();
-    const projectId = autoProject(globalOpts);
-    const searchOpts = { query, project_id: projectId };
-    if (opts.status)
-      searchOpts.status = normalizeStatus(opts.status);
-    if (opts.priority)
-      searchOpts.priority = opts.priority;
-    if (opts.assigned)
-      searchOpts.assigned_to = opts.assigned;
-    if (opts.since)
-      searchOpts.updated_after = opts.since;
-    if (opts.blocked)
-      searchOpts.is_blocked = true;
-    if (opts.hasDeps)
-      searchOpts.has_dependencies = true;
-    const tasks = searchTasks(searchOpts);
-    if (globalOpts.json) {
-      output(tasks, true);
-      return;
-    }
-    if (tasks.length === 0) {
-      console.log(chalk4.dim(`No tasks matching "${query}".`));
-      return;
-    }
-    console.log(chalk4.bold(`${tasks.length} result(s) for "${query}":
-`));
-    for (const t of tasks) {
-      console.log(formatTaskLine(t));
+    try {
+      const deleted = deleteSearchView(name);
+      output({ deleted }, Boolean(globalOpts.json));
+      if (!globalOpts.json)
+        console.log(deleted ? chalk4.green(`Deleted view ${name}.`) : chalk4.dim(`View not found: ${name}`));
+    } catch (e) {
+      handleError(e);
     }
   });
   program2.command("deps <id>").description("Manage task dependencies").option("--needs <dep-id>", "Add dependency (this task needs dep-id)").option("--remove <dep-id>", "Remove dependency").option("--graph", "Show the dependency graph instead of direct edges").option("--direction <direction>", "Graph direction: up, down, or both", "both").action(async (id, opts) => {
@@ -12415,8 +13242,8 @@ function registerProjectCommands(program2) {
     const projectId = autoProject(globalOpts);
     const writeOutput = async (content) => {
       if (opts.output) {
-        const { writeFileSync: writeFileSync4 } = await import("fs");
-        writeFileSync4(resolve9(opts.output), content.endsWith(`
+        const { writeFileSync: writeFileSync5 } = await import("fs");
+        writeFileSync5(resolve9(opts.output), content.endsWith(`
 `) ? content : `${content}
 `);
       } else {
@@ -12576,7 +13403,7 @@ var init_project_commands = __esm(() => {
   init_database();
   init_projects();
   init_comments();
-  init_search();
+  init_saved_search_views();
   init_sync();
   init_config();
   init_helpers();
@@ -14205,8 +15032,8 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync5, statSync as statSync5 } from "fs";
-import { basename as basename4, dirname as dirname7, join as join9 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync6, statSync as statSync5 } from "fs";
+import { basename as basename4, dirname as dirname7, join as join10 } from "path";
 function tableExists(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
@@ -14363,13 +15190,13 @@ function createBackup(dbPath) {
   if (!existsSync9(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join9(dirname7(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
+  const backupDir = join10(dirname7(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
   const files = [];
-  mkdirSync5(backupDir, { recursive: true });
+  mkdirSync6(backupDir, { recursive: true });
   for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     if (!existsSync9(source))
       continue;
-    const target = join9(backupDir, basename4(source));
+    const target = join10(backupDir, basename4(source));
     copyFileSync(source, target);
     files.push(target);
   }
@@ -14595,7 +15422,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/server/routes.ts
-import { join as join10, resolve as resolve11, sep } from "path";
+import { join as join11, resolve as resolve11, sep } from "path";
 function parseFieldsParam(url) {
   const fieldsParam = url.searchParams.get("fields");
   return fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
@@ -15295,7 +16122,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
   if (!ctx.dashboardExists || method !== "GET" && method !== "HEAD")
     return null;
   if (path !== "/") {
-    const filePath = join10(ctx.dashboardDir, path);
+    const filePath = join11(ctx.dashboardDir, path);
     const resolvedFile = resolve11(filePath);
     const resolvedBase = resolve11(ctx.dashboardDir);
     if (!resolvedFile.startsWith(resolvedBase + sep) && resolvedFile !== resolvedBase) {
@@ -15305,7 +16132,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
     if (res2)
       return res2;
   }
-  const indexPath = join10(ctx.dashboardDir, "index.html");
+  const indexPath = join11(ctx.dashboardDir, "index.html");
   const res = serveStaticFile2(indexPath);
   if (res)
     return res;
@@ -15335,26 +16162,26 @@ __export(exports_serve, {
   MIME_TYPES: () => MIME_TYPES
 });
 import { existsSync as existsSync10 } from "fs";
-import { join as join11, dirname as dirname8, extname } from "path";
+import { join as join12, dirname as dirname8, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname8(fileURLToPath2(import.meta.url));
-    candidates.push(join11(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join11(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join12(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join12(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname8(process.argv[1]);
-    candidates.push(join11(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join11(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join12(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join12(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join11(process.cwd(), "dashboard", "dist"));
+  candidates.push(join12(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
     if (existsSync10(candidate))
       return candidate;
   }
-  return join11(process.cwd(), "dashboard", "dist");
+  return join12(process.cwd(), "dashboard", "dist");
 }
 function getProvidedApiKey(req) {
   const headerKey = req.headers.get("x-api-key");
@@ -17130,14 +17957,14 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk6 from "chalk";
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname9, join as join12 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname9, join as join13 } from "path";
 function registerConfigServeCommands(program2) {
   program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
     const globalOpts = program2.opts();
     const home = process.env["HOME"] || "~";
-    const newPath = join12(home, ".hasna", "todos", "config.json");
-    const legacyPath = join12(home, ".todos", "config.json");
+    const newPath = join13(home, ".hasna", "todos", "config.json");
+    const legacyPath = join13(home, ".todos", "config.json");
     const configPath = !existsSync11(newPath) && existsSync11(legacyPath) ? legacyPath : newPath;
     if (opts.get) {
       const config2 = loadConfig();
@@ -17176,8 +18003,8 @@ function registerConfigServeCommands(program2) {
       obj[keys[keys.length - 1]] = parsedValue;
       const dir = dirname9(configPath);
       if (!existsSync11(dir))
-        mkdirSync6(dir, { recursive: true });
-      writeFileSync4(configPath, JSON.stringify(config2, null, 2));
+        mkdirSync7(dir, { recursive: true });
+      writeFileSync5(configPath, JSON.stringify(config2, null, 2));
       if (globalOpts.json) {
         output({ key, value: parsedValue }, true);
       } else {
@@ -18614,101 +19441,6 @@ var init_task_dedupe = __esm(() => {
   PY_STACK_RE = /File\s+"([^"]+)",\s+line\s+\d+,\s+in\s+([^\s]+)/i;
 });
 
-// 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 custom = 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
-  };
-  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/lib/activity-timeline.ts
 var exports_activity_timeline = {};
 __export(exports_activity_timeline, {
@@ -19552,7 +20284,7 @@ __export(exports_query_commands, {
   registerQueryCommands: () => registerQueryCommands
 });
 import chalk7 from "chalk";
-function parseJsonObjectOption(value, label) {
+function parseJsonObjectOption2(value, label) {
   if (!value)
     return;
   try {
@@ -20083,8 +20815,8 @@ Repairs`));
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
       const { statSync: statSync6 } = await import("fs");
-      const { join: join13 } = await import("path");
-      const dbPath = process.env["TODOS_DB_PATH"] || join13(process.env["HOME"] || "~", ".todos", "todos.db");
+      const { join: join14 } = await import("path");
+      const dbPath = process.env["TODOS_DB_PATH"] || join14(process.env["HOME"] || "~", ".todos", "todos.db");
       let size = "unknown";
       try {
         size = `${(statSync6(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
@@ -20904,7 +21636,7 @@ Repairs`));
   fields.command("set <task-id>").description("Set local fields for a task").option("--labels <labels>", "Comma-separated labels").option("--priority <priority>", "Priority: low, medium, high, critical").option("--severity <severity>", "Local severity, for example s0, s1, s2").option("--owner <owner>", "Local owner or responsible agent").option("--area <area>", "Local area or component").option("--custom <json>", "Custom fields as a JSON object").option("--field <pairs...>", "Custom key=value pairs").option("--replace-custom", "Replace custom fields instead of merging").option("-j, --json", "Output as JSON").action((taskId, opts) => {
     const globalOpts = program2.opts();
     try {
-      const custom = mergeCustomFields(parseJsonObjectOption(opts.custom, "--custom"), parseFieldPairs(opts.field));
+      const custom = mergeCustomFields(parseJsonObjectOption2(opts.custom, "--custom"), parseFieldPairs(opts.field));
       const input = {
         labels: parseCsvOption(opts.labels),
         priority: parsePriority(opts.priority),
@@ -20934,7 +21666,7 @@ Repairs`));
         severity: opts.severity,
         owner: opts.owner,
         area: opts.area,
-        custom: mergeCustomFields(parseJsonObjectOption(opts.custom, "--custom"), parseFieldPairs(opts.field)),
+        custom: mergeCustomFields(parseJsonObjectOption2(opts.custom, "--custom"), parseFieldPairs(opts.field)),
         limit: Number(opts.limit)
       };
       const tasks = queryTasksByLocalFields(query);
@@ -21018,7 +21750,7 @@ Repairs`));
       source_type: opts.sourceType,
       source_name: opts.sourceName || opts.file,
       source_url: opts.sourceUrl,
-      metadata: parseJsonObjectOption(opts.metadata, "--metadata"),
+      metadata: parseJsonObjectOption2(opts.metadata, "--metadata"),
       project_id: autoProject(globalOpts) || undefined,
       priority: opts.priority,
       tags: opts.tags ? String(opts.tags).split(",").map((tag) => tag.trim()).filter(Boolean) : undefined,
@@ -25810,6 +26542,10 @@ var init_token_utils = __esm(() => {
       "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",
@@ -25999,10 +26735,12 @@ var init_token_utils = __esm(() => {
       "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: [
@@ -27601,6 +28339,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 };
+      }
+    });
+  }
 }
 var init_task_project_tools = __esm(() => {
   init_zod();
@@ -28949,6 +29757,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",
@@ -29281,7 +30093,7 @@ __export(exports_verification_providers, {
   discoverVerificationProviderCapabilities: () => discoverVerificationProviderCapabilities
 });
 import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-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");
@@ -29300,10 +30112,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();
@@ -29333,7 +30145,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;
@@ -32070,6 +32882,259 @@ var init_agents2 = __esm(() => {
   init_database();
 });
 
+// src/mcp/tools/templates.ts
+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 json2 = exportTemplate2(resolvedId);
+        return { content: [{ type: "text", text: JSON.stringify(json2, 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: json2 }) => {
+      try {
+        const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
+        const parsed = JSON.parse(json2);
+        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 };
+      }
+    });
+  }
+}
+var init_templates2 = __esm(() => {
+  init_zod();
+  init_tasks();
+});
+
 // src/mcp/index.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -32238,6 +33303,7 @@ var init_mcp = __esm(() => {
   init_code_tools();
   init_machines2();
   init_agents2();
+  init_templates2();
   init_package_version();
   init_token_utils();
   if (hasVersionFlag()) {
@@ -32268,6 +33334,7 @@ var init_mcp = __esm(() => {
   registerTaskRelTools(server, toolContext);
   registerCodeTools(server, toolContext);
   registerAgentTools(server, { ...toolContext, agentFocusMap });
+  registerTemplateTools(server, toolContext);
   registerMachineTools(server, { shouldRegisterTool, formatError });
   registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
   main().catch(async (err) => {
@@ -32287,15 +33354,15 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname10, join as join13 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname10, join as join14 } from "path";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join13(HOME2, ".bun", "bin", "todos-mcp");
+  const bunBin = join14(HOME2, ".bun", "bin", "todos-mcp");
   if (existsSync13(bunBin))
     return bunBin;
   return "todos-mcp";
@@ -32312,8 +33379,8 @@ function readJsonFile2(path) {
 function writeJsonFile2(path, data) {
   const dir = dirname10(path);
   if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, JSON.stringify(data, null, 2) + `
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
@@ -32324,8 +33391,8 @@ function readTomlFile(path) {
 function writeTomlFile(path, content) {
   const dir = dirname10(path);
   if (!existsSync13(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync5(path, content);
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync6(path, content);
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -32389,7 +33456,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join14(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -32403,7 +33470,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join14(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk8.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -32415,7 +33482,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join14(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -32429,7 +33496,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join14(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -32486,9 +33553,9 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join13(process.cwd(), ".claude", "hooks");
+    const hooksDir = join14(process.cwd(), ".claude", "hooks");
     if (!existsSync13(hooksDir))
-      mkdirSync7(hooksDir, { recursive: true });
+      mkdirSync8(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
@@ -32512,11 +33579,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join13(hooksDir, "todos-sync.sh");
-    writeFileSync5(hookPath, hookScript);
+    const hookPath = join14(hooksDir, "todos-sync.sh");
+    writeFileSync6(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join13(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join14(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -33265,12 +34332,12 @@ Artifacts:`));
           console.log(chalk8.yellow("Hook already installed."));
           return;
         }
-        writeFileSync5(hookPath, existing + `
+        writeFileSync6(hookPath, existing + `
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
       } else {
-        writeFileSync5(hookPath, `#!/usr/bin/env bash
+        writeFileSync6(hookPath, `#!/usr/bin/env bash
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
@@ -33302,7 +34369,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       if (cleaned === "#!/usr/bin/env bash" || cleaned === "") {
         (await import("fs")).unlinkSync(hookPath);
       } else {
-        writeFileSync5(hookPath, cleaned + `
+        writeFileSync6(hookPath, cleaned + `
 `);
       }
       console.log(chalk8.green("Post-commit hook removed."));
@@ -33467,9 +34534,9 @@ __export(exports_machines2, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -33663,8 +34730,8 @@ Warning: No primary machine set.`));
       if (opts.push) {
         try {
           const localTasks = listTasks3();
-          const tmpFile = join14(tmpdir2(), `todos-export-${uuid()}.json`);
-          writeFileSync6(tmpFile, JSON.stringify(localTasks, null, 2));
+          const tmpFile = join15(tmpdir2(), `todos-export-${uuid()}.json`);
+          writeFileSync7(tmpFile, JSON.stringify(localTasks, null, 2));
           execSync4(`scp ${tmpFile} ${ssh}:/tmp/todos-import.json`, { timeout: 15000 });
           const importCmd = `ssh ${ssh} 'node -e "const fs=require(\\'fs\\');const tasks=JSON.parse(fs.readFileSync(\\'/tmp/todos-import.json\\',\\'utf-8\\'));console.log(JSON.stringify(tasks.length))"'`;
           const count = execSync4(importCmd, { encoding: "utf-8", timeout: 1e4 }).trim();