@hasna/todos 0.11.42 → 0.11.44

package/dist/index.js

@@ -2538,6 +2538,50 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "environment_snapshot",
+    name: "Environment Snapshot",
+    description: "Local reproducibility snapshot for task and run verification context.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Snapshot schema version."),
+      id: field("string", "Content-derived snapshot identifier."),
+      captured_at: isoDateField,
+      root: field("string", "Canonical local project root inspected."),
+      machine: field("object", "Local hostname, platform, and architecture metadata."),
+      target: field("object", "Optional task, run, and agent attachment IDs."),
+      runtime: field("object", "Bun, Node, and executable metadata."),
+      package_manager: field("object", "Detected package manager, lockfile hashes, and redacted manifests."),
+      git: field("object", "Local git branch, commit, dirty state, and porcelain status."),
+      config_hashes: field("array", "SHA-256 hashes of relevant local config files."),
+      command_env: field("object", "Redacted command and environment metadata."),
+      warnings: field("array", "Warnings about missing or unavailable local data.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "environment_snapshot_comparison",
+    name: "Environment Snapshot Comparison",
+    description: "Drift summary returned when comparing two local environment snapshots.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Comparison schema version."),
+      left_id: field("string", "Left snapshot ID."),
+      right_id: field("string", "Right snapshot ID."),
+      same_root: field("boolean", "Whether both snapshots were captured for the same root."),
+      same_machine: field("boolean", "Whether hostname, platform, and architecture match."),
+      same_runtime: field("boolean", "Whether Bun and Node versions match."),
+      same_git_commit: field("boolean", "Whether git commit IDs match."),
+      dirty_state_changed: field("boolean", "Whether the git dirty flag changed."),
+      changed_config_hashes: field("array", "Changed config hash records."),
+      changed_lockfiles: field("array", "Changed lockfile hash records."),
+      changed_manifests: field("array", "Changed manifest hash records."),
+      warnings: field("array", "Comparison warnings.")
+    },
+    optional: {}
+  }),
   contract({
     id: "local_event_hook",
     name: "Local Event Hook",
@@ -7393,6 +7437,8 @@ var MCP_TOOL_GROUPS = {
     "check_file_lock",
     "create_comment",
     "create_handoff",
+    "capture_environment_snapshot",
+    "compare_environment_snapshots",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",
@@ -7515,10 +7561,12 @@ var MCP_TOOL_GROUPS = {
     "export_template",
     "import_template",
     "init_templates",
+    "list_template_library",
     "list_templates",
     "preview_template",
     "template_history",
-    "update_template"
+    "update_template",
+    "write_template_library"
   ],
   webhooks: ["create_webhook", "delete_webhook", "list_webhooks"],
   machines: [
@@ -8033,6 +8081,39 @@ var TODOS_CLI_MCP_PARITY = [
       mcpTool: "create_plan"
     }
   },
+  {
+    domain: "templates",
+    cliCommands: [
+      "todos template-library",
+      "todos template-init",
+      "todos template-preview",
+      "todos templates --use",
+      "todos template-export",
+      "todos template-import",
+      "todos template-history"
+    ],
+    mcpTools: [
+      "list_template_library",
+      "write_template_library",
+      "init_templates",
+      "preview_template",
+      "create_task_from_template",
+      "create_template",
+      "list_templates",
+      "update_template",
+      "delete_template",
+      "export_template",
+      "import_template",
+      "template_history"
+    ],
+    jsonContracts: ["template", "task", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    example: {
+      cli: "todos template-library --json",
+      mcpTool: "list_template_library"
+    }
+  },
   {
     domain: "workspace-trust",
     cliCommands: [
@@ -8332,6 +8413,18 @@ var TODOS_CLI_MCP_PARITY = [
       mcpTool: "build_agent_context_pack"
     }
   },
+  {
+    domain: "environment-snapshots",
+    cliCommands: ["todos env-snapshot"],
+    mcpTools: ["capture_environment_snapshot", "compare_environment_snapshots"],
+    jsonContracts: ["environment_snapshot", "environment_snapshot_comparison", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    example: {
+      cli: "todos env-snapshot capture --task 1234abcd --json",
+      mcpTool: "capture_environment_snapshot"
+    }
+  },
   {
     domain: "imports",
     cliCommands: [
@@ -10381,10 +10474,141 @@ function clearActiveModel() {
 }
 // src/db/builtin-templates.ts
 init_database();
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21";
+var BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library";
 var BUILTIN_TEMPLATES = [
+  {
+    name: "bug-fix",
+    description: "Reproduce, diagnose, fix, test, and release a defect.",
+    category: "bug-fix",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "bug", required: true, description: "Bug description" }],
+    tasks: [
+      { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical", tags: ["bug", "repro"] },
+      { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", tags: ["bug", "diagnosis"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Write regression test for {bug}", priority: "high", tags: ["bug", "test"], depends_on_positions: [1] },
+      { position: 3, title_pattern: "Implement fix for {bug}", priority: "critical", tags: ["bug", "implementation"], depends_on_positions: [2] },
+      { position: 4, title_pattern: "Run full verification for {bug}", priority: "high", tags: ["bug", "verification"], depends_on_positions: [3] },
+      { position: 5, title_pattern: "Publish and smoke test fix for {bug}", priority: "high", tags: ["bug", "release"], depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "feature-implementation",
+    description: "Plan, build, test, document, and release a product feature.",
+    category: "feature",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [
+      { name: "feature", required: true, description: "Feature name" },
+      { name: "scope", required: false, default: "medium", description: "Implementation size or risk" }
+    ],
+    tasks: [
+      { position: 0, title_pattern: "Define acceptance criteria for {feature}", priority: "high", tags: ["feature", "spec"] },
+      { position: 1, title_pattern: "Design {scope} implementation plan for {feature}", priority: "high", tags: ["feature", "design"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Implement {feature}", priority: "critical", tags: ["feature", "implementation"], depends_on_positions: [1] },
+      { position: 3, title_pattern: "Add tests for {feature}", priority: "high", tags: ["feature", "test"], depends_on_positions: [2] },
+      { position: 4, title_pattern: "Update docs for {feature}", priority: "medium", tags: ["feature", "docs"], depends_on_positions: [2] },
+      { position: 5, title_pattern: "Run release checks for {feature}", priority: "high", tags: ["feature", "verification"], depends_on_positions: [3, 4] }
+    ]
+  },
+  {
+    name: "security-review",
+    description: "Threat model, test, remediate, and report on security posture.",
+    category: "security",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "target", required: true, description: "System, package, or change under review" }],
+    tasks: [
+      { position: 0, title_pattern: "Map trust boundaries for {target}", priority: "critical", tags: ["security", "threat-model"] },
+      { position: 1, title_pattern: "Scan {target} for vulnerabilities and secret exposure", priority: "critical", tags: ["security", "scan"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Review authz, data access, and dependency risks in {target}", priority: "critical", tags: ["security", "review"], depends_on_positions: [0] },
+      { position: 3, title_pattern: "Fix critical security findings in {target}", priority: "critical", tags: ["security", "fix"], depends_on_positions: [1, 2] },
+      { position: 4, title_pattern: "Retest {target} security fixes", priority: "high", tags: ["security", "verification"], depends_on_positions: [3] },
+      { position: 5, title_pattern: "Write local security review report for {target}", priority: "medium", tags: ["security", "report"], depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "release",
+    description: "Prepare, verify, publish, install, and smoke test a package release.",
+    category: "release",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [
+      { name: "package", required: true, description: "Package name" },
+      { name: "version", required: false, default: "patch", description: "Release version or bump type" }
+    ],
+    tasks: [
+      { position: 0, title_pattern: "Prepare {package} {version} release notes", priority: "medium", tags: ["release", "docs"] },
+      { position: 1, title_pattern: "Run full tests for {package}", priority: "critical", tags: ["release", "test"] },
+      { position: 2, title_pattern: "Run build and release verification for {package}", priority: "critical", tags: ["release", "verification"], depends_on_positions: [1] },
+      { position: 3, title_pattern: "Scan {package} release diff for secrets", priority: "critical", tags: ["release", "security"], depends_on_positions: [2] },
+      { position: 4, title_pattern: "Publish {package} {version}", priority: "high", tags: ["release", "publish"], depends_on_positions: [3] },
+      { position: 5, title_pattern: "Install and smoke test published {package}", priority: "high", tags: ["release", "smoke"], depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "migration",
+    description: "Plan, test, apply, and verify a schema or data migration.",
+    category: "migration",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "migration", required: true, description: "Migration name or objective" }],
+    tasks: [
+      { position: 0, title_pattern: "Design migration plan for {migration}", priority: "critical", tags: ["migration", "plan"] },
+      { position: 1, title_pattern: "Write rollback plan for {migration}", priority: "critical", tags: ["migration", "rollback"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Implement migration {migration}", priority: "critical", tags: ["migration", "implementation"], depends_on_positions: [0] },
+      { position: 3, title_pattern: "Test migration {migration} on fixture data", priority: "high", tags: ["migration", "test"], depends_on_positions: [2] },
+      { position: 4, title_pattern: "Run migration {migration} verification and drift checks", priority: "high", tags: ["migration", "verification"], depends_on_positions: [1, 3] },
+      { position: 5, title_pattern: "Document migration {migration} evidence", priority: "medium", tags: ["migration", "docs"], depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "incident",
+    description: "Triage, mitigate, repair, verify, and retrospect an incident.",
+    category: "incident",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "incident", required: true, description: "Incident summary" }],
+    tasks: [
+      { position: 0, title_pattern: "Triage incident: {incident}", priority: "critical", tags: ["incident", "triage"] },
+      { position: 1, title_pattern: "Mitigate customer impact for {incident}", priority: "critical", tags: ["incident", "mitigation"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Diagnose root cause for {incident}", priority: "critical", tags: ["incident", "diagnosis"], depends_on_positions: [0] },
+      { position: 3, title_pattern: "Implement durable repair for {incident}", priority: "critical", tags: ["incident", "repair"], depends_on_positions: [2] },
+      { position: 4, title_pattern: "Verify recovery from {incident}", priority: "high", tags: ["incident", "verification"], depends_on_positions: [1, 3] },
+      { position: 5, title_pattern: "Write retrospective for {incident}", priority: "medium", tags: ["incident", "retro"], depends_on_positions: [4] }
+    ]
+  },
+  {
+    name: "docs-refresh",
+    description: "Audit, update, validate, and publish documentation changes.",
+    category: "docs",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "area", required: true, description: "Documentation area or product surface" }],
+    tasks: [
+      { position: 0, title_pattern: "Audit current docs for {area}", priority: "medium", tags: ["docs", "audit"] },
+      { position: 1, title_pattern: "Update examples and commands for {area}", priority: "medium", tags: ["docs", "examples"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Validate docs snippets for {area}", priority: "high", tags: ["docs", "verification"], depends_on_positions: [1] },
+      { position: 3, title_pattern: "Refresh screenshots or generated artifacts for {area}", priority: "medium", tags: ["docs", "assets"], depends_on_positions: [1] },
+      { position: 4, title_pattern: "Publish docs refresh for {area}", priority: "medium", tags: ["docs", "release"], depends_on_positions: [2, 3] }
+    ]
+  },
+  {
+    name: "qa",
+    description: "Build a focused QA plan, execute checks, file defects, and sign off.",
+    category: "qa",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
+    variables: [{ name: "target", required: true, description: "Feature, release, or workflow under QA" }],
+    tasks: [
+      { position: 0, title_pattern: "Create QA matrix for {target}", priority: "high", tags: ["qa", "plan"] },
+      { position: 1, title_pattern: "Run happy-path QA for {target}", priority: "high", tags: ["qa", "manual"], depends_on_positions: [0] },
+      { position: 2, title_pattern: "Run edge-case QA for {target}", priority: "high", tags: ["qa", "edge-cases"], depends_on_positions: [0] },
+      { position: 3, title_pattern: "File and dedupe QA defects for {target}", priority: "medium", tags: ["qa", "bugs"], depends_on_positions: [1, 2] },
+      { position: 4, title_pattern: "Verify QA fixes for {target}", priority: "high", tags: ["qa", "verification"], depends_on_positions: [3] },
+      { position: 5, title_pattern: "Record QA signoff for {target}", priority: "medium", tags: ["qa", "signoff"], depends_on_positions: [4] }
+    ]
+  },
   {
     name: "open-source-project",
     description: "Full open-source project bootstrap \u2014 scaffold to publish",
+    category: "open-source",
+    version: BUILTIN_TEMPLATE_LIBRARY_VERSION,
     variables: [
       { name: "name", required: true, description: "Service name" },
       { name: "org", required: false, default: "hasna", description: "GitHub org" }
@@ -10404,47 +10628,73 @@ var BUILTIN_TEMPLATES = [
       { position: 11, title_pattern: "Publish @hasna/{name} to npm", priority: "high", depends_on_positions: [6, 7, 8] },
       { position: 12, title_pattern: "Install @hasna/{name} globally and verify", priority: "medium", depends_on_positions: [11] }
     ]
-  },
-  {
-    name: "bug-fix",
-    description: "Standard bug fix workflow",
-    variables: [{ name: "bug", required: true, description: "Bug description" }],
-    tasks: [
-      { position: 0, title_pattern: "Reproduce: {bug}", priority: "critical" },
-      { position: 1, title_pattern: "Diagnose root cause of {bug}", priority: "critical", depends_on_positions: [0] },
-      { position: 2, title_pattern: "Implement fix for {bug}", priority: "critical", depends_on_positions: [1] },
-      { position: 3, title_pattern: "Write regression test for {bug}", priority: "high", depends_on_positions: [2] },
-      { position: 4, title_pattern: "Publish fix and verify in production", priority: "high", depends_on_positions: [3] }
-    ]
-  },
-  {
-    name: "feature",
-    description: "Standard feature development workflow",
-    variables: [{ name: "feature", required: true }, { name: "scope", required: false, default: "medium" }],
-    tasks: [
-      { position: 0, title_pattern: "Write spec for {feature}", priority: "high" },
-      { position: 1, title_pattern: "Design implementation approach for {feature}", priority: "high", depends_on_positions: [0] },
-      { position: 2, title_pattern: "Implement {feature}", priority: "critical", depends_on_positions: [1] },
-      { position: 3, title_pattern: "Write tests for {feature}", priority: "high", depends_on_positions: [2] },
-      { position: 4, title_pattern: "Code review for {feature}", priority: "medium", depends_on_positions: [3] },
-      { position: 5, title_pattern: "Update docs for {feature}", priority: "medium", depends_on_positions: [2] },
-      { position: 6, title_pattern: "Deploy {feature}", priority: "high", depends_on_positions: [4] }
-    ]
-  },
-  {
-    name: "security-audit",
-    description: "Security audit workflow",
-    variables: [{ name: "target", required: true }],
-    tasks: [
-      { position: 0, title_pattern: "Scan {target} for vulnerabilities", priority: "critical" },
-      { position: 1, title_pattern: "Review {target} security findings", priority: "critical", depends_on_positions: [0] },
-      { position: 2, title_pattern: "Fix critical issues in {target}", priority: "critical", depends_on_positions: [1] },
-      { position: 3, title_pattern: "Retest {target} after fixes", priority: "high", depends_on_positions: [2] },
-      { position: 4, title_pattern: "Write security report for {target}", priority: "medium", depends_on_positions: [3] },
-      { position: 5, title_pattern: "Close audit for {target}", priority: "low", depends_on_positions: [4] }
-    ]
   }
 ];
+function templateMetadata(template) {
+  return {
+    source: BUILTIN_TEMPLATE_LIBRARY_SOURCE,
+    library_version: template.version,
+    category: template.category,
+    template_file: `${template.name}.json`,
+    local_only: true,
+    marketplace_free: true
+  };
+}
+function listBuiltinTemplates() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    ...template,
+    variables: template.variables.map((variable) => ({ ...variable })),
+    tasks: template.tasks.map((task) => ({ ...task, tags: task.tags ? [...task.tags] : undefined }))
+  }));
+}
+function getBuiltinTemplate(name) {
+  return listBuiltinTemplates().find((template) => template.name === name) ?? null;
+}
+function exportBuiltinTemplate(name) {
+  const template = getBuiltinTemplate(name);
+  if (!template)
+    throw new Error(`Built-in template not found: ${name}`);
+  return {
+    name: template.name,
+    title_pattern: `${template.name}: {${template.variables[0]?.name ?? "name"}}`,
+    description: template.description,
+    priority: "medium",
+    tags: [template.category, "local-template"],
+    variables: template.variables,
+    project_id: null,
+    plan_id: null,
+    metadata: templateMetadata(template),
+    tasks: template.tasks.map((task) => ({
+      position: task.position,
+      title_pattern: task.title_pattern,
+      description: task.description ?? null,
+      priority: task.priority ?? "medium",
+      tags: task.tags ?? [template.category],
+      task_type: task.task_type ?? null,
+      condition: task.condition ?? null,
+      include_template_id: task.include_template_id ?? null,
+      depends_on_positions: task.depends_on_positions ?? task.depends_on ?? [],
+      metadata: task.metadata ?? { category: template.category }
+    }))
+  };
+}
+function exportBuiltinTemplateFiles() {
+  return BUILTIN_TEMPLATES.map((template) => ({
+    filename: `${template.name}.json`,
+    template: exportBuiltinTemplate(template.name)
+  }));
+}
+function writeBuiltinTemplateFiles(directory) {
+  mkdirSync6(directory, { recursive: true });
+  const files = [];
+  for (const entry of exportBuiltinTemplateFiles()) {
+    const path = join7(directory, entry.filename);
+    writeFileSync4(path, `${JSON.stringify(entry.template, null, 2)}
+`, "utf-8");
+    files.push(path);
+  }
+  return { directory, written: files.length, files };
+}
 function initBuiltinTemplates(db) {
   const d = db || getDatabase();
   const existing = listTemplates(d);
@@ -10470,7 +10720,9 @@ function initBuiltinTemplates(db) {
       name: bt.name,
       title_pattern: `${bt.name}: {${bt.variables[0]?.name || "name"}}`,
       description: bt.description,
+      tags: [bt.category, "local-template"],
       variables: bt.variables,
+      metadata: templateMetadata(bt),
       tasks
     }, d);
     created++;
@@ -11859,16 +12111,16 @@ function runSearchView(idOrName, db) {
   return { ...runSavedSearch(view.filters, view.scope, d), view };
 }
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8 } from "path";
 function getTaskListDir(taskListId) {
-  return join7(HOME, ".claude", "tasks", taskListId);
+  return join8(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join7(dir, filename));
+  return readJsonFile(join8(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join7(dir, `${task.id}.json`), task);
+  writeJsonFile(join8(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -11880,14 +12132,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join7(dir, ".prefix-counter");
+  const path = join8(dir, ".prefix-counter");
   if (!existsSync8(path))
     return 0;
   const val = parseInt(readFileSync6(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync4(join7(dir, ".prefix-counter"), String(value));
+  writeFileSync5(join8(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -11923,7 +12175,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join7(dir, f);
+    const path = join8(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -12030,7 +12282,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join7(dir, f);
+      const filePath = join8(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -12099,26 +12351,26 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 
 // src/lib/agent-tasks.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function getTodosGlobalDir3() {
-  const newDir = join8(HOME, ".hasna", "todos");
-  const legacyDir = join8(HOME, ".todos");
+  const newDir = join9(HOME, ".hasna", "todos");
+  const legacyDir = join9(HOME, ".todos");
   if (!existsSync9(newDir) && existsSync9(legacyDir))
     return legacyDir;
   return newDir;
 }
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join8(getTodosGlobalDir3(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join9(getTodosGlobalDir3(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join8(agentBaseDir(agent), agent, taskListId);
+  return join9(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join8(dir, filename));
+  return readJsonFile(join9(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join8(dir, `${task.id}.json`), task);
+  writeJsonFile(join9(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -12152,7 +12404,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join8(dir, f);
+    const path = join9(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -12245,7 +12497,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join8(dir, f);
+      const filePath = join9(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -12383,7 +12635,7 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
 }
 // src/lib/extract.ts
 import { readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { relative as relative3, resolve as resolve7, join as join9 } from "path";
+import { relative as relative3, resolve as resolve7, join as join10 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
   ".ts",
@@ -12517,7 +12769,7 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync4(basePath).isFile() ? basePath : join9(basePath, file);
+    const fullPath = statSync4(basePath).isFile() ? basePath : join10(basePath, file);
     try {
       const source7 = readFileSync7(fullPath, "utf-8");
       const relPath = statSync4(basePath).isFile() ? relative3(resolve7(basePath, ".."), fullPath) : file;
@@ -15720,8 +15972,8 @@ function getLocalActivityTimeline(options = {}, db) {
 init_database();
 init_migrations();
 init_schema();
-import { chmodSync, copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, statSync as statSync5 } from "fs";
-import { basename as basename2, dirname as dirname7, join as join10 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync7, statSync as statSync5 } from "fs";
+import { basename as basename2, dirname as dirname7, join as join11 } from "path";
 var REQUIRED_TABLES = [
   "_migrations",
   "projects",
@@ -15891,13 +16143,13 @@ function createBackup(dbPath) {
   if (!existsSync11(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join10(dirname7(dbPath), `${basename2(dbPath)}.backup-${stamp}`);
+  const backupDir = join11(dirname7(dbPath), `${basename2(dbPath)}.backup-${stamp}`);
   const files = [];
-  mkdirSync6(backupDir, { recursive: true });
+  mkdirSync7(backupDir, { recursive: true });
   for (const source7 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     if (!existsSync11(source7))
       continue;
-    const target = join10(backupDir, basename2(source7));
+    const target = join11(backupDir, basename2(source7));
     copyFileSync(source7, target);
     files.push(target);
   }
@@ -16101,6 +16353,278 @@ function runTodosDoctor(options = {}) {
     summary
   };
 }
+// src/lib/environment-snapshots.ts
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync12, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { hostname, platform, arch } from "os";
+import { dirname as dirname8, join as join12, resolve as resolve9 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+init_database();
+var MANIFEST_FILES = ["package.json", "dashboard/package.json", "sdk/package.json"];
+var LOCKFILES = ["bun.lock", "bun.lockb", "package-lock.json", "npm-shrinkwrap.json"];
+var CONFIG_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "README.md",
+  "SECURITY.md",
+  "bunfig.toml",
+  "tsconfig.json",
+  "components.json",
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "vite.config.ts",
+  "dashboard/vite.config.ts"
+];
+function sha2563(value) {
+  return createHash6("sha256").update(value).digest("hex");
+}
+function fileRecord(root, relativePath) {
+  const path = join12(root, relativePath);
+  if (!existsSync12(path))
+    return null;
+  const stat = statSync6(path);
+  if (!stat.isFile())
+    return null;
+  const content = readFileSync9(path);
+  return { path: relativePath, sha256: sha2563(content), size_bytes: content.length };
+}
+function manifestRecord(root, relativePath) {
+  const base = fileRecord(root, relativePath);
+  if (!base)
+    return null;
+  const parsed = readJsonFile(join12(root, relativePath));
+  if (!parsed)
+    return { ...base, redacted: {} };
+  const redacted = redactValue({
+    name: parsed["name"] ?? null,
+    version: parsed["version"] ?? null,
+    packageManager: parsed["packageManager"] ?? null,
+    scripts: parsed["scripts"] ?? {},
+    dependencies: parsed["dependencies"] ?? {},
+    devDependencies: parsed["devDependencies"] ?? {},
+    peerDependencies: parsed["peerDependencies"] ?? {},
+    optionalDependencies: parsed["optionalDependencies"] ?? {}
+  });
+  return { ...base, redacted };
+}
+function runLocalCommand(root, args) {
+  const result = Bun.spawnSync({
+    cmd: args,
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { PATH: process.env["PATH"] || "" }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: redactEvidenceText(result.stdout.toString("utf8").trim()),
+    stderr: redactEvidenceText(result.stderr.toString("utf8").trim())
+  };
+}
+function summarizeGitStatus(lines) {
+  const summary = { added: 0, modified: 0, deleted: 0, renamed: 0, untracked: 0 };
+  for (const line of lines) {
+    if (line.startsWith("??"))
+      summary.untracked += 1;
+    else if (line.includes("R"))
+      summary.renamed += 1;
+    else if (line.includes("D"))
+      summary.deleted += 1;
+    else if (line.includes("A"))
+      summary.added += 1;
+    else if (line.includes("M"))
+      summary.modified += 1;
+  }
+  return summary;
+}
+function captureGit(root, warnings) {
+  const inside = runLocalCommand(root, ["git", "rev-parse", "--is-inside-work-tree"]);
+  if (inside.exitCode !== 0 || inside.stdout !== "true") {
+    return { present: false, branch: null, commit: null, is_dirty: false, status_porcelain: [], status_summary: summarizeGitStatus([]) };
+  }
+  const branch = runLocalCommand(root, ["git", "branch", "--show-current"]);
+  const commit = runLocalCommand(root, ["git", "rev-parse", "HEAD"]);
+  const status = runLocalCommand(root, ["git", "status", "--porcelain=v1"]);
+  if (commit.exitCode !== 0)
+    warnings.push(`git commit unavailable: ${commit.stderr || commit.stdout || "unknown error"}`);
+  if (status.exitCode !== 0)
+    warnings.push(`git status unavailable: ${status.stderr || status.stdout || "unknown error"}`);
+  const lines = status.stdout ? status.stdout.split(/\r?\n/).filter(Boolean) : [];
+  return {
+    present: true,
+    branch: branch.stdout || null,
+    commit: commit.stdout || null,
+    is_dirty: lines.length > 0,
+    status_porcelain: lines,
+    status_summary: summarizeGitStatus(lines)
+  };
+}
+function packageManager(env, lockfiles) {
+  const userAgent = (env["npm_config_user_agent"] || "").toLowerCase();
+  if (userAgent.includes("bun"))
+    return "bun";
+  if (lockfiles.some((file) => file.path.startsWith("bun.lock")))
+    return "bun";
+  if (userAgent.includes("npm") || lockfiles.some((file) => file.path.includes("package-lock")))
+    return "npm";
+  return "unknown";
+}
+function isSecretEnvKey(key) {
+  return /api[_-]?key|token|secret|password|credential|private|session|cookie/i.test(key);
+}
+function commandEnv(env, includeValues) {
+  const keys = Object.keys(env).sort();
+  const interesting = keys.filter((key) => isSecretEnvKey(key) || ["CI", "NODE_ENV", "BUN_ENV", "SHELL", "TERM", "PATH", "PWD", "USER", "npm_config_user_agent"].includes(key) || key.startsWith("TODOS_") || key.startsWith("BUN_"));
+  const redactedKeys = interesting.filter(isSecretEnvKey);
+  const values = includeValues ? Object.fromEntries(interesting.map((key) => [key, isSecretEnvKey(key) ? "[REDACTED]" : redactEvidenceText(String(env[key] ?? ""))])) : null;
+  return {
+    command: null,
+    env_keys: interesting,
+    env: values,
+    redacted_keys: redactedKeys
+  };
+}
+function defaultSnapshotDir() {
+  const dbPath = getDatabasePath();
+  if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
+    return join12(tmpdir2(), "hasna-todos", "environment-snapshots");
+  return join12(dirname8(resolve9(dbPath)), "environment-snapshots");
+}
+function snapshotWithId(snapshot) {
+  const digest = sha2563(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest}`, ...snapshot };
+}
+function captureEnvironmentSnapshot(input = {}) {
+  const root = resolve9(input.root || process.cwd());
+  const env = input.env || process.env;
+  const warnings = [];
+  const manifests = MANIFEST_FILES.map((file) => manifestRecord(root, file)).filter((file) => Boolean(file));
+  const lockfiles = LOCKFILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const configHashes = CONFIG_FILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const commandMetadata = commandEnv(env, Boolean(input.include_env_values));
+  commandMetadata.command = input.command ? redactEvidenceText(input.command) : null;
+  if (manifests.length === 0)
+    warnings.push("no package manifest found");
+  if (lockfiles.length === 0)
+    warnings.push("no package lockfile found");
+  return snapshotWithId({
+    schema_version: 1,
+    captured_at: input.now ? new Date(input.now).toISOString() : new Date().toISOString(),
+    root,
+    machine: { hostname: hostname(), platform: platform(), arch: arch() },
+    target: {
+      task_id: input.task_id ?? null,
+      run_id: input.run_id ?? null,
+      agent_id: input.agent_id ?? null
+    },
+    runtime: {
+      bun: Bun.version || null,
+      node: process.version,
+      executable: process.execPath
+    },
+    package_manager: {
+      manager: packageManager(env, lockfiles),
+      user_agent: env["npm_config_user_agent"] ? redactEvidenceText(env["npm_config_user_agent"]) : null,
+      manifests,
+      lockfiles
+    },
+    git: captureGit(root, warnings),
+    config_hashes: configHashes,
+    command_env: commandMetadata,
+    warnings
+  });
+}
+function writeEnvironmentSnapshot(snapshot, outputPath) {
+  const path = outputPath ? resolve9(outputPath) : join12(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname8(path));
+  writeJsonFile(path, snapshot);
+  return path;
+}
+function readEnvironmentSnapshot(path) {
+  const snapshot = readJsonFile(resolve9(path));
+  if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
+    throw new Error(`Invalid environment snapshot: ${path}`);
+  }
+  return snapshot;
+}
+function recordEnvironmentSnapshot(input = {}, db) {
+  let taskId = input.task_id;
+  let runId = input.run_id;
+  const needsDatabase = Boolean(taskId || runId);
+  const d = needsDatabase ? db || getDatabase() : null;
+  if (runId) {
+    runId = resolveTaskRunId(runId, d);
+    const run = getTaskRun(runId, d);
+    if (!run)
+      throw new Error(`Run not found: ${input.run_id}`);
+    taskId = taskId || run.task_id;
+  }
+  if (taskId && d) {
+    taskId = resolvePartialId(d, "tasks", taskId) || taskId;
+    if (!getTask(taskId, d))
+      throw new Error(`Task not found: ${taskId}`);
+  }
+  const snapshot = captureEnvironmentSnapshot({ ...input, task_id: taskId, run_id: runId });
+  const outputPath = writeEnvironmentSnapshot(snapshot, input.output_path);
+  let taskVerificationId = null;
+  let runArtifactId = null;
+  if (runId) {
+    const artifact = addTaskRunArtifact({
+      run_id: runId,
+      path: outputPath,
+      artifact_type: "environment_snapshot",
+      description: "Reproducible local environment snapshot",
+      metadata: { environment_snapshot_id: snapshot.id, schema_version: snapshot.schema_version },
+      store_content: input.store_content ?? true,
+      agent_id: input.agent_id
+    }, d);
+    runArtifactId = artifact.id;
+  } else if (taskId) {
+    const verification = addTaskVerification({
+      task_id: taskId,
+      command: input.command || "capture environment snapshot",
+      status: "unknown",
+      output_summary: `environment snapshot ${snapshot.id}`,
+      artifact_path: outputPath,
+      agent_id: input.agent_id,
+      run_at: snapshot.captured_at
+    }, d);
+    taskVerificationId = verification.id;
+  }
+  return { snapshot, output_path: outputPath, task_verification_id: taskVerificationId, run_artifact_id: runArtifactId };
+}
+function keyed(files) {
+  return new Map(files.map((file) => [file.path, file]));
+}
+function diffFiles(left, right) {
+  const leftMap = keyed(left);
+  const rightMap = keyed(right);
+  const paths = [...new Set([...leftMap.keys(), ...rightMap.keys()])].sort((a, b) => a.localeCompare(b));
+  return paths.map((path) => ({ path, left_sha256: leftMap.get(path)?.sha256 ?? null, right_sha256: rightMap.get(path)?.sha256 ?? null })).filter((entry) => entry.left_sha256 !== entry.right_sha256);
+}
+function compareEnvironmentSnapshots(left, right) {
+  const warnings = [];
+  if (left.schema_version !== right.schema_version)
+    warnings.push("snapshot schema versions differ");
+  return {
+    schema_version: 1,
+    left_id: left.id,
+    right_id: right.id,
+    same_root: left.root === right.root,
+    same_machine: left.machine.hostname === right.machine.hostname && left.machine.platform === right.machine.platform && left.machine.arch === right.machine.arch,
+    same_runtime: left.runtime.bun === right.runtime.bun && left.runtime.node === right.runtime.node,
+    same_git_commit: left.git.commit === right.git.commit,
+    dirty_state_changed: left.git.is_dirty !== right.git.is_dirty,
+    changed_config_hashes: diffFiles(left.config_hashes, right.config_hashes),
+    changed_lockfiles: diffFiles(left.package_manager.lockfiles, right.package_manager.lockfiles),
+    changed_manifests: diffFiles(left.package_manager.manifests, right.package_manager.manifests),
+    warnings
+  };
+}
+function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
+  return compareEnvironmentSnapshots(readEnvironmentSnapshot(leftPath), readEnvironmentSnapshot(rightPath));
+}
 // src/lib/task-contracts.ts
 init_database();
 var CONTRACT_KEY = "_contract";
@@ -16315,6 +16839,8 @@ function checkTaskDoneContract(taskId, db) {
   };
 }
 export {
+  writeEnvironmentSnapshot,
+  writeBuiltinTemplateFiles,
   verifyTaskRunArtifacts,
   verifyStoredArtifact,
   verifyApiKey,
@@ -16413,6 +16939,8 @@ export {
   redistributeStaleTasks,
   redactEvidenceText,
   recordTaskReview,
+  recordEnvironmentSnapshot,
+  readEnvironmentSnapshot,
   queueAgentRun,
   queryTasksByLocalFields,
   previewTemplate,
@@ -16465,6 +16993,7 @@ export {
   listCyclesWithStats,
   listCycles,
   listComments,
+  listBuiltinTemplates,
   listApprovalGates,
   listApiKeys,
   listAgents,
@@ -16559,6 +17088,7 @@ export {
   getChecklist,
   getCapableAgents,
   getBurndown,
+  getBuiltinTemplate,
   getBudget,
   getBlockingDeps,
   getAgentMetrics,
@@ -16584,6 +17114,8 @@ export {
   exportTodosMarkdown,
   exportTemplate,
   exportStoredArtifactContent,
+  exportBuiltinTemplateFiles,
+  exportBuiltinTemplate,
   explainRunnerSandbox,
   explainPolicyPack,
   expireApprovalGate,
@@ -16649,6 +17181,8 @@ export {
   createAgentContextPack,
   countTasks,
   completeTask,
+  compareEnvironmentSnapshots,
+  compareEnvironmentSnapshotFiles,
   closeDatabase,
   cloneTask,
   clearChecklist,
@@ -16664,6 +17198,7 @@ export {
   checkChecklistItem,
   checkBudget,
   checkApprovalGate,
+  captureEnvironmentSnapshot,
   cancelDispatch,
   cancelAgentRunDispatch,
   calculateDelay,
@@ -16736,6 +17271,8 @@ export {
   DEFAULT_ENCRYPTION_KEY_ENV,
   CompletionGuardError,
   CORE_MCP_TOOLS,
+  BUILTIN_TEMPLATE_LIBRARY_VERSION,
+  BUILTIN_TEMPLATE_LIBRARY_SOURCE,
   BUILTIN_TEMPLATES,
   AgentNotFoundError
 };