@hasna/todos 0.11.94 → 0.11.95

package/dist/cli/index.js

@@ -2104,7 +2104,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.11.94",
+    version: "0.11.95",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -2826,6 +2826,48 @@ async function cloudDeleteTask(client, id) {
     throw error;
   }
 }
+function unwrapTemplate(raw) {
+  if (raw && typeof raw === "object" && "template" in raw) {
+    return raw.template;
+  }
+  return raw;
+}
+async function cloudListTemplates(client, projectId) {
+  const result = await requiredRemoteRoute(client, "/v1/templates", () => client.list("templates", { query: projectId ? { project_id: projectId } : undefined }));
+  const envelope = result.raw;
+  return Array.isArray(envelope?.templates) ? envelope.templates : result.items;
+}
+async function cloudCreateTemplate(client, input) {
+  return unwrapTemplate(await requiredRemoteRoute(client, "/v1/templates", () => client.create("templates", input)));
+}
+async function cloudGetTemplate(client, id) {
+  try {
+    return unwrapTemplate(await client.get("templates", id));
+  } catch (error) {
+    if (error && typeof error === "object" && error.status === 404)
+      return null;
+    throw error;
+  }
+}
+async function cloudUpdateTemplate(client, id, patch) {
+  try {
+    return unwrapTemplate(await client.update("templates", id, patch));
+  } catch (error) {
+    if (error && typeof error === "object" && error.status === 404)
+      return null;
+    throw error;
+  }
+}
+async function cloudDeleteTemplate(client, id) {
+  try {
+    await client.transport.del(`/templates/${encodeURIComponent(id)}`);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && error.status === 404)
+      return false;
+    throw error;
+  }
+}
 async function cloudTaskAction(client, id, action, body = {}) {
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/${action}`, body);
   return unwrapTask(raw);
@@ -9928,6 +9970,50 @@ var init_recurrence = __esm(() => {
   };
 });
 
+// src/lib/template-semantics.ts
+function resolveTemplateVariables(templateVars, provided) {
+  const merged = { ...provided };
+  for (const variable of templateVars) {
+    if (merged[variable.name] === undefined && variable.default !== undefined) {
+      merged[variable.name] = variable.default;
+    }
+  }
+  const missing = templateVars.filter((variable) => variable.required && merged[variable.name] === undefined).map((variable) => variable.name);
+  if (missing.length > 0) {
+    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
+  }
+  return merged;
+}
+function substituteTemplateVariables(text, variables) {
+  let result = text;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+  }
+  return result;
+}
+function evaluateTemplateCondition(condition, variables) {
+  if (!condition || condition.trim() === "")
+    return true;
+  const trimmed = condition.trim();
+  const equal = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
+  if (equal)
+    return (variables[equal[1]] ?? "") === equal[2].trim();
+  const unequal = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
+  if (unequal)
+    return (variables[unequal[1]] ?? "") !== unequal[2].trim();
+  const falsy = trimmed.match(/^!\{([^}]+)\}$/);
+  if (falsy) {
+    const value = variables[falsy[1]];
+    return !value || value === "" || value === "false";
+  }
+  const truthy = trimmed.match(/^\{([^}]+)\}$/);
+  if (truthy) {
+    const value = variables[truthy[1]];
+    return !!value && value !== "" && value !== "false";
+  }
+  return true;
+}
+
 // src/db/templates.ts
 var exports_templates = {};
 __export(exports_templates, {
@@ -10023,6 +10109,14 @@ function deleteTemplate(id, db) {
     payload: template,
     version: template.version
   }, d);
+  for (const task of getTemplateTasks(resolved, d)) {
+    recordStorageTombstone({
+      object_type: "template_tasks",
+      object_id: task.id,
+      payload: task,
+      version: 1
+    }, d);
+  }
   return d.run("DELETE FROM task_templates WHERE id = ?", [resolved]).changes > 0;
 }
 function updateTemplate(id, updates, db) {
@@ -10154,34 +10248,7 @@ function getTemplateTasks(templateId, db) {
   return rows.map(rowToTemplateTask);
 }
 function evaluateCondition(condition, variables) {
-  if (!condition || condition.trim() === "")
-    return true;
-  const trimmed = condition.trim();
-  const eqMatch = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
-  if (eqMatch) {
-    const varName = eqMatch[1];
-    const expected = eqMatch[2].trim();
-    return (variables[varName] ?? "") === expected;
-  }
-  const neqMatch = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
-  if (neqMatch) {
-    const varName = neqMatch[1];
-    const expected = neqMatch[2].trim();
-    return (variables[varName] ?? "") !== expected;
-  }
-  const falsyMatch = trimmed.match(/^!\{([^}]+)\}$/);
-  if (falsyMatch) {
-    const varName = falsyMatch[1];
-    const val = variables[varName];
-    return !val || val === "" || val === "false";
-  }
-  const truthyMatch = trimmed.match(/^\{([^}]+)\}$/);
-  if (truthyMatch) {
-    const varName = truthyMatch[1];
-    const val = variables[varName];
-    return !!val && val !== "" && val !== "false";
-  }
-  return true;
+  return evaluateTemplateCondition(condition, variables);
 }
 function exportTemplate(id, db) {
   const d = db || getDatabase();
@@ -10254,29 +10321,10 @@ function listTemplateVersions(id, db) {
   return d.query("SELECT * FROM template_versions WHERE template_id = ? ORDER BY version DESC").all(resolved);
 }
 function resolveVariables(templateVars, provided) {
-  const merged = { ...provided };
-  for (const v of templateVars) {
-    if (merged[v.name] === undefined && v.default !== undefined) {
-      merged[v.name] = v.default;
-    }
-  }
-  const missing = [];
-  for (const v of templateVars) {
-    if (v.required && merged[v.name] === undefined) {
-      missing.push(v.name);
-    }
-  }
-  if (missing.length > 0) {
-    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
-  }
-  return merged;
+  return resolveTemplateVariables(templateVars, provided);
 }
 function substituteVars(text, variables) {
-  let result = text;
-  for (const [key, val] of Object.entries(variables)) {
-    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
-  }
-  return result;
+  return substituteTemplateVariables(text, variables);
 }
 function tasksFromTemplate(templateId, projectId, variables, taskListId, db, _visitedTemplateIds) {
   const d = db || getDatabase();
@@ -16910,6 +16958,80 @@ __export(exports_plan_template_commands, {
   registerPlanTemplateCommands: () => registerPlanTemplateCommands
 });
 import chalk3 from "chalk";
+async function createRemoteTemplateTasks(cloud, template, projectId, variables, agentId, overrides, visited = new Set) {
+  if (visited.has(template.id)) {
+    throw new Error(`Circular template reference detected: ${template.id}`);
+  }
+  visited.add(template.id);
+  try {
+    const resolved = resolveTemplateVariables(template.variables ?? [], variables);
+    const render = (value) => value === null || value === undefined ? value : substituteTemplateVariables(value, resolved);
+    if (template.tasks.length === 0) {
+      const task = await cloudCreateTask(cloud, {
+        title: render(overrides?.title || template.title_pattern),
+        ...render(overrides?.description ?? template.description) ? { description: render(overrides?.description ?? template.description) } : {},
+        priority: overrides?.priority ?? template.priority,
+        tags: template.tags,
+        ...projectId ? { project_id: projectId } : {},
+        ...template.plan_id ? { plan_id: template.plan_id } : {},
+        ...agentId ? { agent_id: agentId } : {},
+        ...Object.keys(template.metadata ?? {}).length > 0 ? { metadata: template.metadata } : {}
+      });
+      return { tasks: [task] };
+    }
+    const created = [];
+    const positionToTaskId = new Map;
+    const skippedPositions = new Set;
+    for (const step of template.tasks) {
+      if (step.include_template_id) {
+        const included = await cloudGetTemplate(cloud, step.include_template_id);
+        if (!included)
+          throw new Error(`Included template not found: ${step.include_template_id}`);
+        const result = await createRemoteTemplateTasks(cloud, included, projectId, resolved, agentId, undefined, visited);
+        created.push(...result.tasks);
+        if (result.tasks.length > 0)
+          positionToTaskId.set(step.position, result.tasks[0].id);
+        else
+          skippedPositions.add(step.position);
+        continue;
+      }
+      if (step.condition && !evaluateTemplateCondition(step.condition, resolved)) {
+        skippedPositions.add(step.position);
+        continue;
+      }
+      const task = await cloudCreateTask(cloud, {
+        title: render(step.title_pattern),
+        ...render(step.description) ? { description: render(step.description) } : {},
+        priority: step.priority,
+        tags: step.tags,
+        ...step.task_type ? { task_type: step.task_type } : {},
+        ...projectId ? { project_id: projectId } : {},
+        ...template.plan_id ? { plan_id: template.plan_id } : {},
+        ...agentId ? { agent_id: agentId } : {},
+        ...Object.keys(step.metadata ?? {}).length > 0 ? { metadata: step.metadata } : {}
+      });
+      created.push(task);
+      positionToTaskId.set(step.position, task.id);
+    }
+    for (const step of template.tasks) {
+      if (skippedPositions.has(step.position) || step.include_template_id)
+        continue;
+      const taskId = positionToTaskId.get(step.position);
+      if (!taskId)
+        continue;
+      for (const dependencyPosition of step.depends_on_positions) {
+        if (skippedPositions.has(dependencyPosition))
+          continue;
+        const dependencyId = positionToTaskId.get(dependencyPosition);
+        if (dependencyId)
+          await cloudAddDependency(cloud, taskId, dependencyId);
+      }
+    }
+    return { tasks: created };
+  } finally {
+    visited.delete(template.id);
+  }
+}
 function resolvePlanCliRef(ref, projectId) {
   const db = getDatabase();
   const resolved = resolvePlanRefDetailed(ref, db, projectId);
@@ -17154,6 +17276,117 @@ function registerPlanTemplateCommands(program2) {
   });
   program2.command("templates").description("List and manage task templates").option("--add <name>", "Create a template").option("--title <pattern>", "Title pattern (with --add)").option("-d, --description <text>", "Default description").option("-p, --priority <level>", "Default priority").option("-t, --tags <tags>", "Default tags (comma-separated)").option("--delete <id>", "Delete a template").option("--update <id>", "Update a template").option("--use <id>", "Create a task from a template").option("--var <vars...>", "Variable substitutions: key=value (e.g. --var feature=login)").action(async (opts) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      try {
+        const projectId = globalOpts.project ? await cloudResolveProjectRef(cloud, globalOpts.project) : undefined;
+        if (opts.add) {
+          if (!opts.title) {
+            console.error(chalk3.red("--title is required with --add"));
+            process.exit(1);
+          }
+          const template = await cloudCreateTemplate(cloud, {
+            name: opts.add,
+            title_pattern: opts.title,
+            description: opts.description,
+            priority: opts.priority || "medium",
+            tags: opts.tags ? opts.tags.split(",").map((tag) => tag.trim()).filter(Boolean) : [],
+            project_id: projectId
+          });
+          if (globalOpts.json) {
+            output(template, true);
+          } else {
+            console.log(chalk3.green(`Template created: ${template.id.slice(0, 8)} | ${template.name} | "${template.title_pattern}"`));
+          }
+          return;
+        }
+        if (opts.delete) {
+          const deleted = await cloudDeleteTemplate(cloud, opts.delete);
+          if (globalOpts.json) {
+            output({ deleted }, true);
+          } else if (deleted) {
+            console.log(chalk3.green("Template deleted."));
+          } else {
+            console.error(chalk3.red("Template not found."));
+            process.exit(1);
+          }
+          return;
+        }
+        if (opts.update) {
+          const updates = {};
+          if (opts.title)
+            updates.title_pattern = opts.title;
+          if (opts.description)
+            updates.description = opts.description;
+          if (opts.priority)
+            updates.priority = opts.priority;
+          if (opts.tags)
+            updates.tags = opts.tags.split(",").map((tag) => tag.trim()).filter(Boolean);
+          if (Object.keys(updates).length === 0) {
+            console.error(chalk3.red("Provide --title, --description, --priority, or --tags with --update"));
+            process.exit(1);
+          }
+          const updated = await cloudUpdateTemplate(cloud, opts.update, updates);
+          if (!updated) {
+            console.error(chalk3.red("Template not found."));
+            process.exit(1);
+          }
+          if (globalOpts.json) {
+            output(updated, true);
+          } else {
+            console.log(chalk3.green(`Template updated: ${updated.id.slice(0, 8)} | ${updated.name} | "${updated.title_pattern}"`));
+          }
+          return;
+        }
+        if (opts.use) {
+          const variables = {};
+          for (const value of opts.var ?? []) {
+            const separator = value.indexOf("=");
+            if (separator === -1) {
+              console.error(chalk3.red(`Invalid variable format: ${value} (expected key=value)`));
+              process.exit(1);
+            }
+            variables[value.slice(0, separator)] = value.slice(separator + 1);
+          }
+          const template = await cloudGetTemplate(cloud, opts.use);
+          if (!template) {
+            console.error(chalk3.red("Template not found."));
+            process.exit(1);
+          }
+          const targetProjectId = template.project_id ?? projectId;
+          const { tasks: created } = await createRemoteTemplateTasks(cloud, template, targetProjectId, variables, globalOpts.agent, {
+            title: opts.title,
+            description: opts.description,
+            priority: opts.priority
+          });
+          if (globalOpts.json) {
+            output(created, true);
+          } else {
+            console.log(chalk3.green(`${created.length} task(s) created from template:`));
+            for (const task of created)
+              console.log(formatTaskLine(task));
+          }
+          return;
+        }
+        const templates2 = await cloudListTemplates(cloud, projectId);
+        if (globalOpts.json) {
+          output(templates2, true);
+          return;
+        }
+        if (templates2.length === 0) {
+          console.log(chalk3.dim("No templates."));
+          return;
+        }
+        console.log(chalk3.bold(`${templates2.length} template(s):
+`));
+        for (const template of templates2) {
+          console.log(`  ${chalk3.dim(template.id.slice(0, 8))} ${chalk3.bold(template.name)} ${chalk3.cyan(`"${template.title_pattern}"`)} ${chalk3.yellow(template.priority)}`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+      return;
+    }
     const {
       createTemplate: createTemplate2,
       getTemplateWithTasks: getTemplateWithTasks2,
@@ -17406,7 +17639,6 @@ function registerPlanTemplateCommands(program2) {
   });
   program2.command("template-import [file]").alias("templates-import").description("Import a template from a JSON file").option("--file <path>", "Path to template JSON file (alternative to positional arg)").action(async (file, opts) => {
     const globalOpts = program2.opts();
-    const { importTemplate: importTemplate2 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
     const { readFileSync: readFileSync5 } = await import("fs");
     try {
       const filePath = file || opts.file;
@@ -17416,7 +17648,8 @@ function registerPlanTemplateCommands(program2) {
       }
       const content = readFileSync5(filePath, "utf-8");
       const json = JSON.parse(content);
-      const template = importTemplate2(json);
+      const cloud = getTodosCloudClient();
+      const template = cloud ? await cloudCreateTemplate(cloud, json) : (await Promise.resolve().then(() => (init_templates(), exports_templates))).importTemplate(json);
       if (globalOpts.json) {
         output(template, true);
       } else {
@@ -26311,6 +26544,7 @@ function exportSqliteTodosStorageSnapshot(db) {
     agents: listAgents({ include_archived: true }, d),
     taskLists: listTaskLists(undefined, d),
     templates: listTemplates(d),
+    templateTasks: listTemplates(d).flatMap((template) => getTemplateTasks(template.id, d)),
     auditHistory: getRecentActivity(Number.MAX_SAFE_INTEGER, d),
     tombstones: listStorageTombstones(d)
   };
@@ -26360,6 +26594,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   applyRows("task_lists", "task_lists", TASK_LIST_COLUMNS, snapshot.taskLists, "updated_at");
   applyRows("plans", "plans", PLAN_COLUMNS, snapshot.plans, "updated_at");
   applyRows("templates", "task_templates", TEMPLATE_COLUMNS, snapshot.templates);
+  applyRows("template_tasks", "template_tasks", TEMPLATE_TASK_COLUMNS, snapshot.templateTasks ?? []);
   applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks2(snapshot.tasks), "updated_at", (row, changed) => {
     if (changed && Array.isArray(row["tags"]) && typeof row["id"] === "string") {
       replaceTaskTags(row["id"], row["tags"].filter((tag) => typeof tag === "string"), d);
@@ -26464,6 +26699,8 @@ function tableForTombstone(objectType) {
     return "task_lists";
   if (objectType === "templates")
     return "task_templates";
+  if (objectType === "template_tasks")
+    return "template_tasks";
   return "task_history";
 }
 function listRows(db, table, columns) {
@@ -26500,7 +26737,7 @@ function clockColumnsForTable(table) {
     return ["created_at"];
   return ["updated_at", "created_at"];
 }
-var PROJECT_COLUMNS, PROJECT_MACHINE_PATH_COLUMNS, TASK_LIST_COLUMNS, PLAN_COLUMNS, AGENT_COLUMNS, TEMPLATE_COLUMNS, TASK_COLUMNS, AUDIT_COLUMNS, JSON_COLUMNS, BOOLEAN_COLUMNS;
+var PROJECT_COLUMNS, PROJECT_MACHINE_PATH_COLUMNS, TASK_LIST_COLUMNS, PLAN_COLUMNS, AGENT_COLUMNS, TEMPLATE_COLUMNS, TEMPLATE_TASK_COLUMNS, TASK_COLUMNS, AUDIT_COLUMNS, JSON_COLUMNS, BOOLEAN_COLUMNS;
 var init_sqlite_snapshot = __esm(() => {
   init_database();
   init_agents();
@@ -26594,6 +26831,21 @@ var init_sqlite_snapshot = __esm(() => {
     "machine_id",
     "synced_at"
   ];
+  TEMPLATE_TASK_COLUMNS = [
+    "id",
+    "template_id",
+    "position",
+    "title_pattern",
+    "description",
+    "priority",
+    "tags",
+    "task_type",
+    "condition",
+    "include_template_id",
+    "depends_on_positions",
+    "metadata",
+    "created_at"
+  ];
   TASK_COLUMNS = [
     "id",
     "short_id",
@@ -26662,7 +26914,7 @@ var init_sqlite_snapshot = __esm(() => {
     "created_at",
     "machine_id"
   ];
-  JSON_COLUMNS = new Set(["tags", "metadata", "permissions", "capabilities", "variables"]);
+  JSON_COLUMNS = new Set(["tags", "metadata", "permissions", "capabilities", "variables", "depends_on_positions"]);
   BOOLEAN_COLUMNS = new Set(["requires_approval"]);
 });
 
@@ -27052,6 +27304,7 @@ function snapshotEntries(snapshot) {
     ...snapshot.agents.map((payload) => entry("agents", payload, snapshot.exportedAt)),
     ...snapshot.taskLists.map((payload) => entry("task_lists", payload, snapshot.exportedAt)),
     ...snapshot.templates.map((payload) => entry("templates", payload, snapshot.exportedAt)),
+    ...(snapshot.templateTasks ?? []).map((payload) => entry("template_tasks", payload, snapshot.exportedAt)),
     ...snapshot.auditHistory.map((payload) => entry("audit_history", payload, snapshot.exportedAt)),
     ...(snapshot.tombstones ?? []).map((tombstone) => ({
       type: tombstone.object_type,
@@ -27103,6 +27356,7 @@ function rowsToSnapshot(rows) {
     agents: [],
     taskLists: [],
     templates: [],
+    templateTasks: [],
     auditHistory: [],
     tombstones: []
   };
@@ -27137,6 +27391,8 @@ function rowsToSnapshot(rows) {
       snapshot.taskLists.push(payload);
     else if (row.object_type === "templates")
       snapshot.templates.push(payload);
+    else if (row.object_type === "template_tasks")
+      snapshot.templateTasks.push(payload);
     else if (row.object_type === "audit_history")
       snapshot.auditHistory.push(payload);
   }
@@ -27354,6 +27610,9 @@ class TodosShadowOutbox {
       case "templates":
         snapshot.templates.push(record);
         break;
+      case "template_tasks":
+        snapshot.templateTasks.push(record);
+        break;
       case "audit_history":
         snapshot.auditHistory.push(record);
         break;
@@ -27420,6 +27679,7 @@ function emptySnapshot() {
     agents: [],
     taskLists: [],
     templates: [],
+    templateTasks: [],
     auditHistory: [],
     tombstones: []
   };
@@ -27616,10 +27876,13 @@ function createPostgresTodosStorageAdapter(options) {
       get: (id) => store.get("templates", id),
       list: async () => (await store.list("templates")).sort((a, b) => a.name.localeCompare(b.name)),
       update: (id, input) => updateTemplate2(id, input, store),
-      delete: (id, context) => store.delete("templates", id, context),
+      delete: (id, context) => deleteTemplate2(id, store, context),
       getWithTasks: async (id) => {
         const template = await store.get("templates", id);
-        return template ? { ...template, tasks: [] } : null;
+        if (!template)
+          return null;
+        const tasks = (await store.list("template_tasks")).filter((task) => task.template_id === id).sort((left, right) => left.position - right.position || left.id.localeCompare(right.id));
+        return { ...template, tasks };
       }
     },
     audit: {
@@ -27907,6 +28170,57 @@ class PostgresJsonRecordStore {
     }
     return value;
   }
+  async createTemplateWithTasks(template, tasks, context = {}) {
+    await this.ensureSchema();
+    const records = [
+      { object_type: "templates", object_id: template.id, payload: template, updated_at: template.created_at, version: template.version },
+      ...tasks.map((task) => ({ object_type: "template_tasks", object_id: task.id, payload: task, updated_at: task.created_at, version: 1 }))
+    ];
+    const result = await this.options.client.query(`/* todos:create-template-with-tasks-atomic */ WITH input AS (
+         SELECT value->>'object_type' AS object_type,
+           value->>'object_id' AS object_id,
+           value->'payload' AS payload,
+           value->>'updated_at' AS updated_at,
+           COALESCE((value->>'version')::integer, 1) AS version
+         FROM jsonb_array_elements($2::jsonb) AS value
+       ) INSERT INTO ${this.tableName} (
+         service, object_type, object_id, payload, updated_at,
+         deleted_at, source_machine_id, version
+       ) SELECT $1, object_type, object_id, payload, updated_at::timestamptz,
+         NULL, $3, version
+       FROM input
+       ON CONFLICT (service, object_type, object_id) DO UPDATE SET
+         payload = EXCLUDED.payload,
+         updated_at = EXCLUDED.updated_at,
+         deleted_at = NULL,
+         source_machine_id = EXCLUDED.source_machine_id,
+         version = EXCLUDED.version
+       WHERE ${this.tableName}.updated_at IS NULL
+          OR ${this.tableName}.updated_at < EXCLUDED.updated_at
+          OR (${this.tableName}.updated_at = EXCLUDED.updated_at
+              AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))
+       RETURNING object_type, object_id`, [this.service, jsonbParam(records), this.machineId(context)]);
+    if (result.rows.length !== records.length) {
+      throw new Error("Template checklist write was rejected before completion; no partial template was committed");
+    }
+  }
+  async deleteTemplateWithTasks(id, context = {}) {
+    await this.ensureSchema();
+    const timestamp = new Date().toISOString();
+    const result = await this.options.client.query(`/* todos:delete-template-with-tasks-atomic */ WITH target AS (
+         SELECT 1 FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'templates' AND object_id = $2 AND deleted_at IS NULL
+       ) UPDATE ${this.tableName} AS record SET
+         deleted_at = $3::timestamptz,
+         updated_at = $3::timestamptz,
+         source_machine_id = COALESCE($4, record.source_machine_id),
+         version = COALESCE(record.version, 0) + 1
+       WHERE record.service = $1 AND record.deleted_at IS NULL AND EXISTS (SELECT 1 FROM target)
+         AND (record.object_type = 'templates' AND record.object_id = $2
+           OR record.object_type = 'template_tasks' AND record.payload->>'template_id' = $2)
+       RETURNING record.object_type`, [this.service, id, timestamp, this.machineId(context)]);
+    return result.rows.some((row) => row.object_type === "templates");
+  }
   async completeTask(id, agentId, options) {
     await this.ensureSchema();
     const operationTimestamp = new Date().toISOString();
@@ -28669,7 +28983,7 @@ async function updateTaskList2(id, input, store) {
 }
 async function createTemplate2(input, store, context) {
   const timestamp = new Date().toISOString();
-  return store.upsert("templates", {
+  const template = {
     id: randomUUID3(),
     name: input.name,
     title_pattern: input.title_pattern,
@@ -28684,7 +28998,30 @@ async function createTemplate2(input, store, context) {
     created_at: timestamp,
     machine_id: store.machineId(context),
     synced_at: null
-  }, context);
+  };
+  const tasks = buildTemplateTasks(template.id, input.tasks ?? [], timestamp);
+  await store.createTemplateWithTasks(template, tasks, context);
+  return template;
+}
+function buildTemplateTasks(templateId, inputs, timestamp) {
+  return inputs.map((input, position) => ({
+    id: randomUUID3(),
+    template_id: templateId,
+    position,
+    title_pattern: input.title_pattern,
+    description: input.description ?? null,
+    priority: input.priority ?? "medium",
+    tags: input.tags ?? [],
+    task_type: input.task_type ?? null,
+    condition: input.condition ?? null,
+    include_template_id: input.include_template_id ?? null,
+    depends_on_positions: input.depends_on ?? [],
+    metadata: input.metadata ?? {},
+    created_at: timestamp
+  }));
+}
+async function deleteTemplate2(id, store, context) {
+  return store.deleteTemplateWithTasks(id, context);
 }
 async function updateTemplate2(id, input, store) {
   const template = await store.get("templates", id);
@@ -28740,6 +29077,7 @@ async function exportSnapshot(store) {
     agents: await store.list("agents"),
     taskLists: await store.list("task_lists"),
     templates: await store.list("templates"),
+    templateTasks: await store.list("template_tasks"),
     auditHistory: await store.list("audit_history"),
     tombstones: await store.listTombstones()
   };
@@ -28764,6 +29102,7 @@ async function importSnapshot(snapshot, store, context) {
     ...snapshot.agents.map((row) => ["agents", row]),
     ...snapshot.taskLists.map((row) => ["task_lists", row]),
     ...snapshot.templates.map((row) => ["templates", row]),
+    ...(snapshot.templateTasks ?? []).map((row) => ["template_tasks", row]),
     ...snapshot.auditHistory.map((row) => ["audit_history", row])
   ];
   for (const [type, row] of entries) {
@@ -29173,12 +29512,16 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         TaskList: taskListSchema,
         TaskComment: taskCommentSchema,
         Plan: planSchema,
+        Template: templateSchema,
+        TemplateTask: templateTaskSchema,
+        TemplateVariable: templateVariableSchema,
+        CreateTemplateTaskInput: createTemplateTaskInputSchema,
         CreateTaskInput: {
           type: "object",
           required: ["title"],
           properties: {
             title: { type: "string" },
-            description: { type: "string" },
+            description: { type: "string", nullable: true },
             status: { type: "string" },
             priority: { type: "string" },
             project_id: { type: "string" },
@@ -29313,6 +29656,39 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             agent_id: { type: "string", minLength: 1 },
             status: { type: "string", enum: ["active", "completed", "archived"] }
           }
+        },
+        CreateTemplateInput: {
+          type: "object",
+          additionalProperties: false,
+          required: ["name", "title_pattern"],
+          properties: {
+            name: { type: "string", minLength: 1 },
+            title_pattern: { type: "string", minLength: 1 },
+            description: { type: "string", nullable: true },
+            priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            tags: { type: "array", items: { type: "string", minLength: 1 } },
+            variables: { type: "array", items: { $ref: "#/components/schemas/TemplateVariable" } },
+            project_id: { type: "string", minLength: 1, nullable: true },
+            plan_id: { type: "string", minLength: 1, nullable: true },
+            metadata: { type: "object", additionalProperties: true },
+            tasks: { type: "array", items: { $ref: "#/components/schemas/CreateTemplateTaskInput" } }
+          }
+        },
+        UpdateTemplateInput: {
+          type: "object",
+          additionalProperties: false,
+          minProperties: 1,
+          properties: {
+            name: { type: "string", minLength: 1 },
+            title_pattern: { type: "string", minLength: 1 },
+            description: { type: "string", nullable: true },
+            priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+            tags: { type: "array", items: { type: "string", minLength: 1 } },
+            variables: { type: "array", items: { type: "object" } },
+            project_id: { type: "string", nullable: true },
+            plan_id: { type: "string", nullable: true },
+            metadata: { type: "object", additionalProperties: true }
+          }
         }
       }
     },
@@ -29615,6 +29991,41 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { deleted: { type: "boolean" }, id: { type: "string" } } } } } } }
         }
       },
+      "/v1/templates": {
+        get: {
+          operationId: "listTemplates",
+          summary: "List reusable task templates",
+          parameters: [{ name: "project_id", in: "query", schema: { type: "string" } }],
+          responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { templates: { type: "array", items: { $ref: "#/components/schemas/Template" } }, count: { type: "number" } } } } } } }
+        },
+        post: {
+          operationId: "createTemplate",
+          summary: "Create a reusable task template",
+          requestBody: { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/CreateTemplateInput" } } } },
+          responses: { "201": { content: { "application/json": { schema: { type: "object", properties: { template: { $ref: "#/components/schemas/Template" } } } } } } }
+        }
+      },
+      "/v1/templates/{id}": {
+        get: {
+          operationId: "getTemplate",
+          summary: "Get one reusable task template with its checklist steps",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { template: { $ref: "#/components/schemas/Template" } } } } } } }
+        },
+        patch: {
+          operationId: "updateTemplate",
+          summary: "Update reusable template metadata and defaults",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/UpdateTemplateInput" } } } },
+          responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { template: { $ref: "#/components/schemas/Template" } } } } } } }
+        },
+        delete: {
+          operationId: "deleteTemplate",
+          summary: "Delete a reusable task template and its checklist steps",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": { content: { "application/json": { schema: { type: "object", properties: { deleted: { type: "boolean" }, id: { type: "string" } } } } } } }
+        }
+      },
       "/v1/task-lists": {
         get: {
           operationId: "listTaskLists",
@@ -29692,6 +30103,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
                     agents: { type: "array", items: { type: "object" } },
                     taskLists: { type: "array", items: { type: "object" } },
                     templates: { type: "array", items: { type: "object" } },
+                    templateTasks: { type: "array", items: { $ref: "#/components/schemas/TemplateTask" } },
                     auditHistory: { type: "array", items: { type: "object" } },
                     tombstones: { type: "array", items: { type: "object" } }
                   }
@@ -29728,7 +30140,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     }
   };
 }
-var taskSchema, projectSchema, taskListSchema, taskCommentSchema, planSchema;
+var taskSchema, projectSchema, taskListSchema, taskCommentSchema, planSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
 var init_openapi = __esm(() => {
   init_package_version();
   taskSchema = {
@@ -29805,6 +30217,72 @@ var init_openapi = __esm(() => {
       updated_at: { type: "string", format: "date-time" }
     }
   };
+  templateTaskSchema = {
+    type: "object",
+    required: ["id", "template_id", "position", "title_pattern", "priority", "tags", "depends_on_positions", "metadata", "created_at"],
+    properties: {
+      id: { type: "string" },
+      template_id: { type: "string" },
+      position: { type: "integer", minimum: 0 },
+      title_pattern: { type: "string" },
+      description: { type: "string", nullable: true },
+      priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      tags: { type: "array", items: { type: "string" } },
+      task_type: { type: "string", nullable: true },
+      condition: { type: "string", nullable: true },
+      include_template_id: { type: "string", nullable: true },
+      depends_on_positions: { type: "array", items: { type: "integer", minimum: 0 } },
+      metadata: { type: "object", additionalProperties: true },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
+  templateSchema = {
+    type: "object",
+    required: ["id", "name", "title_pattern", "priority", "tags", "variables", "version", "metadata", "created_at"],
+    properties: {
+      id: { type: "string" },
+      name: { type: "string" },
+      title_pattern: { type: "string" },
+      description: { type: "string", nullable: true },
+      priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      tags: { type: "array", items: { type: "string" } },
+      variables: { type: "array", items: { type: "object", properties: { name: { type: "string" }, required: { type: "boolean" }, default: { type: "string" }, description: { type: "string" } } } },
+      version: { type: "integer", minimum: 1 },
+      project_id: { type: "string", nullable: true },
+      plan_id: { type: "string", nullable: true },
+      metadata: { type: "object", additionalProperties: true },
+      created_at: { type: "string", format: "date-time" },
+      tasks: { type: "array", items: { $ref: "#/components/schemas/TemplateTask" } }
+    }
+  };
+  templateVariableSchema = {
+    type: "object",
+    required: ["name", "required"],
+    properties: {
+      name: { type: "string" },
+      required: { type: "boolean" },
+      default: { type: "string" },
+      description: { type: "string" }
+    }
+  };
+  createTemplateTaskInputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["title_pattern"],
+    properties: {
+      position: { type: "integer", minimum: 0 },
+      title_pattern: { type: "string", minLength: 1 },
+      description: { type: "string", nullable: true },
+      priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      tags: { type: "array", items: { type: "string", minLength: 1 } },
+      task_type: { type: "string", nullable: true },
+      condition: { type: "string", nullable: true },
+      include_template_id: { type: "string", nullable: true },
+      depends_on: { type: "array", items: { type: "integer", minimum: 0 } },
+      depends_on_positions: { type: "array", items: { type: "integer", minimum: 0 } },
+      metadata: { type: "object", additionalProperties: true }
+    }
+  };
 });
 
 // src/server/v1.ts
@@ -29944,6 +30422,122 @@ function validatePlanCreate(value) {
     }
   };
 }
+function validateTemplateTask(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const body = value;
+  const allowed = new Set(["position", "title_pattern", "description", "priority", "tags", "task_type", "condition", "include_template_id", "depends_on", "depends_on_positions", "metadata"]);
+  if (Object.keys(body).some((key) => !allowed.has(key)))
+    return null;
+  if (typeof body.title_pattern !== "string" || !body.title_pattern.trim())
+    return null;
+  if (body.position !== undefined && (typeof body.position !== "number" || !Number.isSafeInteger(body.position) || body.position < 0))
+    return null;
+  if (body.description !== undefined && body.description !== null && typeof body.description !== "string")
+    return null;
+  if (body.priority !== undefined && (typeof body.priority !== "string" || !["low", "medium", "high", "critical"].includes(body.priority)))
+    return null;
+  if (body.tags !== undefined && (!Array.isArray(body.tags) || body.tags.some((tag) => typeof tag !== "string" || !tag.trim())))
+    return null;
+  for (const field of ["task_type", "condition", "include_template_id"]) {
+    if (body[field] !== undefined && body[field] !== null && (typeof body[field] !== "string" || !body[field].trim()))
+      return null;
+  }
+  if (body.depends_on !== undefined && body.depends_on_positions !== undefined)
+    return null;
+  const dependencies = body.depends_on ?? body.depends_on_positions;
+  if (dependencies !== undefined && (!Array.isArray(dependencies) || dependencies.some((position) => !Number.isSafeInteger(position) || position < 0)))
+    return null;
+  if (body.metadata !== undefined && (!body.metadata || typeof body.metadata !== "object" || Array.isArray(body.metadata)))
+    return null;
+  return {
+    title_pattern: body.title_pattern,
+    ...typeof body.description === "string" ? { description: body.description } : {},
+    ...typeof body.priority === "string" ? { priority: body.priority } : {},
+    ...Array.isArray(body.tags) ? { tags: body.tags } : {},
+    ...typeof body.task_type === "string" ? { task_type: body.task_type } : {},
+    ...typeof body.condition === "string" ? { condition: body.condition } : {},
+    ...typeof body.include_template_id === "string" ? { include_template_id: body.include_template_id } : {},
+    ...Array.isArray(dependencies) ? { depends_on: dependencies } : {},
+    ...body.metadata && typeof body.metadata === "object" && !Array.isArray(body.metadata) ? { metadata: body.metadata } : {}
+  };
+}
+function validateTemplateCreate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, message: "template body must be an object" };
+  const body = value;
+  const allowed = new Set(["name", "title_pattern", "description", "priority", "tags", "variables", "project_id", "plan_id", "metadata", "tasks"]);
+  const unknown = Object.keys(body).find((key) => !allowed.has(key));
+  if (unknown)
+    return { ok: false, message: `unknown template field: ${unknown}` };
+  if (typeof body.name !== "string" || !body.name.trim())
+    return { ok: false, message: "name must be a non-empty string" };
+  if (typeof body.title_pattern !== "string" || !body.title_pattern.trim())
+    return { ok: false, message: "title_pattern must be a non-empty string" };
+  if (body.description !== undefined && body.description !== null && typeof body.description !== "string")
+    return { ok: false, message: "description must be a string or null" };
+  if (body.priority !== undefined && (typeof body.priority !== "string" || !["low", "medium", "high", "critical"].includes(body.priority)))
+    return { ok: false, message: "priority must be low, medium, high, or critical" };
+  if (body.tags !== undefined && (!Array.isArray(body.tags) || body.tags.some((tag) => typeof tag !== "string" || !tag.trim())))
+    return { ok: false, message: "tags must be an array of non-empty strings" };
+  if (body.variables !== undefined && (!Array.isArray(body.variables) || body.variables.some((variable) => !variable || typeof variable !== "object" || Array.isArray(variable) || typeof variable.name !== "string" || !variable.name || typeof variable.required !== "boolean" || variable.default !== undefined && typeof variable.default !== "string" || variable.description !== undefined && typeof variable.description !== "string"))) {
+    return { ok: false, message: "variables must be valid template variable objects" };
+  }
+  for (const field of ["project_id", "plan_id"]) {
+    if (body[field] !== undefined && body[field] !== null && (typeof body[field] !== "string" || !body[field].trim()))
+      return { ok: false, message: `${field} must be a non-empty string or null` };
+  }
+  if (body.metadata !== undefined && (!body.metadata || typeof body.metadata !== "object" || Array.isArray(body.metadata)))
+    return { ok: false, message: "metadata must be an object" };
+  const tasks = body.tasks === undefined ? [] : Array.isArray(body.tasks) ? body.tasks.map(validateTemplateTask) : null;
+  if (tasks === null || tasks.some((task) => task === null))
+    return { ok: false, message: "tasks must be valid template task objects" };
+  const taskInputs = tasks;
+  for (const [position, task] of taskInputs.entries()) {
+    if ((task.depends_on ?? []).some((dependency) => dependency >= position)) {
+      return { ok: false, message: "template task dependencies must reference earlier task positions" };
+    }
+  }
+  return {
+    ok: true,
+    input: {
+      name: body.name,
+      title_pattern: body.title_pattern,
+      ...typeof body.description === "string" ? { description: body.description } : {},
+      ...typeof body.priority === "string" ? { priority: body.priority } : {},
+      ...Array.isArray(body.tags) ? { tags: body.tags } : {},
+      ...Array.isArray(body.variables) ? { variables: body.variables } : {},
+      ...typeof body.project_id === "string" ? { project_id: body.project_id } : {},
+      ...typeof body.plan_id === "string" ? { plan_id: body.plan_id } : {},
+      ...body.metadata && typeof body.metadata === "object" && !Array.isArray(body.metadata) ? { metadata: body.metadata } : {},
+      tasks: taskInputs
+    }
+  };
+}
+function validateTemplatePatch(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, message: "template patch must be an object" };
+  const body = value;
+  const allowed = new Set(["name", "title_pattern", "description", "priority", "tags", "variables", "project_id", "plan_id", "metadata"]);
+  const unknown = Object.keys(body).find((key) => !allowed.has(key));
+  if (unknown)
+    return { ok: false, message: `unknown template field: ${unknown}` };
+  if (Object.keys(body).length === 0)
+    return { ok: false, message: "template patch must not be empty" };
+  const templateLike = { name: body.name ?? "template", title_pattern: body.title_pattern ?? "template", ...body };
+  const validated = validateTemplateCreate(templateLike);
+  if (!validated.ok)
+    return validated;
+  const { name: _name, title_pattern: _title, tasks: _tasks, ...patch } = validated.input;
+  return { ok: true, patch: {
+    ...body.name !== undefined ? { name: validated.input.name } : {},
+    ...body.title_pattern !== undefined ? { title_pattern: validated.input.title_pattern } : {},
+    ...patch,
+    ...body.description === null ? { description: null } : {},
+    ...body.project_id === null ? { project_id: null } : {},
+    ...body.plan_id === null ? { plan_id: null } : {}
+  } };
+}
 async function readJson(req) {
   try {
     const text = await req.text();
@@ -30004,12 +30598,13 @@ function normalizeImportSnapshot(raw) {
     agents: arr(body["agents"]),
     taskLists: arr(body["taskLists"]),
     templates: arr(body["templates"]),
+    templateTasks: arr(body["templateTasks"]),
     auditHistory: arr(body["auditHistory"]),
     tombstones: arr(body["tombstones"])
   };
 }
 function countSnapshotRecords(s) {
-  return s.tasks.length + s.projects.length + (s.projectMachinePaths?.length ?? 0) + s.plans.length + s.agents.length + s.taskLists.length + s.templates.length + s.auditHistory.length + (s.tombstones?.length ?? 0);
+  return s.tasks.length + s.projects.length + (s.projectMachinePaths?.length ?? 0) + s.plans.length + s.agents.length + s.taskLists.length + s.templates.length + s.templateTasks.length + s.auditHistory.length + (s.tombstones?.length ?? 0);
 }
 async function handleV1Request(req, url, dependencies = {}) {
   const path = url.pathname;
@@ -30579,6 +31174,40 @@ async function handleV1Request(req, url, dependencies = {}) {
       if (id)
         return error(405, `method ${method} not allowed on /v1/plans/:id`);
     }
+    if (resource === "templates") {
+      if (!id && method === "GET") {
+        const projectId = url.searchParams.get("project_id");
+        const templates = (await store.templates.list()).filter((template) => projectId === null || template.project_id === projectId);
+        return json2({ templates, count: templates.length });
+      }
+      if (!id && method === "POST") {
+        const body = await readJson(req);
+        const validated = validateTemplateCreate(body);
+        if (!validated.ok)
+          return error(400, validated.message);
+        const template = await store.templates.create(validated.input, contextFromPrincipal(principal));
+        return json2({ template: await store.templates.getWithTasks(template.id) }, 201);
+      }
+      if (!id)
+        return error(405, `method ${method} not allowed on /v1/templates`);
+      if (method === "GET") {
+        const template = await store.templates.getWithTasks(id);
+        return template ? json2({ template }) : error(404, "template not found");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const body = await readJson(req);
+        const validated = validateTemplatePatch(body);
+        if (!validated.ok)
+          return error(400, validated.message);
+        const template = await store.templates.update(id, validated.patch, contextFromPrincipal(principal));
+        return template ? json2({ template: await store.templates.getWithTasks(id) }) : error(404, "template not found");
+      }
+      if (method === "DELETE") {
+        const deleted = await store.templates.delete(id, contextFromPrincipal(principal));
+        return deleted ? json2({ deleted: true, id }) : error(404, "template not found");
+      }
+      return error(405, `method ${method} not allowed on /v1/templates/:id`);
+    }
     if (resource === "agents") {
       if (!id && method === "GET") {
         const agents = await store.agents.list();
@@ -53808,9 +54437,9 @@ ${task2.id.slice(0, 8)} | ${task2.priority} | ${task2.title}` }] };
   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 { deleteTemplate: deleteTemplate3 } = await Promise.resolve().then(() => (init_templates(), exports_templates));
         const resolvedId = resolveId(id, "task_templates");
-        const deleted = deleteTemplate2(resolvedId);
+        const deleted = deleteTemplate3(resolvedId);
         return { content: [{ type: "text", text: deleted ? "Template deleted." : "Template not found." }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -69258,6 +69887,7 @@ function emptySnapshot2() {
     agents: [],
     taskLists: [],
     templates: [],
+    templateTasks: [],
     auditHistory: [],
     tombstones: []
   };
@@ -69446,6 +70076,7 @@ var init_shadow = __esm(() => {
     agents: "agents",
     taskLists: "task_lists",
     templates: "templates",
+    templateTasks: "template_tasks",
     auditHistory: "audit_history"
   };
 });
@@ -71476,6 +72107,8 @@ var REMOTE_COMMANDS = new Set([
   "task",
   "task-lists",
   "timeline",
+  "template-import",
+  "templates",
   "tl",
   "unlock",
   "update"