@hasna/todos 0.11.93 → 0.11.95

package/dist/mcp/index.js

@@ -11043,6 +11043,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, {
@@ -11138,6 +11182,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) {
@@ -11269,34 +11321,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();
@@ -11369,29 +11394,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();
@@ -16658,6 +16664,7 @@ var init_token_utils = __esm(() => {
 
 // src/cli/cloud-router.ts
 import { resolveStorageClient } from "@hasna/contracts/client/storage";
+import { resolve as resolvePath } from "path";
 function cleanMode(value) {
   const normalized = value?.trim().toLowerCase();
   return normalized || null;
@@ -16940,6 +16947,39 @@ async function cloudListProjects(client) {
   const envelope = res.raw;
   return Array.isArray(envelope?.projects) ? envelope.projects : res.items;
 }
+function cloudProjectSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function cloudProjectPathBasename(value) {
+  return value.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? value;
+}
+function uniqueProjectMatches(projects, predicate) {
+  return [...new Map(projects.filter(predicate).map((project) => [project.id, project])).values()];
+}
+function resolveCloudProjectRef(projects, ref) {
+  const input = ref.trim();
+  const normalizedRef = input.toLowerCase();
+  const pathLike = input.startsWith(".") || input.includes("/") || input.includes("\\");
+  const normalizedPath = pathLike ? resolvePath(input) : undefined;
+  const slug = cloudProjectSlug(pathLike ? cloudProjectPathBasename(input) : input);
+  const matchGroups = [
+    uniqueProjectMatches(projects, (project) => project.id.toLowerCase() === normalizedRef),
+    uniqueProjectMatches(projects, (project) => project.path === input || normalizedPath !== undefined && resolvePath(project.path) === normalizedPath),
+    uniqueProjectMatches(projects, (project) => project.name.toLowerCase() === normalizedRef),
+    uniqueProjectMatches(projects, (project) => project.task_list_id === input || cloudProjectSlug(project.name) === slug || cloudProjectSlug(cloudProjectPathBasename(project.path)) === slug),
+    uniqueProjectMatches(projects, (project) => project.id.toLowerCase().startsWith(normalizedRef))
+  ];
+  for (const matches of matchGroups) {
+    if (matches.length === 1)
+      return matches[0].id;
+    if (matches.length > 1)
+      throw new Error(`Project reference is ambiguous: "${input}"`);
+  }
+  throw new Error(`Project not found: "${input}"`);
+}
+async function cloudResolveProjectRef(client, ref) {
+  return resolveCloudProjectRef(await cloudListProjects(client), ref);
+}
 async function cloudAddComment(client, taskId, input) {
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(taskId)}/comments`, input);
   const comment = raw && typeof raw === "object" && "comment" in raw ? raw.comment : raw;
@@ -16984,9 +17024,46 @@ async function cloudReleaseAgent(client, idOrName, sessionId) {
   const env = raw ?? {};
   return { agent: env.agent ?? null, released: env.released !== false };
 }
-var CLOUD_MODES, VALID_STORAGE_MODES, completionCapabilityCache;
+async function cloudListTaskLists(client, projectId) {
+  const query = projectId ? { project_id: projectId } : {};
+  const raw = await requiredRemoteRoute(client, "/v1/task-lists", () => client.transport.get("/task-lists", { query }));
+  const envelope = raw ?? {};
+  if (Array.isArray(envelope.task_lists))
+    return envelope.task_lists;
+  if (Array.isArray(envelope.taskLists))
+    return envelope.taskLists;
+  return Array.isArray(raw) ? raw : [];
+}
+async function cloudResolveTaskListRef(client, ref, projectId) {
+  const input = ref.trim();
+  const normalizedIdRef = input.toLowerCase();
+  if (UUID_RE.test(input) && !projectId)
+    return normalizedIdRef;
+  const lists = await cloudListTaskLists(client, projectId);
+  const exactIds = lists.filter((list) => list.id.toLowerCase() === normalizedIdRef);
+  if (exactIds.length === 1)
+    return exactIds[0].id;
+  if (exactIds.length > 1) {
+    throw new Error(`Task list reference is ambiguous: "${input}"`);
+  }
+  const slugs = lists.filter((list) => list.slug === input);
+  if (slugs.length === 1)
+    return slugs[0].id;
+  if (slugs.length > 1) {
+    throw new Error(`Task list reference is ambiguous: "${input}"`);
+  }
+  const prefixes = lists.filter((list) => list.id.toLowerCase().startsWith(normalizedIdRef));
+  if (prefixes.length === 1)
+    return prefixes[0].id;
+  if (prefixes.length > 1) {
+    throw new Error(`Task list reference is ambiguous: "${input}"`);
+  }
+  throw new Error(`Task list not found: "${input}"`);
+}
+var UUID_RE, CLOUD_MODES, VALID_STORAGE_MODES, completionCapabilityCache;
 var init_cloud_router = __esm(() => {
   init_redaction();
+  UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   CLOUD_MODES = new Set(["self_hosted", "cloud", "remote", "hybrid"]);
   VALID_STORAGE_MODES = new Set(["local", ...CLOUD_MODES]);
   completionCapabilityCache = new Map;
@@ -17273,6 +17350,17 @@ ${task.description}` : null
             patch.estimated_minutes = estimate;
           if (deadline !== undefined)
             patch.due_at = deadline;
+          if (typeof patch.project_id === "string" && patch.project_id) {
+            patch.project_id = await cloudResolveProjectRef(cloud, patch.project_id);
+          }
+          if (typeof patch.task_list_id === "string" && patch.task_list_id) {
+            let scope = typeof patch.project_id === "string" ? patch.project_id : undefined;
+            if (!scope) {
+              const current = await cloudGetTask(cloud, task_id2);
+              scope = current?.project_id ?? undefined;
+            }
+            patch.task_list_id = await cloudResolveTaskListRef(cloud, patch.task_list_id, scope);
+          }
           if (version2 !== undefined)
             patch.version = version2;
           const updated = await cloudUpdateTask(cloud, task_id2, patch);
@@ -23286,6 +23374,63 @@ function registerTaskProjectTools(server, ctx) {
       }
     });
   }
+  if (shouldRegisterTool("move_task")) {
+    server.tool("move_task", "Re-parent a task to another project and/or task list, preserving its id and history. " + "A task list is project-scoped, so moving to a new project detaches the old list unless to_list is given.", {
+      task_id: exports_external.string().describe("Task ID"),
+      to_project: exports_external.string().optional().describe("Destination project ID, slug, or path"),
+      to_list: exports_external.string().optional().describe("Destination task list (UUID, or slug resolved in the destination project)"),
+      clear_list: exports_external.boolean().optional().describe("Detach from its task list (set task_list_id to null)"),
+      version: exports_external.number().optional().describe("Expected version for optimistic locking")
+    }, async ({ task_id, to_project, to_list, clear_list, version }) => {
+      try {
+        if (!to_project && !to_list && !clear_list) {
+          throw new Error("Nothing to move: pass to_project, to_list, or clear_list.");
+        }
+        if (to_list && clear_list) {
+          throw new Error("Use either to_list or clear_list, not both.");
+        }
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const current2 = await cloudGetTask(cloud, task_id);
+          if (!current2)
+            throw new Error(`Task not found: ${task_id}`);
+          const targetProjectId2 = to_project ? await cloudResolveProjectRef(cloud, to_project) : undefined;
+          const scope = targetProjectId2 ?? current2.project_id ?? undefined;
+          const patch = {};
+          if (targetProjectId2 !== undefined)
+            patch.project_id = targetProjectId2;
+          if (to_list)
+            patch.task_list_id = await cloudResolveTaskListRef(cloud, to_list, scope);
+          else if (clear_list)
+            patch.task_list_id = null;
+          else if (targetProjectId2 && targetProjectId2 !== current2.project_id)
+            patch.task_list_id = null;
+          if (version !== undefined)
+            patch.version = version;
+          const task2 = await cloudUpdateTask(cloud, task_id, patch);
+          return { content: [{ type: "text", text: formatTask(task2) }] };
+        }
+        const resolvedId = resolveId(task_id);
+        const current = getTask(resolvedId);
+        if (!current)
+          throw new Error(`Task not found: ${task_id}`);
+        const targetProjectId = to_project ? resolveId(to_project, "projects") : undefined;
+        const updates = {};
+        if (targetProjectId !== undefined)
+          updates.project_id = targetProjectId;
+        if (to_list)
+          updates.task_list_id = resolveId(to_list, "task_lists");
+        else if (clear_list)
+          updates.task_list_id = null;
+        else if (targetProjectId && targetProjectId !== current.project_id)
+          updates.task_list_id = null;
+        const task = updateWithOptionalVersion(resolvedId, updates, version);
+        return { content: [{ type: "text", text: formatTask(task) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
   if (shouldRegisterTool("reschedule_task")) {
     server.tool("reschedule_task", "Update a task's deadline.", {
       task_id: exports_external.string().describe("Task ID"),
@@ -27608,6 +27753,7 @@ function registerTaskMetaTools(server, ctx) {
           complete_task: "complete_task \u2014 Mark task completed. Params: task_id, confidence, completed_at, version",
           cancel_task: "cancel_task \u2014 Cancel a task. Params: task_id, version",
           reassign_task: "reassign_task \u2014 Change task assignee. Params: task_id, new_assignee, version",
+          move_task: "move_task \u2014 Re-parent a task to another project and/or task list (keeps its id and history). Params: task_id (required), to_project, to_list, clear_list, version",
           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",
@@ -30647,7 +30793,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.11.93",
+    version: "0.11.95",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -39991,6 +40137,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)
   };
@@ -40040,6 +40187,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);
@@ -40144,6 +40292,8 @@ function tableForTombstone(objectType2) {
     return "task_lists";
   if (objectType2 === "templates")
     return "task_templates";
+  if (objectType2 === "template_tasks")
+    return "template_tasks";
   return "task_history";
 }
 function listRows(db, table, columns) {
@@ -40180,7 +40330,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();
@@ -40274,6 +40424,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",
@@ -40342,7 +40507,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"]);
 });
 
@@ -40732,6 +40897,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,
@@ -40783,6 +40949,7 @@ function rowsToSnapshot(rows) {
     agents: [],
     taskLists: [],
     templates: [],
+    templateTasks: [],
     auditHistory: [],
     tombstones: []
   };
@@ -40817,6 +40984,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);
   }
@@ -41034,6 +41203,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;
@@ -41100,6 +41272,7 @@ function emptySnapshot() {
     agents: [],
     taskLists: [],
     templates: [],
+    templateTasks: [],
     auditHistory: [],
     tombstones: []
   };
@@ -42299,10 +42472,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((task2) => task2.template_id === id).sort((left, right) => left.position - right.position || left.id.localeCompare(right.id));
+        return { ...template, tasks };
       }
     },
     audit: {
@@ -42590,6 +42766,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((task2) => ({ object_type: "template_tasks", object_id: task2.id, payload: task2, updated_at: task2.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 timestamp3 = 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, timestamp3, 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();
@@ -42930,7 +43157,7 @@ async function updateTask2(id, input, store) {
     tags: input.tags ?? existing.tags,
     metadata: input.metadata ?? existing.metadata,
     requires_approval: input.requires_approval ?? existing.requires_approval,
-    task_list_id: input.task_list_id ?? existing.task_list_id
+    task_list_id: input.task_list_id !== undefined ? input.task_list_id : existing.task_list_id
   };
   await store.upsert("tasks", task2);
   return task2;
@@ -43352,7 +43579,7 @@ async function updateTaskList2(id, input, store) {
 }
 async function createTemplate2(input, store, context) {
   const timestamp3 = new Date().toISOString();
-  return store.upsert("templates", {
+  const template = {
     id: randomUUID3(),
     name: input.name,
     title_pattern: input.title_pattern,
@@ -43367,7 +43594,30 @@ async function createTemplate2(input, store, context) {
     created_at: timestamp3,
     machine_id: store.machineId(context),
     synced_at: null
-  }, context);
+  };
+  const tasks = buildTemplateTasks(template.id, input.tasks ?? [], timestamp3);
+  await store.createTemplateWithTasks(template, tasks, context);
+  return template;
+}
+function buildTemplateTasks(templateId, inputs, timestamp3) {
+  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: timestamp3
+  }));
+}
+async function deleteTemplate2(id, store, context) {
+  return store.deleteTemplateWithTasks(id, context);
 }
 async function updateTemplate2(id, input, store) {
   const template = await store.get("templates", id);
@@ -43423,6 +43673,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()
   };
@@ -43447,6 +43698,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) {
@@ -43853,12 +44105,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" },
@@ -43875,6 +44131,8 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             status: { type: "string" },
             priority: { type: "string" },
             assigned_to: { type: "string" },
+            project_id: { type: "string", nullable: true },
+            task_list_id: { type: "string", nullable: true },
             version: { type: "number" }
           }
         },
@@ -43991,6 +44249,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 }
+          }
         }
       }
     },
@@ -44293,6 +44584,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",
@@ -44370,6 +44696,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" } }
                   }
@@ -44406,7 +44733,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 = {
@@ -44483,6 +44810,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
@@ -44622,6 +45015,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((task2) => task2 === null))
+    return { ok: false, message: "tasks must be valid template task objects" };
+  const taskInputs = tasks;
+  for (const [position, task2] of taskInputs.entries()) {
+    if ((task2.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 text2 = await req.text();
@@ -44682,12 +45191,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;
@@ -45257,6 +45767,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();