@cardor/agent-harness-kit 1.8.1 → 1.10.0

package/dist/cli.js

@@ -1,10 +1,19 @@
 import {
   findConfigFile,
   loadConfig
-} from "./chunk-OEPZRC7J.js";
+} from "./chunk-ADV7OPU2.js";
+import {
+  getRowCounts,
+  isEmptyDatabase,
+  openDB,
+  readStorageStateFile,
+  resolveGlobalStorageDir,
+  resolveSqlitePathForScope
+} from "./chunk-DNFFWQWR.js";
 
 // src/cli.ts
 import { Command } from "commander";
+import pc19 from "picocolors";
 
 // src/commands/build.ts
 import { watch } from "fs";
@@ -12,8 +21,8 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 
 // src/core/materializer/claude-code.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
 
 // src/utils/file.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -24,29 +33,88 @@ var write = (cwd2, relPath, content, mode) => {
   writeFileSync(abs, content, { encoding: "utf8", mode });
 };
 
+// src/core/materializer/detect-package-manager.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+function detectPackageManager(cwd2) {
+  const fromField = detectFromPackageManagerField(cwd2);
+  if (fromField) return fromField;
+  if (existsSync(join2(cwd2, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join2(cwd2, "bun.lockb")) || existsSync(join2(cwd2, "bun.lock"))) return "bun";
+  if (existsSync(join2(cwd2, "yarn.lock"))) {
+    return existsSync(join2(cwd2, ".yarnrc.yml")) ? "yarn-berry" : "yarn-classic";
+  }
+  if (existsSync(join2(cwd2, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function detectFromPackageManagerField(cwd2) {
+  const pkgPath2 = join2(cwd2, "package.json");
+  if (!existsSync(pkgPath2)) return null;
+  try {
+    const pkg2 = JSON.parse(readFileSync(pkgPath2, "utf8"));
+    const field = pkg2?.packageManager;
+    if (typeof field !== "string" || !field.trim()) return null;
+    const match = field.match(/^([a-z]+)@(\d+)/i);
+    if (!match) return null;
+    const [, rawName, majorStr] = match;
+    const name = rawName.toLowerCase();
+    const major = Number(majorStr);
+    switch (name) {
+      case "npm":
+        return "npm";
+      case "pnpm":
+        return "pnpm";
+      case "bun":
+        return "bun";
+      case "yarn":
+        return major >= 2 ? "yarn-berry" : "yarn-classic";
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function getMcpCommandParts(pm, port) {
+  const portStr = String(port);
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", "exec", "ahk", "serve", "--port", portStr];
+    case "yarn-classic":
+    case "yarn-berry":
+      return ["yarn", "run", "ahk", "serve", "--port", portStr];
+    case "bun":
+      return ["bunx", "--no-install", "ahk", "serve", "--port", portStr];
+    case "npm":
+    default:
+      return ["npx", "--no", "ahk", "serve", "--port", portStr];
+  }
+}
+
 // src/core/materializer/mcp-merge.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
-function mergeClaudeMcpJson(filePath, port) {
+function mergeClaudeMcpJson(filePath, port, pm = "npm") {
   const folderPath = dirname(filePath);
-  if (!existsSync(folderPath)) {
+  if (!existsSync2(folderPath)) {
     mkdirSync2(folderPath, { recursive: true });
   }
   let existing = {};
-  if (existsSync(filePath)) {
+  if (existsSync2(filePath)) {
     try {
-      existing = JSON.parse(readFileSync(filePath, "utf8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf8"));
     } catch {
     }
   }
+  const [command, ...args] = getMcpCommandParts(pm, port);
   const merged = {
     ...existing,
     mcpServers: {
       ...existing.mcpServers ?? {},
       "agent-harness-kit": {
         type: "stdio",
-        command: "npx",
-        args: ["ahk", "serve", "--port", String(port)]
+        command,
+        args
       }
     }
   };
@@ -56,9 +124,9 @@ function mergeClaudeMcpJson(filePath, port) {
 function mergeClaudeSettingsJson(filePath) {
   mkdirSync2(dirname(filePath), { recursive: true });
   let existing = {};
-  if (existsSync(filePath)) {
+  if (existsSync2(filePath)) {
     try {
-      existing = JSON.parse(readFileSync(filePath, "utf8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf8"));
     } catch {
     }
   }
@@ -163,9 +231,9 @@ var MCP_CLAUDE_PERMISSIONS = [
 function mergeClaudeSettingsLocalJson(filePath) {
   mkdirSync2(dirname(filePath), { recursive: true });
   let existing = {};
-  if (existsSync(filePath)) {
+  if (existsSync2(filePath)) {
     try {
-      existing = JSON.parse(readFileSync(filePath, "utf8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf8"));
     } catch {
     }
   }
@@ -184,15 +252,15 @@ function mergeClaudeSettingsLocalJson(filePath) {
   };
   writeFileSync2(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
 }
-function mergeOpencodeJson(filePath, port) {
+function mergeOpencodeJson(filePath, port, pm = "npm") {
   const folderPath = dirname(filePath);
-  if (!existsSync(folderPath)) {
+  if (!existsSync2(folderPath)) {
     mkdirSync2(folderPath, { recursive: true });
   }
   let existing = {};
-  if (existsSync(filePath)) {
+  if (existsSync2(filePath)) {
     try {
-      existing = JSON.parse(readFileSync(filePath, "utf8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf8"));
     } catch {
     }
   }
@@ -207,7 +275,9 @@ function mergeOpencodeJson(filePath, port) {
       "agent-harness-kit": {
         enabled: true,
         type: "local",
-        command: ["npx", "ahk", "serve", "--port", String(port)]
+        // OpenCode's mcp.<name>.command field is a single array (unlike
+        // Claude/Codex, which split command/args) — pass the full token list.
+        command: getMcpCommandParts(pm, port)
       }
     }
   };
@@ -237,15 +307,16 @@ function mergeTomlSection(content, sectionName, sectionBody) {
   ];
   return newLines.join("\n");
 }
-function mergeCodexConfigToml(filePath, port) {
+function mergeCodexConfigToml(filePath, port, pm = "npm") {
   mkdirSync2(dirname(filePath), { recursive: true });
   let content = "";
-  if (existsSync(filePath)) {
-    content = readFileSync(filePath, "utf8");
+  if (existsSync2(filePath)) {
+    content = readFileSync2(filePath, "utf8");
   }
+  const [command, ...args] = getMcpCommandParts(pm, port);
   const sectionBody = [
-    'command = "npx"',
-    `args = ["ahk", "serve", "--port", "${port}"]`,
+    `command = ${JSON.stringify(command)}`,
+    `args = ${JSON.stringify(args)}`,
     'default_tools_approval_mode = "auto"'
   ].join("\n");
   content = mergeTomlSection(content, "mcp_servers.agent-harness-kit", sectionBody);
@@ -253,18 +324,18 @@ function mergeCodexConfigToml(filePath, port) {
 }
 
 // src/core/materializer/scaffold-utils.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/core/materializer/templates.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var TEMPLATES_DIR = join2(__dirname, "agent-templates");
+var TEMPLATES_DIR = join3(__dirname, "agent-templates");
 function loadAgentTemplate(name, vars = {}) {
-  const raw = readFileSync2(join2(TEMPLATES_DIR, `${name}.md`), "utf8");
+  const raw = readFileSync3(join3(TEMPLATES_DIR, `${name}.md`), "utf8");
   return raw.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
 }
 var HEALTH_SH = `#!/usr/bin/env bash
@@ -456,7 +527,11 @@ If orchestrating: Agent definition files in .claude/agents/
 \`\`\`
 `;
 }
+function modelField(model) {
+  return model ? `, model: ${JSON.stringify(model)}` : "";
+}
 function configTs(params) {
+  const models = params.models ?? {};
   return `import { defineHarness } from '@cardor/agent-harness-kit'
 
 export default defineHarness({
@@ -469,11 +544,12 @@ export default defineHarness({
   provider: '${params.provider}',
 
   agents: {
-    lead:     { instructionsPath: null },
-    explorer: { instructionsPath: null, allowedPaths: ['${params.docsPath}', './src'] },
-    builder:  { instructionsPath: null, writablePaths: ['./src', './tests'] },
-    reviewer: { instructionsPath: null },
-    custom:   [],
+    lead:     { instructionsPath: null${modelField(models.lead)} },
+    explorer: { instructionsPath: null, allowedPaths: ['${params.docsPath}', './src']${modelField(models.explorer)} },
+    builder:  { instructionsPath: null, writablePaths: ['./src', './tests']${modelField(models.builder)} },
+    reviewer: { instructionsPath: null${modelField(models.reviewer)} },
+    ${models.consultant ? `consultant: { instructionsPath: null${modelField(models.consultant)} },
+    ` : ""}custom:   [],
   },
 
   // SQLite (default). Switch to postgres/mysql by changing database.type.
@@ -492,6 +568,10 @@ export default defineHarness({
       nextSteps:     false,
     },
     markdownFallback: { enabled: true, path: '.harness/current.md' },
+    // 'local' \u2014 DB lives in .harness/ (project-relative). 'global' \u2014 DB lives
+    // under ~/.harness/dbs/<projectId>/, outside the project tree.
+    scope:     '${params.scope}',
+    projectId: '${params.projectId}',
   },
 
   health: {
@@ -508,6 +588,7 @@ export default defineHarness({
 }
 var configMjs = configTs;
 function configCjs(params) {
+  const models = params.models ?? {};
   return `const { defineHarness } = require('@cardor/agent-harness-kit')
 
 module.exports = defineHarness({
@@ -520,11 +601,12 @@ module.exports = defineHarness({
   provider: '${params.provider}',
 
   agents: {
-    lead:     { instructionsPath: null },
-    explorer: { instructionsPath: null, allowedPaths: ['${params.docsPath}', './src'] },
-    builder:  { instructionsPath: null, writablePaths: ['./src', './tests'] },
-    reviewer: { instructionsPath: null },
-    custom:   [],
+    lead:     { instructionsPath: null${modelField(models.lead)} },
+    explorer: { instructionsPath: null, allowedPaths: ['${params.docsPath}', './src']${modelField(models.explorer)} },
+    builder:  { instructionsPath: null, writablePaths: ['./src', './tests']${modelField(models.builder)} },
+    reviewer: { instructionsPath: null${modelField(models.reviewer)} },
+    ${models.consultant ? `consultant: { instructionsPath: null${modelField(models.consultant)} },
+    ` : ""}custom:   [],
   },
 
   // SQLite (default). Switch to postgres/mysql by changing database.type.
@@ -543,6 +625,10 @@ module.exports = defineHarness({
       nextSteps:     false,
     },
     markdownFallback: { enabled: true, path: '.harness/current.md' },
+    // 'local' \u2014 DB lives in .harness/ (project-relative). 'global' \u2014 DB lives
+    // under ~/.harness/dbs/<projectId>/, outside the project tree.
+    scope:     '${params.scope}',
+    projectId: '${params.projectId}',
   },
 
   health: {
@@ -590,11 +676,14 @@ function stripFrontmatter(md) {
   }
   return { description, body };
 }
-function toCodexToml(name, description, body, sandboxMode) {
+function toCodexToml(name, description, body, sandboxMode, model) {
   const safe = (s) => s.replace(/"""/g, '""\\u0022');
+  const trimmedModel = model?.trim() ?? "";
+  const modelLine = trimmedModel.length >= 3 ? `model = "${trimmedModel}"
+` : "";
   return `name = "${name}"
 sandbox_mode = "${sandboxMode}"
-
+${modelLine}
 description = """
 ${safe(description)}
 """
@@ -606,29 +695,29 @@ ${safe(body.trimEnd())}
 }
 function agentLeadToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("lead", vars));
-  return toCodexToml("lead", description, body, "read-only");
+  return toCodexToml("lead", description, body, "read-only", vars.model);
 }
 function agentLeadAsDefaultToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("lead", vars));
-  return toCodexToml("default", description, body, "read-only");
+  return toCodexToml("default", description, body, "read-only", vars.model);
 }
 function agentExplorerToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("explorer", vars));
-  return toCodexToml("explorer", description, body, "read-only");
+  return toCodexToml("explorer", description, body, "read-only", vars.model);
 }
 function agentBuilderToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("builder", vars));
-  return toCodexToml("builder", description, body, "workspace-write");
+  return toCodexToml("builder", description, body, "workspace-write", vars.model);
 }
 function agentReviewerToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("reviewer", vars));
-  return toCodexToml("reviewer", description, body, "read-only");
+  return toCodexToml("reviewer", description, body, "read-only", vars.model);
 }
 function agentConsultantToml(vars) {
   const { description, body } = stripFrontmatter(loadAgentTemplate("consultant", vars));
-  return toCodexToml("consultant", description, body, "read-only");
+  return toCodexToml("consultant", description, body, "read-only", vars.model);
 }
-function translateFrontmatterForClaudeCode(md, agentName) {
+function translateFrontmatterForClaudeCode(md, agentName, model) {
   const permissionsMap = {
     lead: [...MCP_CLAUDE_PERMISSIONS_LEAD],
     explorer: [...MCP_CLAUDE_PERMISSIONS_EXPLORER],
@@ -638,13 +727,24 @@ function translateFrontmatterForClaudeCode(md, agentName) {
   };
   const permissions = permissionsMap[agentName] ?? MCP_CLAUDE_PERMISSIONS;
   const mcpLines = permissions.map((t) => `  - ${t}`).join("\n");
-  return md.replace(/(tools:\n(?:  - (?!mcp__)[^\n]+\n)+)/, (match) => {
+  let result = md.replace(/(tools:\n(?:  - (?!mcp__)[^\n]+\n)+)/, (match) => {
     const trimmed = match.trimEnd();
     return `${trimmed}
   - Task
 ${mcpLines}
 `;
   });
+  if (model) {
+    result = injectModelFrontmatterLine(result, model);
+  }
+  return result;
+}
+function injectModelFrontmatterLine(md, model) {
+  if (/^model:\s*.*$/m.test(md)) {
+    return md.replace(/^model:\s*.*$/m, `model: ${model}`);
+  }
+  return md.replace(/^(name:.*)$/m, `$1
+model: ${model}`);
 }
 function translateFrontmatterForOpenCode(md) {
   return md.replace(/(tools:\n(?:  - [^\n]+\n)+)/, (match) => {
@@ -663,14 +763,14 @@ var GITIGNORE_ENTRIES = `
 // src/core/materializer/scaffold-utils.ts
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
 function writeAgentFile(cwd2, relPath, content) {
-  const abs = join3(cwd2, relPath);
-  if (existsSync2(abs)) return;
+  const abs = join4(cwd2, relPath);
+  if (existsSync3(abs)) return;
   mkdirSync3(resolve2(abs, ".."), { recursive: true });
   writeFileSync3(abs, content, "utf8");
 }
 function appendGitignore(cwd2) {
-  const giPath = join3(cwd2, ".gitignore");
-  const existing = existsSync2(giPath) ? readFileSync3(giPath, "utf8") : "";
+  const giPath = join4(cwd2, ".gitignore");
+  const existing = existsSync3(giPath) ? readFileSync4(giPath, "utf8") : "";
   const toAdd = GITIGNORE_ENTRIES.split("\n").filter((line) => line && !existing.includes(line)).join("\n");
   if (toAdd.trim()) {
     writeFileSync3(giPath, existing + (existing.endsWith("\n") ? "" : "\n") + toAdd + "\n", "utf8");
@@ -680,15 +780,23 @@ function slugify(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
 }
 function writeSkills(cwd2, skillsDir) {
-  const skillNames = ["ahk-ask", "ahk-consultant", "ahk-triage"];
+  const skillNames = ["ahk-ask", "ahk-consultant", "ahk-triage", "ahk-review"];
   for (const skillName of skillNames) {
-    const src = join3(__dirname2, "skills", skillName, "SKILL.md");
-    const destDir = join3(cwd2, skillsDir, skillName);
-    const dest = join3(destDir, "SKILL.md");
+    const src = join4(__dirname2, "skills", skillName, "SKILL.md");
+    const destDir = join4(cwd2, skillsDir, skillName);
+    const dest = join4(destDir, "SKILL.md");
     mkdirSync3(destDir, { recursive: true });
-    writeFileSync3(dest, readFileSync3(src, "utf8"), "utf8");
+    writeFileSync3(dest, readFileSync4(src, "utf8"), "utf8");
   }
 }
+function writeSkill(skillsRoot, skillName) {
+  const src = join4(__dirname2, "skills", skillName, "SKILL.md");
+  const destDir = join4(skillsRoot, skillName);
+  const dest = join4(destDir, "SKILL.md");
+  if (existsSync3(dest)) return;
+  mkdirSync3(destDir, { recursive: true });
+  writeFileSync3(dest, readFileSync4(src, "utf8"), "utf8");
+}
 
 // src/core/materializer/claude-code.ts
 var ClaudeCodeMaterializer = class {
@@ -696,12 +804,12 @@ var ClaudeCodeMaterializer = class {
     const { cwd: cwd2 } = opts;
     write(cwd2, "AGENTS.md", agentsMd(config));
     write(cwd2, "CLAUDE.md", claudeMd(config));
-    if (!existsSync3(join4(cwd2, "health.sh"))) {
+    if (!existsSync4(join5(cwd2, "health.sh"))) {
       write(cwd2, "health.sh", HEALTH_SH, 493);
     }
     const tasks = opts.firstTask ? [{ slug: slugify(opts.firstTask.title), ...opts.firstTask }] : [];
     write(cwd2, "feature_list.json", featureListJson(tasks));
-    if (!existsSync3(join4(cwd2, config.storage.markdownFallback.path))) {
+    if (!existsSync4(join5(cwd2, config.storage.markdownFallback.path))) {
       write(
         cwd2,
         config.storage.markdownFallback.path,
@@ -717,20 +825,25 @@ No tasks in progress.
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
-    writeAgentFile(cwd2, ".claude/agents/lead.md", translateFrontmatterForClaudeCode(agentLead({ projectName }), "lead"));
-    writeAgentFile(cwd2, ".claude/agents/explorer.md", translateFrontmatterForClaudeCode(agentExplorer({ projectName, allowedPaths }), "explorer"));
-    writeAgentFile(cwd2, ".claude/agents/consultant.md", translateFrontmatterForClaudeCode(agentConsultant({ projectName }), "consultant"));
-    writeAgentFile(cwd2, ".claude/agents/builder.md", translateFrontmatterForClaudeCode(agentBuilder({ projectName, writablePaths }), "builder"));
-    writeAgentFile(cwd2, ".claude/agents/reviewer.md", translateFrontmatterForClaudeCode(agentReviewer({ projectName }), "reviewer"));
-    mergeClaudeMcpJson(join4(cwd2, ".mcp.json"), config.tools.mcp.port);
-    mergeClaudeSettingsJson(join4(cwd2, ".claude/settings.json"));
-    mergeClaudeSettingsLocalJson(join4(cwd2, ".claude/settings.local.json"));
+    const leadModel = config.agents.lead.model;
+    const explorerModel = config.agents.explorer.model;
+    const consultantModel = config.agents.consultant?.model;
+    const builderModel = config.agents.builder.model;
+    const reviewerModel = config.agents.reviewer.model;
+    writeAgentFile(cwd2, ".claude/agents/lead.md", translateFrontmatterForClaudeCode(agentLead({ projectName }), "lead", leadModel));
+    writeAgentFile(cwd2, ".claude/agents/explorer.md", translateFrontmatterForClaudeCode(agentExplorer({ projectName, allowedPaths }), "explorer", explorerModel));
+    writeAgentFile(cwd2, ".claude/agents/consultant.md", translateFrontmatterForClaudeCode(agentConsultant({ projectName }), "consultant", consultantModel));
+    writeAgentFile(cwd2, ".claude/agents/builder.md", translateFrontmatterForClaudeCode(agentBuilder({ projectName, writablePaths }), "builder", builderModel));
+    writeAgentFile(cwd2, ".claude/agents/reviewer.md", translateFrontmatterForClaudeCode(agentReviewer({ projectName }), "reviewer", reviewerModel));
+    mergeClaudeMcpJson(join5(cwd2, ".mcp.json"), config.tools.mcp.port, detectPackageManager(cwd2));
+    mergeClaudeSettingsJson(join5(cwd2, ".claude/settings.json"));
+    mergeClaudeSettingsLocalJson(join5(cwd2, ".claude/settings.local.json"));
     appendGitignore(cwd2);
     writeSkills(cwd2, ".claude/skills");
   }
   async build(config, cwd2) {
     const write2 = (relPath, content) => {
-      const abs = join4(cwd2, relPath);
+      const abs = join5(cwd2, relPath);
       mkdirSync4(resolve3(abs, ".."), { recursive: true });
       writeFileSync4(abs, content, "utf8");
     };
@@ -739,14 +852,19 @@ No tasks in progress.
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
-    write2(".claude/agents/lead.md", translateFrontmatterForClaudeCode(agentLead({ projectName }), "lead"));
-    write2(".claude/agents/explorer.md", translateFrontmatterForClaudeCode(agentExplorer({ projectName, allowedPaths }), "explorer"));
-    write2(".claude/agents/consultant.md", translateFrontmatterForClaudeCode(agentConsultant({ projectName }), "consultant"));
-    write2(".claude/agents/builder.md", translateFrontmatterForClaudeCode(agentBuilder({ projectName, writablePaths }), "builder"));
-    write2(".claude/agents/reviewer.md", translateFrontmatterForClaudeCode(agentReviewer({ projectName }), "reviewer"));
-    mergeClaudeMcpJson(join4(cwd2, ".mcp.json"), config.tools.mcp.port);
-    mergeClaudeSettingsJson(join4(cwd2, ".claude/settings.json"));
-    mergeClaudeSettingsLocalJson(join4(cwd2, ".claude/settings.local.json"));
+    const leadModel = config.agents.lead.model;
+    const explorerModel = config.agents.explorer.model;
+    const consultantModel = config.agents.consultant?.model;
+    const builderModel = config.agents.builder.model;
+    const reviewerModel = config.agents.reviewer.model;
+    write2(".claude/agents/lead.md", translateFrontmatterForClaudeCode(agentLead({ projectName }), "lead", leadModel));
+    write2(".claude/agents/explorer.md", translateFrontmatterForClaudeCode(agentExplorer({ projectName, allowedPaths }), "explorer", explorerModel));
+    write2(".claude/agents/consultant.md", translateFrontmatterForClaudeCode(agentConsultant({ projectName }), "consultant", consultantModel));
+    write2(".claude/agents/builder.md", translateFrontmatterForClaudeCode(agentBuilder({ projectName, writablePaths }), "builder", builderModel));
+    write2(".claude/agents/reviewer.md", translateFrontmatterForClaudeCode(agentReviewer({ projectName }), "reviewer", reviewerModel));
+    mergeClaudeMcpJson(join5(cwd2, ".mcp.json"), config.tools.mcp.port, detectPackageManager(cwd2));
+    mergeClaudeSettingsJson(join5(cwd2, ".claude/settings.json"));
+    mergeClaudeSettingsLocalJson(join5(cwd2, ".claude/settings.local.json"));
     writeSkills(cwd2, ".claude/skills");
   }
   async migrate(config, _to, _cwd) {
@@ -761,12 +879,12 @@ No tasks in progress.
       reviewer: [...MCP_CLAUDE_PERMISSIONS_REVIEWER]
     };
     for (const [agent, tools] of Object.entries(AGENT_TOOLS)) {
-      const filePath = join4(cwd2, ".claude", "agents", `${agent}.md`);
-      if (!existsSync3(filePath)) {
+      const filePath = join5(cwd2, ".claude", "agents", `${agent}.md`);
+      if (!existsSync4(filePath)) {
         console.log(`  ${agent}.md not found \u2014 skipping`);
         continue;
       }
-      const content = readFileSync4(filePath, "utf-8");
+      const content = readFileSync5(filePath, "utf-8");
       const updated = content.replace(
         /(tools:\n)((?:  - [^\n]+\n)*)/m,
         (_match, header, toolsSection) => {
@@ -787,23 +905,23 @@ No tasks in progress.
 };
 
 // src/core/materializer/codex-cli.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join5, resolve as resolve4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6, resolve as resolve4 } from "path";
 var CodexCliMaterializer = class {
   async scaffold(config, opts) {
     const { cwd: cwd2 } = opts;
     const write2 = (relPath, content, mode) => {
-      const abs = join5(cwd2, relPath);
+      const abs = join6(cwd2, relPath);
       mkdirSync5(resolve4(abs, ".."), { recursive: true });
       writeFileSync5(abs, content, { encoding: "utf8", mode });
     };
     write2("AGENTS.md", agentsMd(config));
-    if (!existsSync4(join5(cwd2, "health.sh"))) {
+    if (!existsSync5(join6(cwd2, "health.sh"))) {
       write2("health.sh", HEALTH_SH, 493);
     }
     const tasks = opts.firstTask ? [{ slug: slugify(opts.firstTask.title), ...opts.firstTask }] : [];
-    write2(join5(config.storage.dir, "feature_list.json"), featureListJson(tasks));
-    if (!existsSync4(join5(cwd2, config.storage.markdownFallback.path))) {
+    write2(join6(config.storage.dir, "feature_list.json"), featureListJson(tasks));
+    if (!existsSync5(join6(cwd2, config.storage.markdownFallback.path))) {
       write2(
         config.storage.markdownFallback.path,
         `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
@@ -818,19 +936,24 @@ No tasks in progress.
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
-    writeAgentFile(cwd2, ".codex/agents/lead.toml", agentLeadToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/explorer.toml", agentExplorerToml({ projectName, allowedPaths }));
-    writeAgentFile(cwd2, ".codex/agents/consultant.toml", agentConsultantToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/builder.toml", agentBuilderToml({ projectName, writablePaths }));
-    writeAgentFile(cwd2, ".codex/agents/reviewer.toml", agentReviewerToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/default.toml", agentLeadAsDefaultToml({ projectName }));
-    mergeCodexConfigToml(join5(cwd2, ".codex/config.toml"), config.tools.mcp.port);
+    const leadModel = config.agents.lead.model;
+    const explorerModel = config.agents.explorer.model;
+    const consultantModel = config.agents.consultant?.model;
+    const builderModel = config.agents.builder.model;
+    const reviewerModel = config.agents.reviewer.model;
+    writeAgentFile(cwd2, ".codex/agents/lead.toml", agentLeadToml({ projectName, model: leadModel }));
+    writeAgentFile(cwd2, ".codex/agents/explorer.toml", agentExplorerToml({ projectName, allowedPaths, model: explorerModel }));
+    writeAgentFile(cwd2, ".codex/agents/consultant.toml", agentConsultantToml({ projectName, model: consultantModel }));
+    writeAgentFile(cwd2, ".codex/agents/builder.toml", agentBuilderToml({ projectName, writablePaths, model: builderModel }));
+    writeAgentFile(cwd2, ".codex/agents/reviewer.toml", agentReviewerToml({ projectName, model: reviewerModel }));
+    writeAgentFile(cwd2, ".codex/agents/default.toml", agentLeadAsDefaultToml({ projectName, model: leadModel }));
+    mergeCodexConfigToml(join6(cwd2, ".codex/config.toml"), config.tools.mcp.port, detectPackageManager(cwd2));
     appendGitignore(cwd2);
     writeSkills(cwd2, ".agents/skills");
   }
   async build(config, cwd2) {
     const write2 = (relPath, content) => {
-      const abs = join5(cwd2, relPath);
+      const abs = join6(cwd2, relPath);
       mkdirSync5(resolve4(abs, ".."), { recursive: true });
       writeFileSync5(abs, content, "utf8");
     };
@@ -838,13 +961,18 @@ No tasks in progress.
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
-    writeAgentFile(cwd2, ".codex/agents/lead.toml", agentLeadToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/explorer.toml", agentExplorerToml({ projectName, allowedPaths }));
-    writeAgentFile(cwd2, ".codex/agents/consultant.toml", agentConsultantToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/builder.toml", agentBuilderToml({ projectName, writablePaths }));
-    writeAgentFile(cwd2, ".codex/agents/reviewer.toml", agentReviewerToml({ projectName }));
-    writeAgentFile(cwd2, ".codex/agents/default.toml", agentLeadAsDefaultToml({ projectName }));
-    mergeCodexConfigToml(join5(cwd2, ".codex/config.toml"), config.tools.mcp.port);
+    const leadModel = config.agents.lead.model;
+    const explorerModel = config.agents.explorer.model;
+    const consultantModel = config.agents.consultant?.model;
+    const builderModel = config.agents.builder.model;
+    const reviewerModel = config.agents.reviewer.model;
+    writeAgentFile(cwd2, ".codex/agents/lead.toml", agentLeadToml({ projectName, model: leadModel }));
+    writeAgentFile(cwd2, ".codex/agents/explorer.toml", agentExplorerToml({ projectName, allowedPaths, model: explorerModel }));
+    writeAgentFile(cwd2, ".codex/agents/consultant.toml", agentConsultantToml({ projectName, model: consultantModel }));
+    writeAgentFile(cwd2, ".codex/agents/builder.toml", agentBuilderToml({ projectName, writablePaths, model: builderModel }));
+    writeAgentFile(cwd2, ".codex/agents/reviewer.toml", agentReviewerToml({ projectName, model: reviewerModel }));
+    writeAgentFile(cwd2, ".codex/agents/default.toml", agentLeadAsDefaultToml({ projectName, model: leadModel }));
+    mergeCodexConfigToml(join6(cwd2, ".codex/config.toml"), config.tools.mcp.port, detectPackageManager(cwd2));
     writeSkills(cwd2, ".agents/skills");
   }
   async migrate(config, _to, _cwd) {
@@ -856,23 +984,23 @@ No tasks in progress.
 };
 
 // src/core/materializer/opencode.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6, resolve as resolve5 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7, resolve as resolve5 } from "path";
 var OpenCodeMaterializer = class {
   async scaffold(config, opts) {
     const { cwd: cwd2 } = opts;
     const write2 = (relPath, content, mode) => {
-      const abs = join6(cwd2, relPath);
+      const abs = join7(cwd2, relPath);
       mkdirSync6(resolve5(abs, ".."), { recursive: true });
       writeFileSync6(abs, content, { encoding: "utf8", mode });
     };
     write2("AGENTS.md", agentsMd(config));
-    if (!existsSync5(join6(cwd2, "health.sh"))) {
+    if (!existsSync6(join7(cwd2, "health.sh"))) {
       write2("health.sh", HEALTH_SH, 493);
     }
     const tasks = opts.firstTask ? [{ slug: slugify(opts.firstTask.title), ...opts.firstTask }] : [];
-    write2(join6(config.storage.dir, "feature_list.json"), featureListJson(tasks));
-    if (!existsSync5(join6(cwd2, config.storage.markdownFallback.path))) {
+    write2(join7(config.storage.dir, "feature_list.json"), featureListJson(tasks));
+    if (!existsSync6(join7(cwd2, config.storage.markdownFallback.path))) {
       write2(
         config.storage.markdownFallback.path,
         `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
@@ -892,13 +1020,13 @@ No tasks in progress.
     writeAgentFile(cwd2, ".opencode/agents/consultant.md", translateFrontmatterForOpenCode(agentConsultant({ projectName })));
     writeAgentFile(cwd2, ".opencode/agents/builder.md", translateFrontmatterForOpenCode(agentBuilder({ projectName, writablePaths })));
     writeAgentFile(cwd2, ".opencode/agents/reviewer.md", translateFrontmatterForOpenCode(agentReviewer({ projectName })));
-    mergeOpencodeJson(join6(cwd2, "opencode.json"), config.tools.mcp.port);
+    mergeOpencodeJson(join7(cwd2, "opencode.json"), config.tools.mcp.port, detectPackageManager(cwd2));
     appendGitignore(cwd2);
     writeSkills(cwd2, ".opencode/skills");
   }
   async build(config, cwd2) {
     const write2 = (relPath, content) => {
-      const abs = join6(cwd2, relPath);
+      const abs = join7(cwd2, relPath);
       mkdirSync6(resolve5(abs, ".."), { recursive: true });
       writeFileSync6(abs, content, "utf8");
     };
@@ -911,7 +1039,7 @@ No tasks in progress.
     writeAgentFile(cwd2, ".opencode/agents/consultant.md", translateFrontmatterForOpenCode(agentConsultant({ projectName })));
     writeAgentFile(cwd2, ".opencode/agents/builder.md", translateFrontmatterForOpenCode(agentBuilder({ projectName, writablePaths })));
     writeAgentFile(cwd2, ".opencode/agents/reviewer.md", translateFrontmatterForOpenCode(agentReviewer({ projectName })));
-    mergeOpencodeJson(join6(cwd2, "opencode.json"), config.tools.mcp.port);
+    mergeOpencodeJson(join7(cwd2, "opencode.json"), config.tools.mcp.port, detectPackageManager(cwd2));
     writeSkills(cwd2, ".opencode/skills");
   }
   async migrate(config, _to, _cwd) {
@@ -977,14 +1105,14 @@ async function buildOnce(cwd2) {
 }
 
 // src/commands/dashboard.ts
-import { dirname as dirname5, join as join9, resolve as resolve7 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import pc2 from "picocolors";
 
 // src/core/dashboard-server.ts
 import { watch as watch2 } from "fs";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { extname, join as join7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { extname, join as join8 } from "path";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { WebSocketServer } from "ws";
@@ -1026,7 +1154,7 @@ var MIME = {
   ".ttf": "font/ttf"
 };
 function fileResponse(filePath) {
-  const content = readFileSync5(filePath);
+  const content = readFileSync6(filePath);
   const mime = MIME[extname(filePath)] ?? "application/octet-stream";
   return new Response(content, {
     headers: { "Content-Type": mime, "Cache-Control": "no-cache" }
@@ -1132,15 +1260,15 @@ async function startDashboardServer(db, dbPath, staticPath, port) {
   app.get("/*", (c) => {
     const urlPath = c.req.path;
     if (urlPath !== "/") {
-      const candidate = join7(staticPath, urlPath);
-      if (existsSync6(candidate)) {
+      const candidate = join8(staticPath, urlPath);
+      if (existsSync7(candidate)) {
         try {
           return fileResponse(candidate);
         } catch {
         }
       }
     }
-    return fileResponse(join7(staticPath, "index.html"));
+    return fileResponse(join8(staticPath, "index.html"));
   });
   const resolvedPort = await findFreePort(port);
   if (resolvedPort !== port) {
@@ -1171,7 +1299,7 @@ async function startDashboardServer(db, dbPath, staticPath, port) {
   let watcher = null;
   if (dbPath) {
     const walPath = `${dbPath}-wal`;
-    const watchTarget = existsSync6(walPath) ? walPath : dbPath;
+    const watchTarget = existsSync7(walPath) ? walPath : dbPath;
     watcher = watch2(watchTarget, broadcast);
   }
   return {
@@ -1185,635 +1313,12 @@ async function startDashboardServer(db, dbPath, staticPath, port) {
   };
 }
 
-// src/core/db.ts
-import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname4, join as join8, resolve as resolve6 } from "path";
-
-// src/core/repositories/ActionRepository.ts
-var ActionRepository = class {
-  constructor(driver) {
-    this.driver = driver;
-  }
-  driver;
-  async create(id, taskId, agent, now) {
-    await this.driver.exec(
-      `INSERT INTO actions (id, task_id, agent, status, created_at) VALUES (?, ?, ?, 'in_progress', ?)`,
-      [id, taskId, agent, now]
-    );
-  }
-  async complete(actionId, summary, now) {
-    await this.driver.exec(
-      `UPDATE actions SET status = 'completed', completed_at = ?, summary = ? WHERE id = ?`,
-      [now, summary, actionId]
-    );
-  }
-  async closeOrphaned(taskId, now) {
-    return this.driver.exec(
-      `UPDATE actions SET status = 'completed', completed_at = ?, summary = 'Auto-closed: task marked done' WHERE task_id = ? AND status = 'in_progress'`,
-      [now, taskId]
-    );
-  }
-  async getById(actionId) {
-    return this.driver.queryOne(`SELECT * FROM actions WHERE id = ?`, [actionId]);
-  }
-  async getForTask(taskId) {
-    return this.driver.query(
-      `SELECT * FROM actions WHERE task_id = ? ORDER BY created_at`,
-      [taskId]
-    );
-  }
-  async getAll() {
-    return this.driver.query(`SELECT * FROM actions ORDER BY created_at`);
-  }
-  async getWithDetails(taskId) {
-    const actions = await this.getForTask(taskId);
-    return Promise.all(
-      actions.map(async (action) => ({
-        ...action,
-        sections: await this.getSections(action.id),
-        files: await this.getFiles(action.id),
-        tools: await this.getTools(action.id)
-      }))
-    );
-  }
-  // ─── Sections ─────────────────────────────────────────────────────────────
-  async addSection(actionId, sectionType, content, now) {
-    await this.driver.exec(
-      `INSERT INTO action_sections (action_id, section_type, content, created_at) VALUES (?, ?, ?, ?)`,
-      [actionId, sectionType, content, now]
-    );
-  }
-  async getSections(actionId) {
-    return this.driver.query(
-      `SELECT * FROM action_sections WHERE action_id = ? ORDER BY created_at`,
-      [actionId]
-    );
-  }
-  async getAllSections() {
-    return this.driver.query(`SELECT * FROM action_sections ORDER BY created_at`);
-  }
-  // ─── Files ────────────────────────────────────────────────────────────────
-  async addFile(actionId, filePath, operation, notes) {
-    await this.driver.exec(
-      `INSERT INTO action_files (action_id, file_path, operation, notes) VALUES (?, ?, ?, ?)`,
-      [actionId, filePath, operation, notes]
-    );
-  }
-  async getFiles(actionId) {
-    return this.driver.query(
-      `SELECT * FROM action_files WHERE action_id = ?`,
-      [actionId]
-    );
-  }
-  async getFilesForTask(taskId) {
-    return this.driver.query(
-      `SELECT af.*, a.agent FROM action_files af JOIN actions a ON af.action_id = a.id WHERE a.task_id = ? ORDER BY a.agent, af.operation`,
-      [taskId]
-    );
-  }
-  // ─── Tools ────────────────────────────────────────────────────────────────
-  async addTool(actionId, toolName, argsJson, resultSummary, now) {
-    await this.driver.exec(
-      `INSERT INTO action_tools (action_id, tool_name, args_json, result_summary, called_at) VALUES (?, ?, ?, ?, ?)`,
-      [actionId, toolName, argsJson, resultSummary, now]
-    );
-  }
-  async getTools(actionId) {
-    return this.driver.query(
-      `SELECT * FROM action_tools WHERE action_id = ? ORDER BY called_at`,
-      [actionId]
-    );
-  }
-  async getTopTools(limit) {
-    return this.driver.query(
-      `SELECT tool_name, COUNT(*) as uses FROM action_tools GROUP BY tool_name ORDER BY uses DESC LIMIT ?`,
-      [limit]
-    );
-  }
-};
-
-// src/core/repositories/StatsRepository.ts
-var AGENT_ORDER = ["lead", "explorer", "builder", "reviewer"];
-var StatsRepository = class {
-  constructor(driver) {
-    this.driver = driver;
-  }
-  driver;
-  async getCounts() {
-    const [{ total: totalActions }] = await this.driver.query(
-      `SELECT COUNT(*) as total FROM actions`
-    );
-    const [{ total: totalFiles }] = await this.driver.query(
-      `SELECT COUNT(*) as total FROM action_files`
-    );
-    const [{ total: uniqueTools }] = await this.driver.query(
-      `SELECT COUNT(DISTINCT tool_name) as total FROM action_tools`
-    );
-    const [{ total: activeAgents }] = await this.driver.query(
-      `SELECT COUNT(DISTINCT agent) as total FROM actions WHERE status = 'in_progress'`
-    );
-    return { totalActions, totalFiles, uniqueTools, activeAgents };
-  }
-  async getRecentTools(limit) {
-    return this.driver.query(
-      `SELECT at.*, t.id as task_id, t.title as task_title, t.slug as task_slug, a.agent
-       FROM action_tools at
-       JOIN actions a ON at.action_id = a.id
-       JOIN tasks t ON a.task_id = t.id
-       ORDER BY at.called_at DESC
-       LIMIT ?`,
-      [limit]
-    );
-  }
-  async getTopFiles(limit) {
-    return this.driver.query(
-      `SELECT
-        file_path,
-        COUNT(*) as total,
-        SUM(CASE WHEN operation='read'     THEN 1 ELSE 0 END) as read,
-        SUM(CASE WHEN operation='created'  THEN 1 ELSE 0 END) as created,
-        SUM(CASE WHEN operation='modified' THEN 1 ELSE 0 END) as modified,
-        SUM(CASE WHEN operation='deleted'  THEN 1 ELSE 0 END) as deleted
-       FROM action_files
-       GROUP BY file_path
-       ORDER BY total DESC
-       LIMIT ?`,
-      [limit]
-    );
-  }
-  async getRecentFiles(limit) {
-    return this.driver.query(
-      `SELECT af.*, t.id as task_id, t.title as task_title, t.slug as task_slug,
-        a.agent, a.created_at as called_at
-       FROM action_files af
-       JOIN actions a ON af.action_id = a.id
-       JOIN tasks t ON a.task_id = t.id
-       ORDER BY a.created_at DESC
-       LIMIT ?`,
-      [limit]
-    );
-  }
-  async getAgentStats() {
-    const rows = await this.driver.query(
-      `SELECT
-        a.agent,
-        COUNT(*)                                              as actions_total,
-        SUM(CASE WHEN a.status='completed' THEN 1 ELSE 0 END) as actions_done,
-        SUM(CASE WHEN a.status='blocked'   THEN 1 ELSE 0 END) as actions_blocked,
-        COUNT(DISTINCT a.task_id)                             as tasks_worked,
-        COUNT(DISTINCT af.file_path)                          as files_touched
-       FROM actions a
-       LEFT JOIN action_files af ON af.action_id = a.id
-       GROUP BY a.agent
-       ORDER BY actions_total DESC`
-    );
-    return rows.sort((a, b) => {
-      const ai = AGENT_ORDER.indexOf(a.agent);
-      const bi = AGENT_ORDER.indexOf(b.agent);
-      if (ai === -1 && bi === -1) return 0;
-      if (ai === -1) return 1;
-      if (bi === -1) return -1;
-      return ai - bi;
-    });
-  }
-  async getTimeline(limit) {
-    return this.driver.query(
-      `SELECT a.*, t.title as task_title, t.slug as task_slug, t.status as task_status
-       FROM actions a
-       JOIN tasks t ON a.task_id = t.id
-       ORDER BY a.created_at DESC
-       LIMIT ?`,
-      [limit]
-    );
-  }
-};
-
-// src/core/repositories/TaskRepository.ts
-var TaskRepository = class {
-  constructor(driver) {
-    this.driver = driver;
-  }
-  driver;
-  async add(params) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return this.driver.insert(
-      `INSERT INTO tasks (slug, title, description, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`,
-      [params.slug, params.title, params.description ?? null, params.status ?? "pending", now, now]
-    );
-  }
-  async addAcceptance(taskId, criteria) {
-    for (const criterion of criteria) {
-      await this.driver.exec(
-        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`,
-        [taskId, criterion]
-      );
-    }
-  }
-  async getAll(status, includeArchived = false) {
-    let sql = `SELECT * FROM tasks`;
-    const params = [];
-    const conditions = [];
-    if (!includeArchived) {
-      conditions.push(`archived_at IS NULL`);
-    }
-    if (status) {
-      conditions.push(`status = ?`);
-      params.push(status);
-    }
-    if (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" AND ")}`;
-    }
-    sql += ` ORDER BY CASE status WHEN 'pending' THEN 1 WHEN 'in_progress' THEN 2 WHEN 'blocked' THEN 3 WHEN 'done' THEN 4 ELSE 5 END, updated_at DESC`;
-    return this.driver.query(sql, params);
-  }
-  async getAllWithAcceptanceCounts(includeArchived = false) {
-    let sql = `
-      SELECT t.*,
-        COUNT(ta.id) as acceptance_total,
-        COALESCE(SUM(ta.met), 0) as acceptance_met
-      FROM tasks t
-      LEFT JOIN task_acceptance ta ON ta.task_id = t.id
-    `;
-    if (!includeArchived) {
-      sql += ` WHERE t.archived_at IS NULL`;
-    }
-    sql += ` GROUP BY t.id ORDER BY CASE t.status WHEN 'pending' THEN 1 WHEN 'in_progress' THEN 2 WHEN 'blocked' THEN 3 WHEN 'done' THEN 4 ELSE 5 END, t.updated_at DESC`;
-    return this.driver.query(sql);
-  }
-  async getById(id) {
-    return this.driver.queryOne(`SELECT * FROM tasks WHERE id = ?`, [id]);
-  }
-  async getBySlug(slug) {
-    return this.driver.queryOne(`SELECT * FROM tasks WHERE slug = ?`, [slug]);
-  }
-  async getAcceptance(taskId) {
-    return this.driver.query(
-      `SELECT * FROM task_acceptance WHERE task_id = ?`,
-      [taskId]
-    );
-  }
-  async setStatus(id, status, extra) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (extra?.started_at) {
-      await this.driver.exec(
-        `UPDATE tasks SET status = ?, started_at = ?, updated_at = ? WHERE id = ?`,
-        [status, extra.started_at, now, id]
-      );
-    } else if (extra?.completed_at) {
-      await this.driver.exec(
-        `UPDATE tasks SET status = ?, completed_at = ?, updated_at = ? WHERE id = ?`,
-        [status, extra.completed_at, now, id]
-      );
-    } else {
-      await this.driver.exec(`UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?`, [status, now, id]);
-    }
-  }
-  async update(id, params) {
-    const sets = [];
-    const vals = [];
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (params.title !== void 0) {
-      sets.push("title = ?");
-      vals.push(params.title);
-    }
-    if (params.description !== void 0) {
-      sets.push("description = ?");
-      vals.push(params.description);
-    }
-    if (params.slug !== void 0) {
-      sets.push("slug = ?");
-      vals.push(params.slug);
-    }
-    if (sets.length === 0) return;
-    sets.push("updated_at = ?");
-    vals.push(now);
-    vals.push(id);
-    await this.driver.exec(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`, vals);
-  }
-  async replaceAcceptance(taskId, criteria) {
-    await this.driver.exec(`DELETE FROM task_acceptance WHERE task_id = ?`, [taskId]);
-    for (const criterion of criteria) {
-      await this.driver.exec(
-        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`,
-        [taskId, criterion]
-      );
-    }
-  }
-  async archive(id) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.driver.exec(`UPDATE tasks SET archived_at = ?, updated_at = ? WHERE id = ?`, [now, now, id]);
-  }
-  async unarchive(id) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.driver.exec(`UPDATE tasks SET archived_at = NULL, updated_at = ? WHERE id = ?`, [now, id]);
-  }
-  async getArchived() {
-    return this.driver.query(
-      `SELECT * FROM tasks WHERE archived_at IS NOT NULL ORDER BY archived_at DESC`
-    );
-  }
-  async claim(id, agent, now) {
-    return this.driver.exec(
-      `UPDATE tasks SET status = 'in_progress', assigned_to = ?, started_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`,
-      [agent, now, now, id]
-    );
-  }
-  async markAcceptanceMet(criterionId) {
-    await this.driver.exec(`UPDATE task_acceptance SET met = 1 WHERE id = ?`, [criterionId]);
-  }
-  async getStatusSummary() {
-    return this.driver.query(
-      `SELECT status, COUNT(*) as total FROM tasks WHERE archived_at IS NULL GROUP BY status`
-    );
-  }
-};
-
-// src/core/db.ts
-var HarnessDB = class {
-  tasks;
-  actions;
-  stats;
-  driver;
-  config;
-  constructor(driver, config) {
-    this.driver = driver;
-    this.config = config;
-    this.tasks = new TaskRepository(driver);
-    this.actions = new ActionRepository(driver);
-    this.stats = new StatsRepository(driver);
-  }
-  // ─── Tasks (public facade — delegates to TaskRepository) ──────────────────
-  async addTask(params) {
-    const taskId = await this.tasks.add({
-      slug: params.slug,
-      title: params.title,
-      description: params.description
-    });
-    if (params.acceptance?.length) {
-      await this.tasks.addAcceptance(taskId, params.acceptance);
-    }
-    await this.regenerateCurrentMd();
-    return await this.tasks.getById(taskId);
-  }
-  async getTasks(status, includeArchived = false) {
-    return this.tasks.getAll(status, includeArchived);
-  }
-  async getTaskById(id) {
-    return this.tasks.getById(id);
-  }
-  async getTaskBySlug(slug) {
-    return this.tasks.getBySlug(slug);
-  }
-  async getTaskAcceptance(taskId) {
-    return this.tasks.getAcceptance(taskId);
-  }
-  async updateTaskStatus(idOrSlug, status) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const task2 = typeof idOrSlug === "number" ? await this.tasks.getById(idOrSlug) : await this.tasks.getBySlug(idOrSlug);
-    if (!task2) throw new Error(`Task not found: ${idOrSlug}`);
-    if (status === "in_progress" && !task2.started_at) {
-      await this.tasks.setStatus(task2.id, status, { started_at: now });
-    } else if (status === "done") {
-      await this.tasks.setStatus(task2.id, status, { completed_at: now });
-    } else {
-      await this.tasks.setStatus(task2.id, status);
-    }
-    await this.regenerateCurrentMd();
-    return await this.tasks.getById(task2.id);
-  }
-  async claimTask(id, agent) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return this.driver.transaction(async (tx) => {
-      const txTasks = new TaskRepository(tx);
-      const changed = await txTasks.claim(id, agent, now);
-      if (!changed) return null;
-      const task2 = await txTasks.getById(id);
-      if (!task2 || task2.status !== "in_progress" || task2.assigned_to !== agent) return null;
-      await this.regenerateCurrentMd();
-      return task2;
-    });
-  }
-  async markAcceptanceMet(criterionId) {
-    return this.tasks.markAcceptanceMet(criterionId);
-  }
-  async updateTask(id, params) {
-    await this.tasks.update(id, params);
-    await this.regenerateCurrentMd();
-    return await this.tasks.getById(id);
-  }
-  async updateTaskAcceptance(taskId, criteria) {
-    await this.tasks.replaceAcceptance(taskId, criteria);
-    await this.regenerateCurrentMd();
-  }
-  async archiveTask(id) {
-    await this.tasks.archive(id);
-    await this.regenerateCurrentMd();
-    return await this.tasks.getById(id);
-  }
-  async unarchiveTask(id) {
-    await this.tasks.unarchive(id);
-    await this.regenerateCurrentMd();
-    return await this.tasks.getById(id);
-  }
-  async getArchivedTasks() {
-    return this.tasks.getArchived();
-  }
-  async getStatusSummary() {
-    return this.tasks.getStatusSummary();
-  }
-  // ─── Actions (public facade — delegates to ActionRepository) ──────────────
-  async startAction(taskId, agent) {
-    const id = randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.actions.create(id, taskId, agent, now);
-    await this.regenerateCurrentMd();
-    return await this.actions.getById(id);
-  }
-  async writeSection(actionId, sectionType, content) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.actions.addSection(actionId, sectionType, content, now);
-    await this.regenerateCurrentMd();
-  }
-  async completeAction(actionId, summary) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.actions.complete(actionId, summary, now);
-    await this.regenerateCurrentMd();
-    return await this.actions.getById(actionId);
-  }
-  async closeOrphanedActions(taskId) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return this.actions.closeOrphaned(taskId, now);
-  }
-  async getAction(actionId) {
-    return this.actions.getById(actionId);
-  }
-  async getActionsForTask(taskId) {
-    return this.actions.getForTask(taskId);
-  }
-  async getActionSections(actionId) {
-    return this.actions.getSections(actionId);
-  }
-  async recordFile(actionId, filePath, operation, notes) {
-    return this.actions.addFile(actionId, filePath, operation, notes ?? null);
-  }
-  async recordTool(actionId, toolName, argsJson, resultSummary) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return this.actions.addTool(actionId, toolName, argsJson ?? null, resultSummary ?? null, now);
-  }
-  async getFilesForTask(taskId) {
-    return this.actions.getFilesForTask(taskId);
-  }
-  async getTopTools(limit = 10) {
-    return this.actions.getTopTools(limit);
-  }
-  // ─── current.md fallback ──────────────────────────────────────────────────
-  async regenerateCurrentMd() {
-    if (!this.config.storage.markdownFallback.enabled) return;
-    const mdPath = resolve6(this.config.storage.markdownFallback.path);
-    mkdirSync7(dirname4(mdPath), { recursive: true });
-    const inProgress = await this.tasks.getAll("in_progress");
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    let md = `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
-`;
-    md += `<!-- Last updated: ${now} -->
-
-`;
-    md += `# Current Session
-
-`;
-    if (inProgress.length === 0) {
-      md += `## No tasks in progress
-
-`;
-      const pending = await this.tasks.getAll("pending");
-      if (pending.length > 0) {
-        md += `### Next pending tasks
-`;
-        for (const t of pending.slice(0, 5)) {
-          md += `- **#${t.id}** ${t.title} (\`${t.slug}\`)
-`;
-        }
-      }
-    } else {
-      for (const task2 of inProgress) {
-        md += `## Active Task
-`;
-        md += `- **ID:** ${task2.id}
-`;
-        md += `- **Slug:** ${task2.slug}
-`;
-        md += `- **Status:** ${task2.status}
-`;
-        md += `- **Started:** ${task2.started_at ?? "unknown"}
-
-`;
-        const taskActions = await this.actions.getForTask(task2.id);
-        if (taskActions.length > 0) {
-          md += `## Actions this session
-`;
-          md += `| Agent    | Status      | Summary                          | Started     |
-`;
-          md += `|----------|-------------|----------------------------------|-------------|
-`;
-          for (const a of taskActions) {
-            const started = a.created_at.slice(11, 16);
-            const summary = (a.summary ?? "").slice(0, 34).padEnd(34);
-            md += `| ${a.agent.padEnd(8)} | ${a.status.padEnd(11)} | ${summary} | ${started}       |
-`;
-          }
-          md += `
-`;
-        }
-        const acceptance = await this.tasks.getAcceptance(task2.id);
-        if (acceptance.length > 0) {
-          md += `## Acceptance Criteria
-`;
-          for (const a of acceptance) {
-            md += `- [${a.met ? "x" : " "}] ${a.criterion}
-`;
-          }
-          md += `
-`;
-        }
-      }
-    }
-    writeFileSync7(mdPath, md, "utf8");
-  }
-  // ─── Raw query escape hatch ───────────────────────────────────────────────
-  async queryRaw(sql, ...params) {
-    return this.driver.query(sql, params);
-  }
-  // ─── Export helpers ───────────────────────────────────────────────────────
-  async exportJson() {
-    return {
-      tasks: await this.tasks.getAll(void 0, true),
-      actions: await this.actions.getAll(),
-      sections: await this.actions.getAllSections()
-    };
-  }
-  async reconnect() {
-    await this.driver.reconnect();
-  }
-  async close() {
-    await this.driver.close();
-  }
-  // ─── feature_list.json sync ───────────────────────────────────────────────
-  async syncFromFeatureList(seeds) {
-    let added = 0;
-    let skipped = 0;
-    for (const t of seeds) {
-      if (await this.tasks.getBySlug(t.slug)) {
-        skipped++;
-        continue;
-      }
-      await this.addTask(t);
-      added++;
-    }
-    return { added, skipped };
-  }
-  async writeFeatureList(cwd2) {
-    const allTasks = await this.tasks.getAll(void 0, true);
-    const list = await Promise.all(
-      allTasks.map(async (t) => ({
-        slug: t.slug,
-        title: t.title,
-        description: t.description ?? void 0,
-        acceptance: (await this.tasks.getAcceptance(t.id)).map((a) => a.criterion),
-        status: t.status
-      }))
-    );
-    const path = join8(resolve6(cwd2), this.config.storage.dir, "feature_list.json");
-    mkdirSync7(dirname4(path), { recursive: true });
-    writeFileSync7(path, JSON.stringify(list, null, 2) + "\n", "utf8");
-  }
-};
-async function openDB(config, cwd2) {
-  const dbConfig = config.database;
-  let driver;
-  if (dbConfig.type === "postgres") {
-    const { PostgresDriver } = await import("./postgres-IOQE32DM.js");
-    driver = new PostgresDriver(dbConfig);
-  } else if (dbConfig.type === "mysql") {
-    const { MySQLDriver } = await import("./mysql-THKQOXIS.js");
-    driver = new MySQLDriver(dbConfig);
-  } else {
-    const { SQLiteDriver } = await import("./sqlite-KWYK4IJW.js");
-    if (dbConfig.type !== "sqlite") {
-      throw new Error("Invalid database type");
-    }
-    driver = new SQLiteDriver(resolve6(cwd2, dbConfig.path));
-  }
-  await driver.ensureSchema();
-  return new HarnessDB(driver, config);
-}
-
 // src/commands/dashboard.ts
-var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
+var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
 async function runDashboard(cwd2, opts) {
   const config = await loadConfig(cwd2);
   const db = await openDB(config, cwd2);
-  const dbPath = config.database.type === "sqlite" ? resolve7(cwd2, config.database.path) : null;
+  const dbPath = config.database.type === "sqlite" ? resolve6(cwd2, config.database.path) : null;
   const staticPath = join9(__dirname3, "dashboard-dist");
   const { url } = await startDashboardServer(db, dbPath, staticPath, opts.port);
   console.log(pc2.green(`\u2713`) + ` Dashboard running at ${pc2.bold(pc2.cyan(url))}`);
@@ -1834,26 +1339,37 @@ async function runDashboard(cwd2, opts) {
 import pc3 from "picocolors";
 
 // src/core/doctor.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname6, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/core/package-data.ts
+import { existsSync as existsSync8 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname6, join as join10 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var require2 = createRequire(import.meta.url);
-var pkgPath = join10(dirname6(fileURLToPath4(import.meta.url)), "..", "package.json");
+var here = dirname5(fileURLToPath4(import.meta.url));
+var candidates = [join10(here, "..", "..", "package.json"), join10(here, "..", "package.json")];
+var pkgPath = candidates.find((p8) => existsSync8(p8)) ?? candidates[0];
 var pkg = require2(pkgPath);
 
 // src/core/doctor.ts
 var REGISTRY_URL = `https://registry.npmjs.org/${pkg.name}/latest`;
 var TIMEOUT_MS = 2e3;
+var LIB_VERSION_CACHE_TTL_MS = 5 * 60 * 1e3;
 var AGENT_NAMES = ["lead", "explorer", "consultant", "builder", "reviewer"];
-var SKILL_NAMES = ["ahk-ask", "ahk-consultant", "ahk-triage"];
-var __dirname4 = dirname7(fileURLToPath5(import.meta.url));
+var SKILL_NAMES = ["ahk-ask", "ahk-consultant", "ahk-triage", "ahk-review"];
+var __dirname4 = dirname6(fileURLToPath5(import.meta.url));
+var libVersionCache = null;
 async function checkLibVersion() {
   const current = pkg.version;
+  if (libVersionCache && Date.now() - libVersionCache.fetchedAt < LIB_VERSION_CACHE_TTL_MS) {
+    if (libVersionCache.status.current === current) {
+      return libVersionCache.status;
+    }
+  }
   try {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
@@ -1862,9 +1378,13 @@ async function checkLibVersion() {
     const data = await res.json();
     const latest = data.version;
     const outdated = isNewer(latest, current);
-    return { current, latest, outdated };
+    const status = { current, latest, outdated };
+    libVersionCache = { status, fetchedAt: Date.now() };
+    return status;
   } catch {
-    return { current, latest: null, outdated: false };
+    const status = { current, latest: null, outdated: false };
+    libVersionCache = { status, fetchedAt: Date.now() };
+    return status;
   }
 }
 function isNewer(latest, current) {
@@ -1888,7 +1408,7 @@ function getProviderAgentInfo(provider) {
   }
 }
 function generateExpectedAgentContent(agentName, provider, vars) {
-  const { projectName, allowedPaths, writablePaths } = vars;
+  const { projectName, allowedPaths, writablePaths, model } = vars;
   if (provider === "claude-code") {
     const templateFns = {
       lead: () => agentLead({ projectName }),
@@ -1897,7 +1417,7 @@ function generateExpectedAgentContent(agentName, provider, vars) {
       builder: () => agentBuilder({ projectName, writablePaths }),
       reviewer: () => agentReviewer({ projectName })
     };
-    return translateFrontmatterForClaudeCode(templateFns[agentName](), agentName);
+    return translateFrontmatterForClaudeCode(templateFns[agentName](), agentName, model);
   }
   if (provider === "opencode") {
     const templateFns = {
@@ -1910,27 +1430,27 @@ function generateExpectedAgentContent(agentName, provider, vars) {
     return translateFrontmatterForOpenCode(templateFns[agentName]());
   }
   const tomlFns = {
-    lead: () => agentLeadToml({ projectName }),
-    explorer: () => agentExplorerToml({ projectName, allowedPaths }),
-    consultant: () => agentConsultantToml({ projectName }),
-    builder: () => agentBuilderToml({ projectName, writablePaths }),
-    reviewer: () => agentReviewerToml({ projectName })
+    lead: () => agentLeadToml({ projectName, model }),
+    explorer: () => agentExplorerToml({ projectName, allowedPaths, model }),
+    consultant: () => agentConsultantToml({ projectName, model }),
+    builder: () => agentBuilderToml({ projectName, writablePaths, model }),
+    reviewer: () => agentReviewerToml({ projectName, model })
   };
   return tomlFns[agentName]();
 }
-function checkAgentFiles(cwd2, provider, projectName, allowedPaths, writablePaths) {
-  const { agentsDir, ext } = getProviderAgentInfo(provider);
+function checkAgentFilesAtRoot(agentsRoot, ext, provider, projectName, allowedPaths, writablePaths, models) {
   return AGENT_NAMES.map((name) => {
-    const filePath = join11(cwd2, agentsDir, `${name}${ext}`);
-    if (!existsSync7(filePath)) {
+    const filePath = join11(agentsRoot, `${name}${ext}`);
+    if (!existsSync9(filePath)) {
       return { name, status: "missing" };
     }
     try {
-      const live = readFileSync6(filePath, "utf8");
+      const live = readFileSync7(filePath, "utf8");
       const expected = generateExpectedAgentContent(name, provider, {
         projectName,
         allowedPaths,
-        writablePaths
+        writablePaths,
+        model: models[name]
       });
       return { name, status: live === expected ? "ok" : "outdated" };
     } catch {
@@ -1938,6 +1458,18 @@ function checkAgentFiles(cwd2, provider, projectName, allowedPaths, writablePath
     }
   });
 }
+function checkAgentFiles(cwd2, provider, projectName, allowedPaths, writablePaths, models) {
+  const { agentsDir, ext } = getProviderAgentInfo(provider);
+  return checkAgentFilesAtRoot(
+    join11(cwd2, agentsDir),
+    ext,
+    provider,
+    projectName,
+    allowedPaths,
+    writablePaths,
+    models
+  );
+}
 function getProviderSkillsDir(provider) {
   switch (provider) {
     case "claude-code":
@@ -1950,24 +1482,76 @@ function getProviderSkillsDir(provider) {
       return ".claude/skills";
   }
 }
-function checkSkills(cwd2, provider) {
-  const skillsDir = getProviderSkillsDir(provider);
+function checkSkillsAtRoot(skillsRoot) {
   const skillSourceBase = join11(__dirname4, "skills");
   return SKILL_NAMES.map((name) => {
-    const livePath = join11(cwd2, skillsDir, name, "SKILL.md");
+    const livePath = join11(skillsRoot, name, "SKILL.md");
     const sourcePath = join11(skillSourceBase, name, "SKILL.md");
-    if (!existsSync7(livePath)) {
+    if (!existsSync9(livePath)) {
       return { name, status: "missing" };
     }
     try {
-      const live = readFileSync6(livePath, "utf8");
-      const source = readFileSync6(sourcePath, "utf8");
+      const live = readFileSync7(livePath, "utf8");
+      const source = readFileSync7(sourcePath, "utf8");
       return { name, status: live === source ? "ok" : "outdated" };
     } catch {
       return { name, status: "outdated" };
     }
   });
 }
+function checkSkills(cwd2, provider) {
+  const skillsDir = getProviderSkillsDir(provider);
+  return checkSkillsAtRoot(join11(cwd2, skillsDir));
+}
+function getGlobalProviderAgentDir(provider, homeDir) {
+  switch (provider) {
+    case "claude-code":
+      return { agentsDir: join11(homeDir, ".claude", "agents"), ext: ".md" };
+    case "opencode":
+      return { agentsDir: join11(homeDir, ".config", "opencode", "agents"), ext: ".md" };
+    case "codex-cli":
+      return { agentsDir: join11(homeDir, ".codex", "agents"), ext: ".toml" };
+    default:
+      return { agentsDir: join11(homeDir, ".claude", "agents"), ext: ".md" };
+  }
+}
+function getGlobalProviderSkillsDir(provider, homeDir) {
+  switch (provider) {
+    case "claude-code":
+      return join11(homeDir, ".claude", "skills");
+    case "opencode":
+      return join11(homeDir, ".config", "opencode", "skills");
+    case "codex-cli":
+      return join11(homeDir, ".agents", "skills");
+    default:
+      return join11(homeDir, ".claude", "skills");
+  }
+}
+async function getGlobalDoctorStatus(provider, config, homeDir = homedir()) {
+  const projectName = config.project.name;
+  const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
+  const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
+  const models = {
+    lead: config.agents.lead.model,
+    explorer: config.agents.explorer.model,
+    consultant: config.agents.consultant?.model,
+    builder: config.agents.builder.model,
+    reviewer: config.agents.reviewer.model
+  };
+  const { agentsDir, ext } = getGlobalProviderAgentDir(provider, homeDir);
+  const agents = checkAgentFilesAtRoot(
+    agentsDir,
+    ext,
+    provider,
+    projectName,
+    allowedPaths,
+    writablePaths,
+    models
+  );
+  const skillsDir = getGlobalProviderSkillsDir(provider, homeDir);
+  const skills = checkSkillsAtRoot(skillsDir);
+  return { agents, skills };
+}
 async function getDoctorStatus(cwd2) {
   const lib = await checkLibVersion();
   let config;
@@ -1984,7 +1568,14 @@ async function getDoctorStatus(cwd2) {
   const projectName = config.project.name;
   const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
   const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
-  const agents = checkAgentFiles(cwd2, provider, projectName, allowedPaths, writablePaths);
+  const models = {
+    lead: config.agents.lead.model,
+    explorer: config.agents.explorer.model,
+    consultant: config.agents.consultant?.model,
+    builder: config.agents.builder.model,
+    reviewer: config.agents.reviewer.model
+  };
+  const agents = checkAgentFiles(cwd2, provider, projectName, allowedPaths, writablePaths, models);
   const skills = checkSkills(cwd2, provider);
   return { lib, agents, skills };
 }
@@ -2074,7 +1665,7 @@ async function runDoctor(cwd2) {
 }
 
 // src/commands/export.ts
-import { writeFileSync as writeFileSync8 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import pc4 from "picocolors";
 async function runExport(cwd2, opts) {
   if (!opts.sql && !opts.json) {
@@ -2088,7 +1679,7 @@ async function runExport(cwd2, opts) {
       const data = await db.exportJson();
       const out = JSON.stringify(data, null, 2) + "\n";
       if (opts.output) {
-        writeFileSync8(opts.output, out, "utf8");
+        writeFileSync7(opts.output, out, "utf8");
         console.log(pc4.green(`\u2713 Exported JSON \u2192 ${opts.output}`));
       } else {
         process.stdout.write(out);
@@ -2105,8 +1696,8 @@ async function runExport(cwd2, opts) {
 
 // src/commands/health.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { join as join12, resolve as resolve8 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join12, resolve as resolve7 } from "path";
 import pc5 from "picocolors";
 function checkLine(label, ok3, message, indent = 0) {
   const prefix = label ? pc5.cyan(`[${label}] `) : " ".repeat(indent);
@@ -2124,8 +1715,8 @@ async function runHealth(cwd2) {
   let allOk = true;
   let dbOk;
   if (config.database.type === "sqlite") {
-    const dbPath = resolve8(cwd2, config.database.path);
-    dbOk = existsSync8(dbPath);
+    const dbPath = resolve7(cwd2, config.database.path);
+    dbOk = existsSync10(dbPath);
     checkLine("checking DB", dbOk, `${config.database.path} reachable`);
   } else {
     dbOk = true;
@@ -2139,7 +1730,7 @@ async function runHealth(cwd2) {
   for (let i = 0; i < agentNames.length; i++) {
     const name = agentNames[i];
     const agentPath = join12(cwd2, agentsDir, `${name}${providerFiles.agentExtension}`);
-    const ok3 = existsSync8(agentPath);
+    const ok3 = existsSync10(agentPath);
     checkLine(
       i === 0 ? "checking agents" : null,
       ok3,
@@ -2150,8 +1741,8 @@ async function runHealth(cwd2) {
   }
   if (config.tools.mcp.enabled) {
     const mcpFile = providerFiles.mcpFile;
-    const mcpPath = resolve8(cwd2, mcpFile);
-    const mcpOk = existsSync8(mcpPath);
+    const mcpPath = resolve7(cwd2, mcpFile);
+    const mcpOk = existsSync10(mcpPath);
     checkLine("checking MCP", mcpOk, `${mcpFile} valid`);
     if (!mcpOk) allOk = false;
   }
@@ -2160,8 +1751,8 @@ async function runHealth(cwd2) {
     console.error(pc5.red("\u2717 Harness checks failed \u2014 fix the above before running health.sh"));
     process.exit(1);
   }
-  const scriptPath = resolve8(cwd2, config.health.scriptPath);
-  if (!existsSync8(scriptPath)) {
+  const scriptPath = resolve7(cwd2, config.health.scriptPath);
+  if (!existsSync10(scriptPath)) {
     console.error(pc5.red(`\u2717 health.sh not found: ${scriptPath}`));
     console.error("  Run ahk init first.");
     process.exit(1);
@@ -2197,11 +1788,56 @@ function getProviderHealthFiles(provider) {
 }
 
 // src/commands/init.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
 import { join as join14 } from "path";
 import * as p3 from "@clack/prompts";
 import pc7 from "picocolors";
 
+// src/core/materializer/global-sync.ts
+import { homedir as homedir2 } from "os";
+async function syncGlobalAgentsAndSkills(config, provider, homeDir = homedir2()) {
+  const status = await getGlobalDoctorStatus(provider, config, homeDir);
+  const missingAgents = status.agents.filter((a) => a.status === "missing");
+  const missingSkills = status.skills.filter((s) => s.status === "missing");
+  if (missingAgents.length === 0 && missingSkills.length === 0) {
+    return { alreadySynced: true, createdAgents: [], createdSkills: [] };
+  }
+  const projectName = config.project.name;
+  const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
+  const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
+  const models = {
+    lead: config.agents.lead.model,
+    explorer: config.agents.explorer.model,
+    consultant: config.agents.consultant?.model,
+    builder: config.agents.builder.model,
+    reviewer: config.agents.reviewer.model
+  };
+  const createdAgents = [];
+  if (missingAgents.length > 0) {
+    const { agentsDir, ext } = getGlobalProviderAgentDir(provider, homeDir);
+    for (const agent of missingAgents) {
+      const name = agent.name;
+      const content = generateExpectedAgentContent(name, provider, {
+        projectName,
+        allowedPaths,
+        writablePaths,
+        model: models[name]
+      });
+      writeAgentFile(agentsDir, `${name}${ext}`, content);
+      createdAgents.push(name);
+    }
+  }
+  const createdSkills = [];
+  if (missingSkills.length > 0) {
+    const skillsDir = getGlobalProviderSkillsDir(provider, homeDir);
+    for (const skill of missingSkills) {
+      writeSkill(skillsDir, skill.name);
+      createdSkills.push(skill.name);
+    }
+  }
+  return { alreadySynced: false, createdAgents, createdSkills };
+}
+
 // src/schema/init.ts
 import * as v from "valibot";
 var initNameSchema = v.pipe(
@@ -2253,14 +1889,15 @@ var cliFormWithRetry = async (formFn, schema) => {
 };
 
 // src/commands/init-helpers.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
 import { join as join13 } from "path";
 import pc6 from "picocolors";
 function readProjectNameFromPackageJson(cwd2) {
   try {
     const pkgPath2 = join13(cwd2, "package.json");
-    if (!existsSync9(pkgPath2)) return null;
-    const content = readFileSync7(pkgPath2, "utf8");
+    if (!existsSync11(pkgPath2)) return null;
+    const content = readFileSync8(pkgPath2, "utf8");
     const pkg2 = JSON.parse(content);
     const name = pkg2?.name;
     if (typeof name === "string" && name.trim()) return name.trim();
@@ -2271,16 +1908,17 @@ function readProjectNameFromPackageJson(cwd2) {
 }
 function detectConfigExtension(cwd2) {
   try {
-    if (existsSync9(join13(cwd2, "tsconfig.json"))) return "ts";
+    if (existsSync11(join13(cwd2, "tsconfig.json"))) return "ts";
     const pkgPath2 = join13(cwd2, "package.json");
-    if (!existsSync9(pkgPath2)) return "mjs";
-    const pkg2 = JSON.parse(readFileSync7(pkgPath2, "utf8"));
+    if (!existsSync11(pkgPath2)) return "mjs";
+    const pkg2 = JSON.parse(readFileSync8(pkgPath2, "utf8"));
     if (pkg2?.type === "module") return "mjs";
   } catch {
   }
   return "mjs";
 }
 function applyConfigDefaults(params) {
+  const models = params.models ?? {};
   return {
     provider: params.provider,
     project: {
@@ -2290,10 +1928,19 @@ function applyConfigDefaults(params) {
       agentsMd: "./AGENTS.md"
     },
     agents: {
-      lead: { instructionsPath: null },
-      explorer: { instructionsPath: null, allowedPaths: [params.docsPath, "./src"] },
-      builder: { instructionsPath: null, writablePaths: ["./src", "./tests"] },
-      reviewer: { instructionsPath: null },
+      lead: { instructionsPath: null, ...models.lead && { model: models.lead } },
+      explorer: {
+        instructionsPath: null,
+        allowedPaths: [params.docsPath, "./src"],
+        ...models.explorer && { model: models.explorer }
+      },
+      builder: {
+        instructionsPath: null,
+        writablePaths: ["./src", "./tests"],
+        ...models.builder && { model: models.builder }
+      },
+      reviewer: { instructionsPath: null, ...models.reviewer && { model: models.reviewer } },
+      ...models.consultant && { consultant: { instructionsPath: null, model: models.consultant } },
       custom: []
     },
     database: { type: "sqlite", path: ".harness/harness.db" },
@@ -2307,7 +1954,9 @@ function applyConfigDefaults(params) {
         blockers: true,
         nextSteps: false
       },
-      markdownFallback: { enabled: true, path: ".harness/current.md" }
+      markdownFallback: { enabled: true, path: ".harness/current.md" },
+      scope: params.scope ?? "local",
+      projectId: params.projectId ?? randomUUID()
     },
     health: {
       scriptPath: "./health.sh",
@@ -2420,6 +2069,61 @@ async function runInit(cwd2, flags) {
     }
     provider = val;
   }
+  const AGENT_LABELS = [
+    { key: "lead", label: "Lead" },
+    { key: "explorer", label: "Explorer" },
+    { key: "consultant", label: "Consultant" },
+    { key: "builder", label: "Builder" },
+    { key: "reviewer", label: "Reviewer" }
+  ];
+  const modelOverrides = {};
+  if (provider === "claude-code" || provider === "codex-cli") {
+    const wantsModelCustomization = await p3.confirm({
+      message: "\xBFPersonalizar el modelo por agente?",
+      initialValue: false
+    });
+    if (p3.isCancel(wantsModelCustomization)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (wantsModelCustomization) {
+      if (provider === "claude-code") {
+        for (const agent of AGENT_LABELS) {
+          const val = await p3.select({
+            message: `Modelo para ${agent.label}`,
+            options: [
+              { value: "inherit", label: "inherit (default)" },
+              { value: "haiku", label: "haiku" },
+              { value: "sonnet", label: "sonnet" },
+              { value: "opus", label: "opus" },
+              { value: "fable", label: "fable" }
+            ],
+            initialValue: "inherit"
+          });
+          if (p3.isCancel(val)) {
+            p3.cancel("Cancelled.");
+            process.exit(0);
+          }
+          modelOverrides[agent.key] = val;
+        }
+      } else {
+        for (const agent of AGENT_LABELS) {
+          const val = await p3.text({
+            message: `Modelo para ${agent.label} (Codex no valida este valor)`,
+            placeholder: "ej. gpt-5 (vac\xEDo o <3 caracteres = sin override)"
+          });
+          if (p3.isCancel(val)) {
+            p3.cancel("Cancelled.");
+            process.exit(0);
+          }
+          const trimmed = val.trim();
+          if (trimmed.length >= 3) {
+            modelOverrides[agent.key] = trimmed;
+          }
+        }
+      }
+    }
+  }
   let docsPath;
   if (flags.docs) {
     docsPath = flags.docs;
@@ -2436,6 +2140,24 @@ async function runInit(cwd2, flags) {
       return val;
     }, initDocsSchema);
   }
+  let storageScope;
+  if (flags.storageScope && ["local", "global"].includes(flags.storageScope)) {
+    storageScope = flags.storageScope;
+  } else {
+    const val = await p3.select({
+      message: "Storage scope",
+      options: [
+        { value: "local", label: "Local \u2014 .harness/harness.db lives in this project" },
+        { value: "global", label: "Global \u2014 DB lives under ~/.harness/dbs/<projectId>/, outside the project" }
+      ],
+      initialValue: "local"
+    });
+    if (p3.isCancel(val)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+    storageScope = val;
+  }
   let tasksAdapter;
   if (flags.tasks && ["local", "jira", "linear"].includes(flags.tasks)) {
     tasksAdapter = flags.tasks;
@@ -2490,10 +2212,19 @@ async function runInit(cwd2, flags) {
     firstTask = { title: taskTitle, description: taskDesc, acceptance };
   }
   let configExt = "ts";
+  let globalSyncResult = null;
   const spinner6 = p3.spinner();
   spinner6.start("Scaffolding...");
   try {
-    const config = applyConfigDefaults({ name, description, provider, docsPath, tasksAdapter });
+    const config = applyConfigDefaults({
+      name,
+      description,
+      provider,
+      docsPath,
+      tasksAdapter,
+      models: modelOverrides,
+      scope: storageScope
+    });
     const materializer = getMaterializer(provider);
     const installDir = cwd2;
     configExt = detectConfigExtension(cwd2);
@@ -2505,12 +2236,19 @@ async function runInit(cwd2, flags) {
       provider,
       docsPath,
       tasksAdapter,
-      port: config.tools.mcp.port
+      port: config.tools.mcp.port,
+      models: modelOverrides,
+      scope: config.storage.scope,
+      projectId: config.storage.projectId
     });
-    writeFileSync9(join14(installDir, configFileName), configContent, "utf8");
-    mkdirSync8(join14(installDir, config.storage.dir), { recursive: true });
+    writeFileSync8(join14(installDir, configFileName), configContent, "utf8");
+    mkdirSync7(join14(installDir, config.storage.dir), { recursive: true });
     const db = await openDB(config, installDir);
+    await db.writeStorageState(installDir);
     await materializer.scaffold(config, { cwd: installDir, firstTask });
+    if (config.storage.scope === "global") {
+      globalSyncResult = await syncGlobalAgentsAndSkills(config, provider);
+    }
     if (firstTask) {
       const slug = slugify(firstTask.title);
       await db.addTask({
@@ -2534,14 +2272,28 @@ async function runInit(cwd2, flags) {
   console.log(pc7.green(`\u2713 agent-harness-kit.config.${configExt}`));
   console.log(pc7.green("\u2713 AGENTS.md"));
   console.log(pc7.green("\u2713 health.sh"));
-  console.log(pc7.green("\u2713 .harness/harness.db"));
-  console.log(pc7.green("\u2713 .harness/current.md"));
+  console.log(pc7.green(storageScope === "global" ? "\u2713 ~/.harness/dbs/<projectId>/harness.db" : "\u2713 .harness/harness.db"));
+  console.log(pc7.green(storageScope === "global" ? "\u2713 ~/.harness/dbs/<projectId>/current.md" : "\u2713 .harness/current.md"));
+  console.log(pc7.green("\u2713 .harness/storage-state.json"));
   console.log(pc7.green(`\u2713 ${agentsDir}lead.md`));
   console.log(pc7.green(`\u2713 ${agentsDir}explorer.md`));
   console.log(pc7.green(`\u2713 ${agentsDir}builder.md`));
   console.log(pc7.green(`\u2713 ${agentsDir}reviewer.md`));
   console.log(pc7.green(`\u2713 ${mcpFile}`));
   console.log(pc7.green("\u2713 .gitignore entries added"));
+  if (globalSyncResult) {
+    console.log("");
+    if (globalSyncResult.alreadySynced) {
+      console.log(pc7.dim("\u2713 Global agents/skills already synced \u2014 skipped"));
+    } else {
+      for (const name2 of globalSyncResult.createdAgents) {
+        console.log(pc7.green(`\u2713 ~global agent added: ${name2}`));
+      }
+      for (const name2 of globalSyncResult.createdSkills) {
+        console.log(pc7.green(`\u2713 ~global skill added: ${name2}`));
+      }
+    }
+  }
   console.log("");
   console.log(pc7.cyan("\u2192") + ` Edit ${pc7.cyan("health.sh")} with your project checks`);
   console.log(pc7.cyan("\u2192") + ` ${pc7.cyan("ahk task add")} to queue work for agents`);
@@ -2598,17 +2350,251 @@ async function runMigrate(cwd2, opts) {
   }
 }
 
+// src/commands/migrate-storage.ts
+import { copyFileSync, existsSync as existsSync12, mkdirSync as mkdirSync8, rmSync, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname7, join as join15, resolve as resolve8 } from "path";
+import pc9 from "picocolors";
+function log5(msg) {
+  console.log(msg);
+}
+function fail(msg) {
+  throw new Error(msg);
+}
+function currentMdPathForScope(scope, config, cwd2, homeDir) {
+  return scope === "global" ? join15(resolveGlobalStorageDir(config, homeDir), "current.md") : resolve8(cwd2, config.storage.markdownFallback.path);
+}
+async function backupDestination(cwd2, storageDir, data) {
+  const backupsDir = resolve8(cwd2, storageDir, "backups");
+  const path = join15(backupsDir, `pre-migrate-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
+  try {
+    mkdirSync8(backupsDir, { recursive: true });
+    writeFileSync9(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+  } catch (err) {
+    throw new Error(
+      `Could not write destination backup to ${path} (${err instanceof Error ? err.message : String(err)}). Aborting migration WITHOUT touching the destination \u2014 nothing was overwritten.`
+    );
+  }
+  return path;
+}
+function copySqliteFile(srcPath, destPath) {
+  mkdirSync8(dirname7(destPath), { recursive: true });
+  copyFileSync(srcPath, destPath);
+  for (const suffix of ["-wal", "-shm"]) {
+    if (existsSync12(`${srcPath}${suffix}`)) {
+      copyFileSync(`${srcPath}${suffix}`, `${destPath}${suffix}`);
+    }
+  }
+  if (!existsSync12(destPath)) {
+    throw new Error(`Copy verification failed: ${destPath} does not exist after copy.`);
+  }
+}
+async function runMigrateStorage(cwd2, opts, homeDir = homedir3()) {
+  const config = await loadConfig(cwd2);
+  const storageDir = config.storage.dir;
+  const state = readStorageStateFile(cwd2, storageDir);
+  let realScope;
+  let realDbType;
+  if (!state) {
+    const defaultSqlitePath = config.database.type === "sqlite" ? config.database.path : ".harness/harness.db";
+    const localPath = resolveSqlitePathForScope("local", defaultSqlitePath, cwd2, config, homeDir);
+    const globalPath = resolveSqlitePathForScope("global", defaultSqlitePath, cwd2, config, homeDir);
+    const localCount = await probeTaskCount(localPath);
+    const globalCount = await probeTaskCount(globalPath);
+    if (localCount > 0 && globalCount > 0) {
+      fail(
+        `storage-state.json is missing and BOTH candidate locations have data \u2014 local (${localPath}): ${localCount} task(s); global (${globalPath}): ${globalCount} task(s). Refusing to guess which one is authoritative. Resolve manually (inspect both databases) or delete the one that should be discarded, then re-run this command.`
+      );
+    }
+    if (localCount === 0 && globalCount === 0) {
+      const db = await openDB(config, cwd2, homeDir);
+      try {
+        await db.writeStorageState(cwd2);
+      } finally {
+        await db.close();
+      }
+      log5(pc9.dim("storage-state.json was missing; no data found at either candidate location. Nothing to migrate \u2014 state recorded."));
+      return;
+    }
+    realScope = localCount > 0 ? "local" : "global";
+    realDbType = "sqlite";
+    log5(
+      pc9.yellow(
+        `storage-state.json was missing. Detected real data at ${realScope} sqlite location (${realScope === "local" ? localPath : globalPath}) \u2014 using it as the migration source.`
+      )
+    );
+  } else {
+    realScope = state.scope;
+    realDbType = state.dbType;
+  }
+  const desiredScope = config.storage.scope;
+  const desiredDbType = config.database.type;
+  if (realScope === desiredScope && realDbType === desiredDbType) {
+    log5(pc9.green(`\u2713 Storage already matches config (scope=${desiredScope}, database=${desiredDbType}) \u2014 nothing to migrate.`));
+    return;
+  }
+  if (realDbType !== "sqlite") {
+    fail(
+      `Cannot auto-locate the previous ${realDbType} database \u2014 storage-state.json does not retain connection credentials for security. Manually run "ahk export --json" while still connected to the old database (with the old config), then adjust agent-harness-kit.config.ts and re-import. This direction is out of scope for "ahk migrate storage".`
+    );
+  }
+  if (desiredDbType === "sqlite" && realDbType === "sqlite") {
+    return migrateScopeOnly(cwd2, config, homeDir, realScope, desiredScope, opts);
+  }
+  return migrateAcrossDbType(cwd2, config, homeDir, realScope, opts);
+}
+async function probeTaskCount(dbPath) {
+  if (!existsSync12(dbPath)) return 0;
+  const { SQLiteDriver } = await import("./sqlite-TR4D324R.js");
+  const driver = new SQLiteDriver(dbPath);
+  try {
+    await driver.ensureSchema();
+    const counts = await getRowCounts(driver);
+    return counts.tasks;
+  } finally {
+    await driver.close();
+  }
+}
+async function migrateScopeOnly(cwd2, config, homeDir, fromScope, toScope, opts) {
+  const sqlitePath = config.database.type === "sqlite" ? config.database.path : ".harness/harness.db";
+  const srcDb = resolveSqlitePathForScope(fromScope, sqlitePath, cwd2, config, homeDir);
+  const destDb = resolveSqlitePathForScope(toScope, sqlitePath, cwd2, config, homeDir);
+  const srcMd = currentMdPathForScope(fromScope, config, cwd2, homeDir);
+  const destMd = currentMdPathForScope(toScope, config, cwd2, homeDir);
+  if (!existsSync12(srcDb)) {
+    fail(`Source database not found at ${srcDb} (expected ${fromScope} scope) \u2014 nothing to move.`);
+  }
+  const destExists = existsSync12(destDb);
+  if (destExists) {
+    const { SQLiteDriver } = await import("./sqlite-TR4D324R.js");
+    const destDriver = new SQLiteDriver(destDb);
+    let destEmpty;
+    try {
+      await destDriver.ensureSchema();
+      destEmpty = await isEmptyDatabase(destDriver);
+    } finally {
+      await destDriver.close();
+    }
+    if (!destEmpty && !opts.force) {
+      fail(
+        `Destination (${toScope}, ${destDb}) already has data. Re-run with --force to overwrite it (a backup of the destination will be written first).`
+      );
+    }
+    if (!destEmpty && opts.force) {
+      const { SQLiteDriver: Driver } = await import("./sqlite-TR4D324R.js");
+      const backupDriver = new Driver(destDb);
+      let data;
+      try {
+        await backupDriver.ensureSchema();
+        const { HarnessDB } = await import("./db-QQ7BR5K7.js");
+        const tmpDb = new HarnessDB(backupDriver, { ...config, storage: { ...config.storage, scope: toScope } }, homeDir);
+        data = await tmpDb.exportJson();
+      } finally {
+        await backupDriver.close();
+      }
+      const backupPath = await backupDestination(cwd2, config.storage.dir, data);
+      log5(pc9.yellow(`  Backed up existing destination data \u2192 ${backupPath}`));
+    }
+  }
+  if (opts.dryRun) {
+    log5(pc9.dim(`[dry-run] Would copy ${srcDb} \u2192 ${destDb} (scope ${fromScope} \u2192 ${toScope}), and move current.md.`));
+    return;
+  }
+  copySqliteFile(srcDb, destDb);
+  log5(pc9.green(`\u2713 Copied database ${srcDb} \u2192 ${destDb}`));
+  if (existsSync12(srcMd)) {
+    mkdirSync8(dirname7(destMd), { recursive: true });
+    copyFileSync(srcMd, destMd);
+    log5(pc9.green(`\u2713 Copied current.md ${srcMd} \u2192 ${destMd}`));
+  }
+  rmSync(srcDb, { force: true });
+  rmSync(`${srcDb}-wal`, { force: true });
+  rmSync(`${srcDb}-shm`, { force: true });
+  if (existsSync12(srcMd) && srcMd !== destMd) rmSync(srcMd, { force: true });
+  const db = await openDB(config, cwd2, homeDir);
+  try {
+    await db.writeStorageState(cwd2);
+  } finally {
+    await db.close();
+  }
+  log5(pc9.green(`\u2713 Storage migrated: scope ${fromScope} \u2192 ${toScope}`));
+}
+async function migrateAcrossDbType(cwd2, config, homeDir, sourceScope, opts) {
+  const sqlitePath = config.database.type === "sqlite" ? config.database.path : ".harness/harness.db";
+  const srcPath = resolveSqlitePathForScope(sourceScope, sqlitePath, cwd2, config, homeDir);
+  if (!existsSync12(srcPath)) {
+    fail(`Source sqlite database not found at ${srcPath} (expected ${sourceScope} scope) \u2014 nothing to migrate.`);
+  }
+  const { SQLiteDriver } = await import("./sqlite-TR4D324R.js");
+  const srcDriver = new SQLiteDriver(srcPath);
+  let sourceData;
+  let sourceCounts;
+  try {
+    await srcDriver.ensureSchema();
+    sourceCounts = await getRowCounts(srcDriver);
+    const { HarnessDB } = await import("./db-QQ7BR5K7.js");
+    const srcDb = new HarnessDB(srcDriver, { ...config, storage: { ...config.storage, scope: sourceScope }, database: { type: "sqlite", path: sqlitePath } }, homeDir);
+    sourceData = await srcDb.exportJson();
+  } finally {
+    await srcDriver.close();
+  }
+  let destDb;
+  try {
+    destDb = await openDB(config, cwd2, homeDir);
+  } catch (err) {
+    fail(`Could not connect to destination (${config.database.type}): ${err instanceof Error ? err.message : String(err)}. Verify database configuration.`);
+  }
+  try {
+    const destCounts = await destDb.getRowCounts();
+    const destEmpty = Object.values(destCounts).every((n) => n === 0);
+    const sourceEmpty = Object.values(sourceCounts).every((n) => n === 0);
+    if (!destEmpty) {
+      if (!opts.force) {
+        const bothHaveData = !sourceEmpty;
+        fail(
+          bothHaveData ? `Both source (${sourceCounts.tasks} task(s)) and destination (${config.database.type}, ${destCounts.tasks} task(s)) have data that DIVERGE \u2014 this is not a first-time migration. Refusing to auto-merge. Review both manually, or re-run with --force to overwrite the destination (a JSON backup will be written first).` : `Destination (${config.database.type}) already has data (${destCounts.tasks} task(s)). Re-run with --force to overwrite it (a backup of the destination will be written first).`
+        );
+      }
+    }
+    if (opts.dryRun) {
+      log5(
+        pc9.dim(
+          `[dry-run] Would migrate ${sourceCounts.tasks} task(s) from sqlite (${sourceScope}, ${srcPath}) to ${config.database.type}${destEmpty ? "" : " (destination has data \u2014 would back up first, then overwrite)"}.`
+        )
+      );
+      return;
+    }
+    let backupPath = null;
+    if (!destEmpty && opts.force) {
+      const currentDestData = await destDb.exportJson();
+      backupPath = await backupDestination(cwd2, config.storage.dir, currentDestData);
+      log5(pc9.yellow(`  Backed up existing destination data \u2192 ${backupPath}`));
+    }
+    await destDb.importFullExport(sourceData, config.database.type, { truncateFirst: !destEmpty });
+    await destDb.writeStorageState(cwd2);
+    log5(
+      pc9.green(
+        `\u2713 Migrated ${sourceData.tasks.length} task(s), ${sourceData.actions.length} action(s) from sqlite (${sourceScope}) \u2192 ${config.database.type}.`
+      )
+    );
+    if (backupPath) log5(pc9.dim(`  Destination backup: ${backupPath}`));
+    log5(pc9.yellow(`  Note: the original sqlite file at ${srcPath} was NOT deleted \u2014 remove it manually once you've verified the migration.`));
+  } finally {
+    await destDb.close();
+  }
+}
+
 // src/commands/reset.ts
-import { existsSync as existsSync10, readdirSync, rmSync } from "fs";
-import { join as join15, resolve as resolve9 } from "path";
+import { existsSync as existsSync13, readdirSync, rmSync as rmSync2 } from "fs";
+import { join as join16, resolve as resolve9 } from "path";
 import * as p5 from "@clack/prompts";
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 var AGENT_MD_FILES = ["lead", "explorer", "consultant", "builder", "reviewer"];
 async function resetAgentMds(cwd2, provider) {
   const agentDir = provider === "claude-code" ? ".claude/agents" : ".opencode/agents";
   const agentDirPath = resolve9(cwd2, agentDir);
-  if (!existsSync10(agentDirPath)) {
-    console.log(pc9.yellow(`  Skipping agent files \u2014 directory not found: ${agentDirPath}`));
+  if (!existsSync13(agentDirPath)) {
+    console.log(pc10.yellow(`  Skipping agent files \u2014 directory not found: ${agentDirPath}`));
     return;
   }
   const existingFiles = [];
@@ -2620,11 +2606,11 @@ async function resetAgentMds(cwd2, provider) {
       }
     }
   } catch {
-    console.log(pc9.yellow(`  Skipping agent files \u2014 ${agentDirPath} is not readable`));
+    console.log(pc10.yellow(`  Skipping agent files \u2014 ${agentDirPath} is not readable`));
     return;
   }
   if (existingFiles.length === 0) {
-    console.log(pc9.yellow(`  No agent MD files found in ${agentDir}/`));
+    console.log(pc10.yellow(`  No agent MD files found in ${agentDir}/`));
     return;
   }
   for (const file of existingFiles) {
@@ -2633,19 +2619,19 @@ async function resetAgentMds(cwd2, provider) {
       initialValue: true
     });
     if (p5.isCancel(confirm3)) {
-      console.log(pc9.red("  Cancelled by user."));
+      console.log(pc10.red("  Cancelled by user."));
       return;
     }
     if (confirm3) {
       try {
-        const filePath = join15(agentDirPath, file);
-        rmSync(filePath, { force: true });
-        console.log(pc9.green(`  Removed ${file}`));
+        const filePath = join16(agentDirPath, file);
+        rmSync2(filePath, { force: true });
+        console.log(pc10.green(`  Removed ${file}`));
       } catch {
-        console.error(pc9.red(`  Failed to remove ${file}`));
+        console.error(pc10.red(`  Failed to remove ${file}`));
       }
     } else {
-      console.log(pc9.cyan(`  Skipped ${file}`));
+      console.log(pc10.cyan(`  Skipped ${file}`));
     }
   }
 }
@@ -2654,7 +2640,7 @@ async function runReset(cwd2, opts) {
   try {
     config = await loadConfig(cwd2);
   } catch {
-    console.error(pc9.red("\u2717 No agent-harness-kit.config found. Run: ahk init"));
+    console.error(pc10.red("\u2717 No agent-harness-kit.config found. Run: ahk init"));
     process.exit(1);
   }
   const storageDir = config.storage.dir || ".harness";
@@ -2663,12 +2649,12 @@ async function runReset(cwd2, opts) {
   let resetDb = false;
   let resetFeatureList = false;
   let resetAgentMdsFlag = false;
-  if (dbPath && existsSync10(dbPath)) {
+  if (dbPath && existsSync13(dbPath)) {
     if (opts.force) {
       resetDb = true;
     } else {
       if (config.database.type !== "sqlite") {
-        console.log(pc9.yellow(`  Skipping DB reset \u2014 database type "${config.database.type}" is not managed by this command.`));
+        console.log(pc10.yellow(`  Skipping DB reset \u2014 database type "${config.database.type}" is not managed by this command.`));
         resetDb = false;
       } else {
         const confirm3 = await p5.confirm({
@@ -2676,16 +2662,16 @@ async function runReset(cwd2, opts) {
           initialValue: true
         });
         if (p5.isCancel(confirm3)) {
-          console.log(pc9.red("  Cancelled by user."));
+          console.log(pc10.red("  Cancelled by user."));
           return;
         }
         resetDb = confirm3;
       }
     }
   } else if (!dbPath) {
-    console.log(pc9.dim(`  Skipping DB reset \u2014 remote ${config.database.type} database is not managed by this command.`));
+    console.log(pc10.dim(`  Skipping DB reset \u2014 remote ${config.database.type} database is not managed by this command.`));
   }
-  if (existsSync10(featureListPath)) {
+  if (existsSync13(featureListPath)) {
     if (opts.force) {
       resetFeatureList = true;
     } else {
@@ -2694,7 +2680,7 @@ async function runReset(cwd2, opts) {
         initialValue: true
       });
       if (p5.isCancel(confirm3)) {
-        console.log(pc9.red("  Cancelled by user."));
+        console.log(pc10.red("  Cancelled by user."));
         return;
       }
       resetFeatureList = confirm3;
@@ -2705,20 +2691,20 @@ async function runReset(cwd2, opts) {
   }
   if (resetDb && dbPath) {
     try {
-      rmSync(dbPath, { force: true });
-      rmSync(`${dbPath}-wal`, { force: true });
-      rmSync(`${dbPath}-shm`, { force: true });
-      console.log(pc9.green(`  \u2713 Removed ${dbPath}`));
+      rmSync2(dbPath, { force: true });
+      rmSync2(`${dbPath}-wal`, { force: true });
+      rmSync2(`${dbPath}-shm`, { force: true });
+      console.log(pc10.green(`  \u2713 Removed ${dbPath}`));
     } catch {
-      console.error(pc9.red(`  \u2717 Failed to remove ${dbPath}`));
+      console.error(pc10.red(`  \u2717 Failed to remove ${dbPath}`));
     }
   }
   if (resetFeatureList) {
     try {
-      rmSync(featureListPath, { force: true });
-      console.log(pc9.green(`  \u2713 Removed ${storageDir}/feature_list.json`));
+      rmSync2(featureListPath, { force: true });
+      console.log(pc10.green(`  \u2713 Removed ${storageDir}/feature_list.json`));
     } catch {
-      console.error(pc9.red(`  \u2717 Failed to remove ${featureListPath}`));
+      console.error(pc10.red(`  \u2717 Failed to remove ${featureListPath}`));
     }
   }
   if (resetAgentMdsFlag) {
@@ -2726,16 +2712,16 @@ async function runReset(cwd2, opts) {
     await resetAgentMds(cwd2, opts.provider || "claude-code");
   }
   if (!resetDb && !resetFeatureList && !resetAgentMdsFlag) {
-    console.log(pc9.yellow("  Nothing to reset (all items missing or skipped)."));
+    console.log(pc10.yellow("  Nothing to reset (all items missing or skipped)."));
     return;
   }
   console.log("");
-  console.log(pc9.green('\u2713 Reset complete. Run "ahk init" to scaffold a fresh harness.'));
+  console.log(pc10.green('\u2713 Reset complete. Run "ahk init" to scaffold a fresh harness.'));
 }
 
 // src/core/mcp-server.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync, writeFileSync as writeFileSync10 } from "fs";
-import { join as join17, resolve as resolve10 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync, writeFileSync as writeFileSync10 } from "fs";
+import { join as join18, resolve as resolve10 } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -2744,8 +2730,8 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/core/permissions-check.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
+import { join as join17 } from "path";
 var CANONICAL = {
   lead: [...MCP_CLAUDE_PERMISSIONS_LEAD],
   explorer: [...MCP_CLAUDE_PERMISSIONS_EXPLORER],
@@ -2768,14 +2754,14 @@ function checkPermissionsSync(cwd2, config) {
   const agents = {};
   let in_sync = true;
   for (const agent of ["lead", "explorer", "consultant", "builder", "reviewer"]) {
-    const filePath = join16(cwd2, ".claude", "agents", `${agent}.md`);
-    if (!existsSync11(filePath)) {
+    const filePath = join17(cwd2, ".claude", "agents", `${agent}.md`);
+    if (!existsSync14(filePath)) {
       const missing2 = CANONICAL[agent];
       agents[agent] = { ok: false, missing: missing2, extra: [] };
       in_sync = false;
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const installed = parseToolsFromFrontmatter(content);
     const canonical = CANONICAL[agent];
     const missing = canonical.filter((t) => !installed.includes(t));
@@ -3195,19 +3181,19 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
       return ok2(JSON.stringify(result, null, 2));
     }
     case "deps.snapshot": {
-      const pkgPath2 = join17(cwd2, "package.json");
-      if (!existsSync12(pkgPath2)) {
+      const pkgPath2 = join18(cwd2, "package.json");
+      if (!existsSync15(pkgPath2)) {
         return ok2("package.json not found in project root", true);
       }
-      const pkg2 = JSON.parse(readFileSync9(pkgPath2, "utf8"));
+      const pkg2 = JSON.parse(readFileSync10(pkgPath2, "utf8"));
       const snapshot = {
         capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
         dependencies: pkg2.dependencies ?? {},
         devDependencies: pkg2.devDependencies ?? {}
       };
-      const harnessDir = join17(cwd2, ".harness");
+      const harnessDir = join18(cwd2, ".harness");
       mkdirSync9(harnessDir, { recursive: true });
-      writeFileSync10(join17(harnessDir, "deps-lock.json"), JSON.stringify(snapshot, null, 2), "utf8");
+      writeFileSync10(join18(harnessDir, "deps-lock.json"), JSON.stringify(snapshot, null, 2), "utf8");
       return ok2(
         JSON.stringify({
           message: "Snapshot saved to .harness/deps-lock.json",
@@ -3216,12 +3202,12 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
       );
     }
     case "deps.check": {
-      const pkgPath2 = join17(cwd2, "package.json");
-      const lockPath = join17(cwd2, ".harness", "deps-lock.json");
-      if (!existsSync12(pkgPath2)) {
+      const pkgPath2 = join18(cwd2, "package.json");
+      const lockPath = join18(cwd2, ".harness", "deps-lock.json");
+      if (!existsSync15(pkgPath2)) {
         return ok2("package.json not found in project root", true);
       }
-      if (!existsSync12(lockPath)) {
+      if (!existsSync15(lockPath)) {
         return ok2(
           JSON.stringify({
             status: "no-snapshot",
@@ -3229,8 +3215,8 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
           })
         );
       }
-      const pkg2 = JSON.parse(readFileSync9(pkgPath2, "utf8"));
-      const lock = JSON.parse(readFileSync9(lockPath, "utf8"));
+      const pkg2 = JSON.parse(readFileSync10(pkgPath2, "utf8"));
+      const lock = JSON.parse(readFileSync10(lockPath, "utf8"));
       const current = { ...pkg2.dependencies ?? {}, ...pkg2.devDependencies ?? {} };
       const previous = { ...lock.dependencies ?? {}, ...lock.devDependencies ?? {} };
       const added = [];
@@ -3297,7 +3283,7 @@ function searchDocs(docsPath, query, maxResults = 10) {
     for (const file of files) {
       if (results.length >= maxResults) break;
       try {
-        const content = readFileSync9(file, "utf8");
+        const content = readFileSync10(file, "utf8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           const lower = lines[i].toLowerCase();
@@ -3322,7 +3308,7 @@ function collectMarkdownFiles(dir) {
   const files = [];
   try {
     for (const entry of readdirSync2(dir)) {
-      const full = join17(dir, entry);
+      const full = join18(dir, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         files.push(...collectMarkdownFiles(full));
@@ -3373,12 +3359,12 @@ async function runServe(cwd2, opts) {
 
 // src/commands/status.ts
 import Table from "cli-table3";
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 var STATUS_COLOR = {
-  pending: (s) => pc10.dim(s),
-  in_progress: (s) => pc10.cyan(s),
-  done: (s) => pc10.green(s),
-  blocked: (s) => pc10.red(s)
+  pending: (s) => pc11.dim(s),
+  in_progress: (s) => pc11.cyan(s),
+  done: (s) => pc11.green(s),
+  blocked: (s) => pc11.red(s)
 };
 async function runStatus(cwd2, opts) {
   const config = await loadConfig(cwd2);
@@ -3399,11 +3385,11 @@ async function runStatus(cwd2, opts) {
       return;
     }
     if (tasks.length === 0) {
-      console.log(pc10.dim("No tasks yet. Run: ahk task add"));
+      console.log(pc11.dim("No tasks yet. Run: ahk task add"));
       return;
     }
     const table = new Table({
-      head: ["ID", "Slug", "Title", "Status", "Assigned", "Started"].map((h) => pc10.bold(h)),
+      head: ["ID", "Slug", "Title", "Status", "Assigned", "Started"].map((h) => pc11.bold(h)),
       style: { head: [], border: [] }
     });
     for (const t of tasks) {
@@ -3421,12 +3407,12 @@ async function runStatus(cwd2, opts) {
     const inProgress = tasks.filter((t) => t.status === "in_progress");
     if (inProgress.length > 0) {
       console.log("");
-      console.log(pc10.bold("Active actions:"));
+      console.log(pc11.bold("Active actions:"));
       for (const t of inProgress) {
         const actions = await db.getActionsForTask(t.id);
         const active = actions.filter((a) => a.status === "in_progress");
         for (const a of active) {
-          console.log(`  ${pc10.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
+          console.log(`  ${pc11.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
         }
       }
     }
@@ -3435,10 +3421,10 @@ async function runStatus(cwd2, opts) {
       const fn = STATUS_COLOR[s.status] ?? ((x) => x);
       return `${fn(s.status)}: ${s.total}`;
     });
-    console.log(pc10.dim("Tasks \u2014 ") + parts.join(pc10.dim(" | ")));
+    console.log(pc11.dim("Tasks \u2014 ") + parts.join(pc11.dim(" | ")));
     const archivedTasks = await db.getArchivedTasks();
     if (archivedTasks.length > 0) {
-      console.log(pc10.dim(`${archivedTasks.length} archived (use \`ahk task list --archived\` to view)`));
+      console.log(pc11.dim(`${archivedTasks.length} archived (use \`ahk task list --archived\` to view)`));
     }
   } finally {
     await db.close();
@@ -3446,13 +3432,13 @@ async function runStatus(cwd2, opts) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join18, resolve as resolve11 } from "path";
-import pc11 from "picocolors";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { join as join19, resolve as resolve11 } from "path";
+import pc12 from "picocolors";
 async function runSync(cwd2, opts) {
   const config = await loadConfig(cwd2);
   const direction = opts.direction ?? "both";
-  const featureListPath = resolve11(join18(cwd2, config.storage.dir, "feature_list.json"));
+  const featureListPath = resolve11(join19(cwd2, config.storage.dir, "feature_list.json"));
   const db = await openDB(config, cwd2);
   try {
     if (direction === "in" || direction === "both") {
@@ -3466,44 +3452,44 @@ async function runSync(cwd2, opts) {
   }
 }
 async function syncIn(featureListPath, db, dryRun) {
-  if (!existsSync13(featureListPath)) {
-    console.log(pc11.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
+  if (!existsSync16(featureListPath)) {
+    console.log(pc12.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
     return;
   }
   let seeds;
   try {
-    seeds = JSON.parse(readFileSync10(featureListPath, "utf8"));
+    seeds = JSON.parse(readFileSync11(featureListPath, "utf8"));
   } catch (err) {
-    console.error(pc11.red(`Failed to parse feature_list.json: ${err}`));
+    console.error(pc12.red(`Failed to parse feature_list.json: ${err}`));
     process.exit(1);
   }
   if (dryRun) {
-    console.log(pc11.bold("Dry run \u2014 in-sync (feature_list.json \u2192 SQLite):"));
+    console.log(pc12.bold("Dry run \u2014 in-sync (feature_list.json \u2192 SQLite):"));
     for (const t of seeds) {
       const existing = await db.getTaskBySlug(t.slug);
-      console.log(`  ${existing ? pc11.dim("skip") : pc11.green("add ")} ${t.slug}`);
+      console.log(`  ${existing ? pc12.dim("skip") : pc12.green("add ")} ${t.slug}`);
     }
     return;
   }
   const result = await db.syncFromFeatureList(seeds);
-  console.log(pc11.green(`\u2713 In-sync: ${result.added} added, ${result.skipped} already existed`));
+  console.log(pc12.green(`\u2713 In-sync: ${result.added} added, ${result.skipped} already existed`));
 }
 async function syncOut(db, cwd2, dryRun) {
   if (dryRun) {
     const tasks = await db.getTasks();
-    console.log(pc11.bold("Dry run \u2014 out-sync (SQLite \u2192 feature_list.json):"));
+    console.log(pc12.bold("Dry run \u2014 out-sync (SQLite \u2192 feature_list.json):"));
     console.log(`  ${tasks.length} tasks would be written`);
     return;
   }
   await db.writeFeatureList(cwd2);
-  console.log(pc11.green("\u2713 Out-sync: feature_list.json updated"));
+  console.log(pc12.green("\u2713 Out-sync: feature_list.json updated"));
 }
 
 // src/commands/task/add.ts
 import * as p6 from "@clack/prompts";
-import pc12 from "picocolors";
+import pc13 from "picocolors";
 async function runTaskAdd(cwd2) {
-  p6.intro(pc12.bold("agent-harness-kit \u2014 add task"));
+  p6.intro(pc13.bold("agent-harness-kit \u2014 add task"));
   const title = await cliFormWithRetry(
     async () => {
       const val = await p6.text({ message: "Task title" });
@@ -3546,10 +3532,10 @@ async function runTaskAdd(cwd2) {
     await db.writeFeatureList(cwd2);
     await db.close();
     spinner6.stop("");
-    console.log(pc12.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
-    console.log(pc12.cyan("\u2192") + " " + pc12.cyan("ahk status") + " to see all tasks");
+    console.log(pc13.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
+    console.log(pc13.cyan("\u2192") + " " + pc13.cyan("ahk status") + " to see all tasks");
   } catch (err) {
-    spinner6.stop(pc12.red("Failed"));
+    spinner6.stop(pc13.red("Failed"));
     p6.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
@@ -3557,17 +3543,17 @@ async function runTaskAdd(cwd2) {
 
 // src/commands/task/done.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { resolve as resolve12 } from "path";
-import pc13 from "picocolors";
+import pc14 from "picocolors";
 async function runTaskDone(cwd2, idOrSlug) {
   const config = await loadConfig(cwd2);
   if (config.health.required) {
     const scriptPath = resolve12(cwd2, config.health.scriptPath);
-    if (existsSync14(scriptPath)) {
+    if (existsSync17(scriptPath)) {
       const result = spawnSync2("bash", [scriptPath], { cwd: cwd2, stdio: "pipe", encoding: "utf8" });
       if (result.status !== 0) {
-        console.error(pc13.red("\u2717 Health check failed \u2014 cannot mark task as done."));
+        console.error(pc14.red("\u2717 Health check failed \u2014 cannot mark task as done."));
         if (result.stdout) console.error(result.stdout);
         if (result.stderr) console.error(result.stderr);
         process.exit(1);
@@ -3580,16 +3566,16 @@ async function runTaskDone(cwd2, idOrSlug) {
     const isId = !isNaN(parsed);
     const task2 = isId ? await db.getTaskById(parsed) : await db.getTaskBySlug(idOrSlug);
     if (!task2) {
-      console.error(pc13.red(`Task not found: ${idOrSlug}`));
+      console.error(pc14.red(`Task not found: ${idOrSlug}`));
       process.exit(1);
     }
     if (task2.status === "done") {
-      console.log(pc13.dim(`Task #${task2.id} is already done.`));
+      console.log(pc14.dim(`Task #${task2.id} is already done.`));
       return;
     }
     await db.updateTaskStatus(task2.id, "done");
     await db.writeFeatureList(cwd2);
-    console.log(pc13.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
+    console.log(pc14.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
   } finally {
     await db.close();
   }
@@ -3597,9 +3583,9 @@ async function runTaskDone(cwd2, idOrSlug) {
 
 // src/commands/task/edit.ts
 import * as p7 from "@clack/prompts";
-import pc14 from "picocolors";
+import pc15 from "picocolors";
 async function runTaskEdit(cwd2) {
-  p7.intro(pc14.bold("agent-harness-kit \u2014 edit task"));
+  p7.intro(pc15.bold("agent-harness-kit \u2014 edit task"));
   const config = await loadConfig(cwd2);
   const db = await openDB(config, cwd2);
   try {
@@ -3677,9 +3663,9 @@ async function runTaskEdit(cwd2) {
       await db.updateTaskAcceptance(task2.id, newAcceptance);
       await db.writeFeatureList(cwd2);
       spinner6.stop("");
-      console.log(pc14.green(`\u2713 Task #${task2.id} updated \u2014 ${newSlug}`));
+      console.log(pc15.green(`\u2713 Task #${task2.id} updated \u2014 ${newSlug}`));
     } catch (err) {
-      spinner6.stop(pc14.red("Failed"));
+      spinner6.stop(pc15.red("Failed"));
       p7.log.error(err instanceof Error ? err.message : String(err));
       process.exit(1);
     }
@@ -3690,12 +3676,12 @@ async function runTaskEdit(cwd2) {
 
 // src/commands/task/list.ts
 import Table2 from "cli-table3";
-import pc15 from "picocolors";
+import pc16 from "picocolors";
 var STATUS_COLOR2 = {
-  pending: (s) => pc15.dim(s),
-  in_progress: (s) => pc15.cyan(s),
-  done: (s) => pc15.green(s),
-  blocked: (s) => pc15.red(s)
+  pending: (s) => pc16.dim(s),
+  in_progress: (s) => pc16.cyan(s),
+  done: (s) => pc16.green(s),
+  blocked: (s) => pc16.red(s)
 };
 async function runTaskList(cwd2, opts) {
   const config = await loadConfig(cwd2);
@@ -3712,11 +3698,11 @@ async function runTaskList(cwd2, opts) {
       let msg = "No tasks";
       if (filterStatus) msg += ` with status: ${filterStatus}`;
       if (opts.archived) msg += " (archived)";
-      console.log(pc15.dim(msg + "."));
+      console.log(pc16.dim(msg + "."));
       return;
     }
     const table = new Table2({
-      head: ["ID", "Slug", "Title", "Status"].map((h) => pc15.bold(h)),
+      head: ["ID", "Slug", "Title", "Status"].map((h) => pc16.bold(h)),
       style: { head: [], border: [] }
     });
     for (const t of tasks) {
@@ -3727,7 +3713,7 @@ async function runTaskList(cwd2, opts) {
     if (!opts.archived && !opts.includeArchived) {
       const archivedTasks = await db.getArchivedTasks();
       if (archivedTasks.length > 0) {
-        console.log(pc15.dim(`${archivedTasks.length} archived task${archivedTasks.length !== 1 ? "s" : ""} (use --archived to view)`));
+        console.log(pc16.dim(`${archivedTasks.length} archived task${archivedTasks.length !== 1 ? "s" : ""} (use --archived to view)`));
       }
     }
   } finally {
@@ -3735,8 +3721,42 @@ async function runTaskList(cwd2, opts) {
   }
 }
 
+// src/core/local-install-guard.ts
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { join as join20 } from "path";
+import pc17 from "picocolors";
+function isLocalInstallSatisfied(cwd2) {
+  const selfPkgPath = join20(cwd2, "package.json");
+  let projectPkg = null;
+  if (existsSync18(selfPkgPath)) {
+    try {
+      const selfPkg = JSON.parse(readFileSync12(selfPkgPath, "utf8"));
+      if (selfPkg?.name === pkg.name) return true;
+      projectPkg = selfPkg;
+    } catch {
+    }
+  }
+  const [scope, name] = pkg.name.split("/");
+  const localPath = pkg.name.startsWith("@") ? join20(cwd2, "node_modules", scope, name) : join20(cwd2, "node_modules", pkg.name);
+  if (existsSync18(localPath)) return true;
+  const isPnp = existsSync18(join20(cwd2, ".pnp.cjs")) || existsSync18(join20(cwd2, ".pnp.loader.mjs"));
+  if (isPnp && projectPkg) {
+    const deps = {
+      ...projectPkg.dependencies ?? {},
+      ...projectPkg.devDependencies ?? {}
+    };
+    if (Object.prototype.hasOwnProperty.call(deps, pkg.name)) return true;
+  }
+  return false;
+}
+function printLocalInstallWarning() {
+  console.error(pc17.red(`\u2717 ${pkg.name} must be installed locally in this project.`));
+  console.error(pc17.dim(`  Run: npm install --save-dev ${pkg.name}`));
+  console.error(pc17.dim("  (or the equivalent for your package manager: pnpm add -D, yarn add --dev, bun add -d)"));
+}
+
 // src/core/update-check.ts
-import pc16 from "picocolors";
+import pc18 from "picocolors";
 var REGISTRY_URL2 = `https://registry.npmjs.org/${pkg.name}/latest`;
 var TIMEOUT_MS2 = 2500;
 function checkForUpdate(currentVersion) {
@@ -3754,8 +3774,8 @@ function checkForUpdate(currentVersion) {
 }
 function printUpdateMessage({ current, latest }) {
   const lines = [
-    `  Update available ${pc16.dim(current)} \u2192 ${pc16.green(latest)}  `,
-    `  Run: ${pc16.cyan(`pnpm i ${pkg.name}@${latest}`)}          `
+    `  Update available ${pc18.dim(current)} \u2192 ${pc18.green(latest)}  `,
+    `  Run: ${pc18.cyan(`pnpm i ${pkg.name}@${latest}`)}          `
   ];
   drawBox(lines);
 }
@@ -3773,7 +3793,7 @@ var cwd = process.cwd();
 var updateCheck = checkForUpdate(pkg.version);
 var program = new Command();
 program.name("ahk").description("agent-harness-kit \u2014 CLI scaffolding for multi-agent harness systems").version(pkg.version, "-v, --version");
-program.command("init").description("Scaffold a harness interactively in the current directory").option("--name <name>", "Project name (skip prompt)").option("--provider <provider>", "AI provider: claude-code | opencode (skip prompt)").option("--docs <path>", "Docs folder path (skip prompt)").option("--tasks <adapter>", "Task adapter: local | jira | linear (skip prompt)").action(async (opts) => {
+program.command("init").description("Scaffold a harness interactively in the current directory").option("--name <name>", "Project name (skip prompt)").option("--provider <provider>", "AI provider: claude-code | opencode (skip prompt)").option("--docs <path>", "Docs folder path (skip prompt)").option("--tasks <adapter>", "Task adapter: local | jira | linear (skip prompt)").option("--storage-scope <scope>", "Storage scope: local | global (skip prompt)").action(async (opts) => {
   await runInit(cwd, opts);
 });
 program.command("build").description("Regenerate AGENTS.md and provider files from agent-harness-kit.config.ts").option("--watch", "Rebuild on config changes").option("--sync", "Sync tools: frontmatter in existing .claude/agents/*.md to match current permission constants").action(async (opts) => {
@@ -3807,9 +3827,20 @@ task.command("edit").description("Edit a task interactively").action(async () =>
 program.command("dashboard").description("Open web dashboard to visualize harness data").option("-p, --port <port>", "Port to listen on", "4242").option("--no-open", "Do not open browser automatically").action(async (opts) => {
   await runDashboard(cwd, { port: parseInt(opts.port), open: opts.open });
 });
-program.command("migrate").description("Migrate provider-specific files to a different provider").option("--to <provider>", "Target provider: claude-code | opencode").action(async (opts) => {
+var migrate = program.command("migrate").description("Migrate provider files to a different provider, or migrate harness storage (see subcommands)");
+migrate.command("provider").description("Migrate provider-specific files to a different provider").option("--to <provider>", "Target provider: claude-code | opencode | codex-cli").action(async (opts) => {
   await runMigrate(cwd, opts);
 });
+migrate.command("storage").description(
+  "Migrate harness DB storage between local/global scope or sqlite/postgres/mysql, based on agent-harness-kit.config.ts vs the real current state"
+).option("--force", "Required to overwrite a non-empty destination (a backup is written first)").option("--dry-run", "Preview what would migrate without applying any changes").action(async (opts) => {
+  try {
+    await runMigrateStorage(cwd, { force: opts.force, dryRun: opts["dry-run"] });
+  } catch (err) {
+    console.error(pc19.red(`\u2717 ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
 program.command("export").description("Export the database").option("--sql", "SQL dump").option("--json", "JSON export of tasks and actions").option("--output <path>", "Output file path (default: stdout)").action(async (opts) => {
   await runExport(cwd, opts);
 });
@@ -3819,9 +3850,25 @@ program.command("reset").description("Reset/clear harness data (DB, feature list
 program.command("doctor").description("Check lib version, agent files, and harness skills sync status").action(async () => {
   await runDoctor(cwd);
 });
+program.hook("preAction", () => {
+  if (!isLocalInstallSatisfied(cwd)) {
+    printLocalInstallWarning();
+    process.exit(1);
+  }
+});
 program.hook("postAction", async () => {
   const update = await updateCheck;
   if (update) printUpdateMessage(update);
 });
-program.parse();
+function rewriteLegacyMigrateArgv(argv) {
+  const migrateIdx = argv.indexOf("migrate");
+  if (migrateIdx === -1) return argv;
+  const next = argv[migrateIdx + 1];
+  const isLegacyForm = next === void 0 || next === "--to";
+  if (!isLegacyForm) return argv;
+  const rewritten = [...argv];
+  rewritten.splice(migrateIdx + 1, 0, "provider");
+  return rewritten;
+}
+program.parse(rewriteLegacyMigrateArgv(process.argv));
 //# sourceMappingURL=cli.js.map