@cardor/agent-harness-kit 2.0.0 → 2.1.1

package/dist/cli.js

@@ -16,11 +16,11 @@ import {
 
 // src/cli.ts
 import { Command, InvalidArgumentError } from "commander";
-import pc20 from "picocolors";
+import pc21 from "picocolors";
 
 // src/commands/build.ts
 import { watch } from "fs";
-import * as p from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 import pc2 from "picocolors";
 
 // src/core/materializer/claude-code.ts
@@ -53,31 +53,39 @@ import { fileURLToPath } from "url";
 var require2 = createRequire(import.meta.url);
 var here = dirname(fileURLToPath(import.meta.url));
 var candidates = [join2(here, "..", "..", "package.json"), join2(here, "..", "package.json")];
-var pkgPath = candidates.find((p8) => existsSync(p8)) ?? candidates[0];
+var pkgPath = candidates.find((p9) => existsSync(p9)) ?? candidates[0];
 var pkg = require2(pkgPath);
 
 // src/core/local-install-guard.ts
 function isLocalInstallSatisfied(cwd2) {
   const selfPkgPath = join3(cwd2, "package.json");
-  let projectPkg = null;
   if (existsSync2(selfPkgPath)) {
     try {
       const selfPkg = JSON.parse(readFileSync(selfPkgPath, "utf8"));
       if (selfPkg?.name === pkg.name) return true;
-      projectPkg = selfPkg;
     } catch {
     }
   }
+  return hasRealLocalInstall(cwd2);
+}
+function hasRealLocalInstall(cwd2) {
   const [scope, name] = pkg.name.split("/");
   const localPath = pkg.name.startsWith("@") ? join3(cwd2, "node_modules", scope, name) : join3(cwd2, "node_modules", pkg.name);
   if (existsSync2(localPath)) return true;
   const isPnp = existsSync2(join3(cwd2, ".pnp.cjs")) || existsSync2(join3(cwd2, ".pnp.loader.mjs"));
-  if (isPnp && projectPkg) {
-    const deps = {
-      ...projectPkg.dependencies ?? {},
-      ...projectPkg.devDependencies ?? {}
-    };
-    if (Object.prototype.hasOwnProperty.call(deps, pkg.name)) return true;
+  if (isPnp) {
+    const pkgPath2 = join3(cwd2, "package.json");
+    if (existsSync2(pkgPath2)) {
+      try {
+        const projectPkg = JSON.parse(readFileSync(pkgPath2, "utf8"));
+        const deps = {
+          ...projectPkg?.dependencies ?? {},
+          ...projectPkg?.devDependencies ?? {}
+        };
+        if (Object.prototype.hasOwnProperty.call(deps, pkg.name)) return true;
+      } catch {
+      }
+    }
   }
   return false;
 }
@@ -132,7 +140,7 @@ function detectFromPackageManagerField(cwd2) {
 }
 function getMcpCommandParts(pm, port, cwd2) {
   const portStr = String(port);
-  if (!isLocalInstallSatisfied(cwd2)) {
+  if (!hasRealLocalInstall(cwd2)) {
     return ["ahk", "serve", "--port", portStr];
   }
   switch (pm) {
@@ -380,6 +388,17 @@ function mergeCodexConfigToml(filePath, port, cwd2, pm = "npm") {
   content = mergeTomlSection(content, "mcp_servers.agent-harness-kit", sectionBody);
   writeFileSync2(filePath, content, "utf8");
 }
+function mergeGrokConfigToml(filePath, port, cwd2, pm = "npm") {
+  mkdirSync2(dirname2(filePath), { recursive: true });
+  let content = "";
+  if (existsSync4(filePath)) {
+    content = readFileSync3(filePath, "utf8");
+  }
+  const [command, ...args] = getMcpCommandParts(pm, port, cwd2);
+  const sectionBody = [`command = ${JSON.stringify(command)}`, `args = ${JSON.stringify(args)}`].join("\n");
+  content = mergeTomlSection(content, "mcp_servers.agent-harness-kit", sectionBody);
+  writeFileSync2(filePath, content, "utf8");
+}
 
 // src/core/materializer/scaffold-utils.ts
 import { createHash } from "crypto";
@@ -420,6 +439,9 @@ These tools may still appear available to you. The sandbox will reject the call.
 function codexRestrictionNotice(agentName) {
   return restrictionFor(agentName) === "no-write" ? CODEX_READ_ONLY_NOTICE : "";
 }
+function grokToolsAllowlist(agentName) {
+  return restrictionFor(agentName) === "no-write" ? ["Bash", "Read", "NotebookRead", "Grep", "Glob", "WebFetch", "WebSearch", "search_tool", "use_tool"] : [];
+}
 
 // src/core/materializer/templates.ts
 var __dirname = dirname3(fileURLToPath2(import.meta.url));
@@ -849,6 +871,11 @@ function translateFrontmatterForOpenCode(md, agentName) {
   result = stripFrontmatterBlockSequence(result, "disallowedTools");
   return appendFrontmatterMapping(result, "permission", opencodePermissions(agentName));
 }
+function translateFrontmatterForGrok(md, agentName) {
+  let result = stripFrontmatterBlockSequence(md, "tools");
+  result = stripFrontmatterBlockSequence(result, "disallowedTools");
+  return appendFrontmatterBlockSequence(result, "tools", grokToolsAllowlist(agentName));
+}
 var GITIGNORE_ENTRIES = `
 # agent-harness-kit
 .harness/harness.db
@@ -1064,7 +1091,7 @@ No tasks in progress.
       ],
       { force: opts.force, backupRoot: join7(cwd2, config.storage.dir, "backups") }
     );
-    const agents = writeAgentFiles(cwd2, claudeAgentFiles(config), {
+    const agents = writeAgentFiles(cwd2, claudeAgentFiles(config, opts.claudeAgentModels), {
       force: opts.force,
       backupRoot: join7(cwd2, config.storage.dir, "backups")
     });
@@ -1163,9 +1190,73 @@ No tasks in progress.
   }
 };
 
-// src/core/materializer/opencode.ts
+// src/core/materializer/grok.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { join as join9, resolve as resolve4 } from "path";
+function grokAgentFiles(config) {
+  const projectName = config.project.name;
+  return [
+    { relPath: ".grok/agents/lead.md", content: translateFrontmatterForGrok(agentLead({ projectName }), "lead") },
+    { relPath: ".grok/agents/explorer.md", content: translateFrontmatterForGrok(agentExplorer({ projectName }), "explorer") },
+    { relPath: ".grok/agents/consultant.md", content: translateFrontmatterForGrok(agentConsultant({ projectName }), "consultant") },
+    { relPath: ".grok/agents/builder.md", content: translateFrontmatterForGrok(agentBuilder({ projectName }), "builder") },
+    { relPath: ".grok/agents/reviewer.md", content: translateFrontmatterForGrok(agentReviewer({ projectName }), "reviewer") }
+  ];
+}
+var GrokMaterializer = class {
+  async scaffold(config, opts) {
+    const { cwd: cwd2 } = opts;
+    const write2 = (relPath, content, mode) => {
+      const abs = join9(cwd2, relPath);
+      mkdirSync5(resolve4(abs, ".."), { recursive: true });
+      writeFileSync5(abs, content, { encoding: "utf8", mode });
+    };
+    write2("AGENTS.md", stampGenerated(agentsMd(config)));
+    if (!existsSync8(join9(cwd2, "health.sh"))) {
+      write2("health.sh", HEALTH_SH, 493);
+    }
+    if (config.storage.scope === "local" && !existsSync8(join9(cwd2, config.storage.markdownFallback.path))) {
+      write2(
+        config.storage.markdownFallback.path,
+        `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
+<!-- Run ahk status to refresh -->
+
+# Current Session
+
+No tasks in progress.
+`
+      );
+    }
+    writeAgentFiles(cwd2, grokAgentFiles(config));
+    mergeGrokConfigToml(join9(cwd2, ".grok/config.toml"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
+    appendGitignore(cwd2);
+    writeSkills(cwd2, ".grok/skills");
+  }
+  async build(config, cwd2, opts = {}) {
+    const derived = reconcileGeneratedFiles(
+      cwd2,
+      [{ relPath: "AGENTS.md", content: agentsMd(config) }],
+      { force: opts.force, backupRoot: join9(cwd2, config.storage.dir, "backups") }
+    );
+    const agents = writeAgentFiles(cwd2, grokAgentFiles(config), {
+      force: opts.force,
+      backupRoot: join9(cwd2, config.storage.dir, "backups")
+    });
+    mergeGrokConfigToml(join9(cwd2, ".grok/config.toml"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
+    writeSkills(cwd2, ".grok/skills");
+    return { agents, derived };
+  }
+  async migrate(config, _to, _cwd) {
+    void config;
+  }
+  async syncPermissions(_cwd) {
+    console.log("  Permissions sync not needed for grok-cli \u2014 skipping");
+  }
+};
+
+// src/core/materializer/opencode.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
 function opencodeAgentFiles(config) {
   const projectName = config.project.name;
   return [
@@ -1180,15 +1271,15 @@ var OpenCodeMaterializer = class {
   async scaffold(config, opts) {
     const { cwd: cwd2 } = opts;
     const write2 = (relPath, content, mode) => {
-      const abs = join9(cwd2, relPath);
-      mkdirSync5(resolve4(abs, ".."), { recursive: true });
-      writeFileSync5(abs, content, { encoding: "utf8", mode });
+      const abs = join10(cwd2, relPath);
+      mkdirSync6(resolve5(abs, ".."), { recursive: true });
+      writeFileSync6(abs, content, { encoding: "utf8", mode });
     };
     write2("AGENTS.md", stampGenerated(agentsMd(config)));
-    if (!existsSync8(join9(cwd2, "health.sh"))) {
+    if (!existsSync9(join10(cwd2, "health.sh"))) {
       write2("health.sh", HEALTH_SH, 493);
     }
-    if (config.storage.scope === "local" && !existsSync8(join9(cwd2, config.storage.markdownFallback.path))) {
+    if (config.storage.scope === "local" && !existsSync9(join10(cwd2, config.storage.markdownFallback.path))) {
       write2(
         config.storage.markdownFallback.path,
         `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
@@ -1201,7 +1292,7 @@ No tasks in progress.
       );
     }
     writeAgentFiles(cwd2, opencodeAgentFiles(config));
-    mergeOpencodeJson(join9(cwd2, "opencode.json"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
+    mergeOpencodeJson(join10(cwd2, "opencode.json"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
     appendGitignore(cwd2);
     writeSkills(cwd2, ".opencode/skills");
   }
@@ -1209,13 +1300,13 @@ No tasks in progress.
     const derived = reconcileGeneratedFiles(
       cwd2,
       [{ relPath: "AGENTS.md", content: agentsMd(config) }],
-      { force: opts.force, backupRoot: join9(cwd2, config.storage.dir, "backups") }
+      { force: opts.force, backupRoot: join10(cwd2, config.storage.dir, "backups") }
     );
     const agents = writeAgentFiles(cwd2, opencodeAgentFiles(config), {
       force: opts.force,
-      backupRoot: join9(cwd2, config.storage.dir, "backups")
+      backupRoot: join10(cwd2, config.storage.dir, "backups")
     });
-    mergeOpencodeJson(join9(cwd2, "opencode.json"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
+    mergeOpencodeJson(join10(cwd2, "opencode.json"), config.tools.mcp.port, cwd2, detectPackageManager(cwd2));
     writeSkills(cwd2, ".opencode/skills");
     return { agents, derived };
   }
@@ -1236,25 +1327,60 @@ function getMaterializer(provider) {
       return new OpenCodeMaterializer();
     case "codex-cli":
       return new CodexCliMaterializer();
+    case "grok-cli":
+      return new GrokMaterializer();
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
 }
 
+// src/commands/claude-model-prompt.ts
+import * as p from "@clack/prompts";
+var AGENT_LABELS = [
+  { key: "lead", label: "Lead" },
+  { key: "explorer", label: "Explorer" },
+  { key: "consultant", label: "Consultant" },
+  { key: "builder", label: "Builder" },
+  { key: "reviewer", label: "Reviewer" }
+];
+async function promptClaudeAgentModels(provider) {
+  const claudeAgentModels = {};
+  if (provider !== "claude-code") return claudeAgentModels;
+  for (const agent of AGENT_LABELS) {
+    const val = await p.select({
+      message: `Model for ${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 (p.isCancel(val)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    claudeAgentModels[agent.key] = val;
+  }
+  return claudeAgentModels;
+}
+
 // src/commands/build.ts
 async function runBuild(cwd2, opts) {
   await buildOnce(cwd2, opts.force);
   if (opts.sync) {
-    p.log.step("Syncing agent permissions...");
+    p2.log.step("Syncing agent permissions...");
     const config = await loadConfig(cwd2);
     const materializer = getMaterializer(config.provider);
     await materializer.syncPermissions(cwd2);
   }
   if (opts.watch) {
-    p.log.info(`Watching agent-harness-kit.config.ts for changes...`);
+    p2.log.info(`Watching agent-harness-kit.config.ts for changes...`);
     watch(cwd2, { recursive: false }, async (_, filename) => {
       if (filename?.startsWith("agent-harness-kit.config")) {
-        p.log.step("Config changed \u2014 rebuilding...");
+        p2.log.step("Config changed \u2014 rebuilding...");
         await buildOnce(cwd2, false);
       }
     });
@@ -1263,36 +1389,45 @@ async function runBuild(cwd2, opts) {
   }
 }
 async function buildOnce(cwd2, force) {
-  const spinner6 = p.spinner();
-  spinner6.start("Loading config...");
+  let config;
+  try {
+    config = await loadConfig(cwd2);
+  } catch (err) {
+    p2.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  let claudeAgentModels;
+  if (force && config.provider === "claude-code") {
+    claudeAgentModels = await promptClaudeAgentModels(config.provider);
+  }
+  const spinner6 = p2.spinner();
+  spinner6.start("Rebuilding files...");
   try {
-    const config = await loadConfig(cwd2);
-    spinner6.message("Rebuilding files...");
     const materializer = getMaterializer(config.provider);
-    const report = await materializer.build(config, cwd2, { force });
+    const report = await materializer.build(config, cwd2, { force, claudeAgentModels });
     spinner6.stop(pc2.green("Build complete"));
     const d = report.derived;
     const upToDate = [...d.created, ...d.current, ...d.propagated];
     if (upToDate.length > 0) {
-      p.log.success(upToDate.join(", "));
+      p2.log.success(upToDate.join(", "));
     }
     if (d.propagated.length > 0) {
-      p.log.info(`Propagated config changes to ${d.propagated.length} generated file(s):
+      p2.log.info(`Propagated config changes to ${d.propagated.length} generated file(s):
   ${d.propagated.join("\n  ")}`);
     }
     if (d.overwritten.length > 0) {
-      p.log.warn(
+      p2.log.warn(
         pc2.yellow(
           `--force REGENERATED ${d.overwritten.length} hand-edited generated file(s), discarding your edits:
   ` + d.overwritten.join("\n  ")
         )
       );
       if (d.backupDir) {
-        p.log.info(pc2.yellow(`  Previous content backed up \u2192 ${d.backupDir}`));
+        p2.log.info(pc2.yellow(`  Previous content backed up \u2192 ${d.backupDir}`));
       }
     }
     if (d.preserved.length > 0) {
-      p.log.warn(
+      p2.log.warn(
         pc2.yellow(
           `Left ${d.preserved.length} hand-edited generated file(s) UNTOUCHED \u2014 your edits are safe:
   ` + d.preserved.join("\n  ") + `
@@ -1301,26 +1436,26 @@ async function buildOnce(cwd2, force) {
         )
       );
     }
-    p.log.success(`Agent definitions (${config.provider})`);
-    p.log.success("MCP config");
+    p2.log.success(`Agent definitions (${config.provider})`);
+    p2.log.success("MCP config");
     const { created, overwritten, preserved, backupDir } = report.agents;
     if (created.length > 0) {
-      p.log.info(`Created ${created.length} missing agent file(s):
+      p2.log.info(`Created ${created.length} missing agent file(s):
   ${created.join("\n  ")}`);
     }
     if (overwritten.length > 0) {
-      p.log.warn(
+      p2.log.warn(
         pc2.yellow(
           `--force REGENERATED ${overwritten.length} existing agent file(s), discarding any customizations:
   ` + overwritten.join("\n  ")
         )
       );
       if (backupDir) {
-        p.log.info(pc2.yellow(`  Previous content backed up \u2192 ${backupDir}`));
+        p2.log.info(pc2.yellow(`  Previous content backed up \u2192 ${backupDir}`));
       }
     }
     if (preserved.length > 0) {
-      p.log.info(
+      p2.log.info(
         `Left ${preserved.length} existing agent file(s) untouched \u2014 agent files are yours to edit.
   Re-run with --force to regenerate them from the packaged templates (this DESTROYS your edits;
   a backup is written first).`
@@ -1328,21 +1463,21 @@ async function buildOnce(cwd2, force) {
     }
   } catch (err) {
     spinner6.stop(pc2.red("Build failed"));
-    p.log.error(err instanceof Error ? err.message : String(err));
+    p2.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }
 
 // src/commands/dashboard.ts
 import { homedir } from "os";
-import { dirname as dirname5, join as join11 } from "path";
+import { dirname as dirname5, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import pc3 from "picocolors";
 
 // src/core/dashboard-server.ts
 import { watch as watch2 } from "fs";
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import { extname, join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { extname, join as join11 } from "path";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { WebSocketServer } from "ws";
@@ -1351,11 +1486,11 @@ import { WebSocketServer } from "ws";
 import { createServer } from "net";
 var DASHBOARD_BIND_HOST = void 0;
 function isPortFree(port, host = DASHBOARD_BIND_HOST) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const server = createServer();
-    server.once("error", () => resolve11(false));
+    server.once("error", () => resolve12(false));
     server.once("listening", () => {
-      server.close(() => resolve11(true));
+      server.close(() => resolve12(true));
     });
     server.listen(port, host);
   });
@@ -1398,7 +1533,7 @@ function fileResponse(filePath) {
   });
 }
 function awaitServerListening(server, port) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const closeQuietly = () => {
       try {
         server.close(() => {
@@ -1421,7 +1556,7 @@ function awaitServerListening(server, port) {
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve11();
+      resolve12();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -1527,15 +1662,15 @@ async function startDashboardServer(db, dbPath, staticPath, port) {
   app.get("/*", (c) => {
     const urlPath = c.req.path;
     if (urlPath !== "/") {
-      const candidate = join10(staticPath, urlPath);
-      if (existsSync9(candidate)) {
+      const candidate = join11(staticPath, urlPath);
+      if (existsSync10(candidate)) {
         try {
           return fileResponse(candidate);
         } catch {
         }
       }
     }
-    return fileResponse(join10(staticPath, "index.html"));
+    return fileResponse(join11(staticPath, "index.html"));
   });
   const resolvedPort = await findFreePort(port, { host: DASHBOARD_BIND_HOST });
   if (resolvedPort !== port) {
@@ -1574,7 +1709,7 @@ async function startDashboardServer(db, dbPath, staticPath, port) {
   let watcher = null;
   if (dbPath) {
     const walPath = `${dbPath}-wal`;
-    const watchTarget = existsSync9(walPath) ? walPath : dbPath;
+    const watchTarget = existsSync10(walPath) ? walPath : dbPath;
     watcher = watch2(watchTarget, broadcast);
   }
   return {
@@ -1594,7 +1729,7 @@ async function runDashboard(cwd2, opts) {
   const config = await loadConfig(cwd2);
   const db = await openDB(config, cwd2);
   const dbPath = config.database.type === "sqlite" ? resolveSqlitePath(config, cwd2, homedir()) : null;
-  const staticPath = join11(__dirname3, "dashboard-dist");
+  const staticPath = join12(__dirname3, "dashboard-dist");
   const { url } = await startDashboardServer(db, dbPath, staticPath, opts.port);
   console.log(pc3.green(`\u2713`) + ` Dashboard running at ${pc3.bold(pc3.cyan(url))}`);
   console.log(pc3.dim(`  WebSocket live updates enabled`));
@@ -1614,8 +1749,8 @@ async function runDashboard(cwd2, opts) {
 import pc4 from "picocolors";
 
 // src/core/doctor.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname6, join as join12 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var REGISTRY_URL = `https://registry.npmjs.org/${pkg.name}/latest`;
 var TIMEOUT_MS = 2e3;
@@ -1664,19 +1799,21 @@ function getProviderAgentInfo(provider) {
       return { agentsDir: ".opencode/agents", ext: ".md" };
     case "codex-cli":
       return { agentsDir: ".codex/agents", ext: ".toml" };
+    case "grok-cli":
+      return { agentsDir: ".grok/agents", ext: ".md" };
     default:
       return { agentsDir: ".claude/agents", ext: ".md" };
   }
 }
 function checkAgentFilesAtRoot(agentsRoot, ext) {
   return AGENT_NAMES.map((name) => {
-    const filePath = join12(agentsRoot, `${name}${ext}`);
-    return { name, status: existsSync10(filePath) ? "ok" : "missing" };
+    const filePath = join13(agentsRoot, `${name}${ext}`);
+    return { name, status: existsSync11(filePath) ? "ok" : "missing" };
   });
 }
 function checkAgentFiles(cwd2, provider) {
   const { agentsDir, ext } = getProviderAgentInfo(provider);
-  return checkAgentFilesAtRoot(join12(cwd2, agentsDir), ext);
+  return checkAgentFilesAtRoot(join13(cwd2, agentsDir), ext);
 }
 function getProviderSkillsDir(provider) {
   switch (provider) {
@@ -1686,16 +1823,18 @@ function getProviderSkillsDir(provider) {
       return ".opencode/skills";
     case "codex-cli":
       return ".agents/skills";
+    case "grok-cli":
+      return ".grok/skills";
     default:
       return ".claude/skills";
   }
 }
 function checkSkillsAtRoot(skillsRoot) {
-  const skillSourceBase = join12(__dirname4, "skills");
+  const skillSourceBase = join13(__dirname4, "skills");
   return SKILL_NAMES.map((name) => {
-    const livePath = join12(skillsRoot, name, "SKILL.md");
-    const sourcePath = join12(skillSourceBase, name, "SKILL.md");
-    if (!existsSync10(livePath)) {
+    const livePath = join13(skillsRoot, name, "SKILL.md");
+    const sourcePath = join13(skillSourceBase, name, "SKILL.md");
+    if (!existsSync11(livePath)) {
       return { name, status: "missing" };
     }
     try {
@@ -1709,7 +1848,7 @@ function checkSkillsAtRoot(skillsRoot) {
 }
 function checkSkills(cwd2, provider) {
   const skillsDir = getProviderSkillsDir(provider);
-  return checkSkillsAtRoot(join12(cwd2, skillsDir));
+  return checkSkillsAtRoot(join13(cwd2, skillsDir));
 }
 async function getDoctorStatus(cwd2) {
   const lib = await checkLibVersion();
@@ -1810,7 +1949,7 @@ async function runDoctor(cwd2) {
 }
 
 // src/commands/export.ts
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import pc5 from "picocolors";
 async function runExport(cwd2, opts) {
   if (!opts.sql && !opts.json) {
@@ -1824,7 +1963,7 @@ async function runExport(cwd2, opts) {
       const data = await db.exportJson();
       const out = JSON.stringify(data, null, 2) + "\n";
       if (opts.output) {
-        writeFileSync6(opts.output, out, "utf8");
+        writeFileSync7(opts.output, out, "utf8");
         console.log(pc5.green(`\u2713 Exported JSON \u2192 ${opts.output}`));
       } else {
         process.stdout.write(out);
@@ -1841,9 +1980,9 @@ async function runExport(cwd2, opts) {
 
 // src/commands/health.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join13, resolve as resolve5 } from "path";
+import { join as join14, resolve as resolve6 } from "path";
 import pc6 from "picocolors";
 function checkLine(label, ok3, message, indent = 0) {
   const prefix = label ? pc6.cyan(`[${label}] `) : " ".repeat(indent);
@@ -1862,7 +2001,7 @@ async function runHealth(cwd2) {
   let dbOk;
   if (config.database.type === "sqlite") {
     const dbPath = resolveSqlitePath(config, cwd2, homedir2());
-    dbOk = existsSync11(dbPath);
+    dbOk = existsSync12(dbPath);
     checkLine("checking DB", dbOk, `${dbPath} reachable`);
   } else {
     dbOk = true;
@@ -1875,8 +2014,8 @@ async function runHealth(cwd2) {
   const agentsLabelWidth = "[checking agents] ".length;
   for (let i = 0; i < agentNames.length; i++) {
     const name = agentNames[i];
-    const agentPath = join13(cwd2, agentsDir, `${name}${providerFiles.agentExtension}`);
-    const ok3 = existsSync11(agentPath);
+    const agentPath = join14(cwd2, agentsDir, `${name}${providerFiles.agentExtension}`);
+    const ok3 = existsSync12(agentPath);
     checkLine(
       i === 0 ? "checking agents" : null,
       ok3,
@@ -1887,8 +2026,8 @@ async function runHealth(cwd2) {
   }
   if (config.tools.mcp.enabled) {
     const mcpFile = providerFiles.mcpFile;
-    const mcpPath = resolve5(cwd2, mcpFile);
-    const mcpOk = existsSync11(mcpPath);
+    const mcpPath = resolve6(cwd2, mcpFile);
+    const mcpOk = existsSync12(mcpPath);
     checkLine("checking MCP", mcpOk, `${mcpFile} valid`);
     if (!mcpOk) allOk = false;
   }
@@ -1897,8 +2036,8 @@ async function runHealth(cwd2) {
     console.error(pc6.red("\u2717 Harness checks failed \u2014 fix the above before running health.sh"));
     process.exit(1);
   }
-  const scriptPath = resolve5(cwd2, config.health.scriptPath);
-  if (!existsSync11(scriptPath)) {
+  const scriptPath = resolve6(cwd2, config.health.scriptPath);
+  if (!existsSync12(scriptPath)) {
     console.error(pc6.red(`\u2717 health.sh not found: ${scriptPath}`));
     console.error("  Run ahk init first.");
     process.exit(1);
@@ -1928,15 +2067,17 @@ function getProviderHealthFiles(provider) {
       return { agentsDir: ".opencode/agents", agentExtension: ".md", mcpFile: "opencode.json" };
     case "codex-cli":
       return { agentsDir: ".codex/agents", agentExtension: ".toml", mcpFile: ".codex/config.toml" };
+    case "grok-cli":
+      return { agentsDir: ".grok/agents", agentExtension: ".md", mcpFile: ".grok/config.toml" };
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { join as join15 } from "path";
-import * as p3 from "@clack/prompts";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { join as join16 } from "path";
+import * as p4 from "@clack/prompts";
 import pc8 from "picocolors";
 
 // src/schema/init.ts
@@ -1975,7 +2116,7 @@ var taskDescriptionSchema = v2.pipe(
 );
 
 // src/utils/form.ts
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import * as v3 from "valibot";
 var cliFormWithRetry = async (formFn, schema) => {
   while (true) {
@@ -1983,20 +2124,20 @@ var cliFormWithRetry = async (formFn, schema) => {
     const result = v3.safeParse(schema, res);
     if (result.success) return result.output;
     const messages = result.issues.map((i) => i.message).join(", ");
-    p2.log.error(messages);
-    p2.log.info("Please try again.\n");
+    p3.log.error(messages);
+    p3.log.info("Please try again.\n");
   }
 };
 
 // src/commands/init-helpers.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
+import { join as join15 } from "path";
 import pc7 from "picocolors";
 function readProjectNameFromPackageJson(cwd2) {
   try {
-    const pkgPath2 = join14(cwd2, "package.json");
-    if (!existsSync12(pkgPath2)) return null;
+    const pkgPath2 = join15(cwd2, "package.json");
+    if (!existsSync13(pkgPath2)) return null;
     const content = readFileSync8(pkgPath2, "utf8");
     const pkg2 = JSON.parse(content);
     const name = pkg2?.name;
@@ -2009,9 +2150,9 @@ function readProjectNameFromPackageJson(cwd2) {
 function detectConfigExtension(cwd2) {
   if (!isLocalInstallSatisfied(cwd2)) return "json";
   try {
-    if (existsSync12(join14(cwd2, "tsconfig.json"))) return "ts";
-    const pkgPath2 = join14(cwd2, "package.json");
-    if (!existsSync12(pkgPath2)) return "mjs";
+    if (existsSync13(join15(cwd2, "tsconfig.json"))) return "ts";
+    const pkgPath2 = join15(cwd2, "package.json");
+    if (!existsSync13(pkgPath2)) return "mjs";
     const pkg2 = JSON.parse(readFileSync8(pkgPath2, "utf8"));
     if (pkg2?.type === "module") return "mjs";
   } catch {
@@ -2092,10 +2233,10 @@ function printWelcomeMessage(projectName) {
 
 // src/commands/init.ts
 async function reconcileFeatureList(db, installDir, storageDir, firstTask) {
-  const featureListPath = join15(installDir, storageDir, "feature_list.json");
+  const featureListPath = join16(installDir, storageDir, "feature_list.json");
   let existingSeeds = [];
   let parseFailed = false;
-  if (existsSync13(featureListPath)) {
+  if (existsSync14(featureListPath)) {
     try {
       const parsed = JSON.parse(readFileSync9(featureListPath, "utf8"));
       if (!Array.isArray(parsed)) throw new Error("feature_list.json is not a JSON array");
@@ -2145,86 +2286,60 @@ async function runInit(cwd2, flags) {
     name = flags.name;
   } else {
     name = await cliFormWithRetry(async () => {
-      const val = await p3.text({
+      const val = await p4.text({
         message: "Project name",
         placeholder: "my-app",
         ...detectedName && { initialValue: detectedName }
       });
-      if (p3.isCancel(val)) {
-        p3.cancel("Cancelled.");
+      if (p4.isCancel(val)) {
+        p4.cancel("Cancelled.");
         process.exit(0);
       }
       return val;
     }, initNameSchema);
   }
   const description = await cliFormWithRetry(async () => {
-    const val = await p3.text({
+    const val = await p4.text({
       message: "Short description (shown to agents as context)",
       placeholder: "A REST API for managing notes"
     });
-    if (p3.isCancel(val)) {
-      p3.cancel("Cancelled.");
+    if (p4.isCancel(val)) {
+      p4.cancel("Cancelled.");
       process.exit(0);
     }
     return val;
   }, initDescriptionSchema);
   let provider;
-  if (flags.provider && ["claude-code", "opencode"].includes(flags.provider)) {
+  if (flags.provider && ["claude-code", "opencode", "codex-cli", "grok-cli"].includes(flags.provider)) {
     provider = flags.provider;
   } else {
-    const val = await p3.select({
+    const val = await p4.select({
       message: "AI provider",
       options: [
         { value: "opencode", label: "OpenCode" },
         { value: "claude-code", label: "Claude Code" },
-        { value: "codex-cli", label: "Codex CLI" }
+        { value: "codex-cli", label: "Codex CLI" },
+        { value: "grok-cli", label: "Grok CLI" }
       ]
     });
-    if (p3.isCancel(val)) {
-      p3.cancel("Cancelled.");
+    if (p4.isCancel(val)) {
+      p4.cancel("Cancelled.");
       process.exit(0);
     }
     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 claudeAgentModels = {};
-  if (provider === "claude-code") {
-    for (const agent of AGENT_LABELS) {
-      const val = await p3.select({
-        message: `Model for ${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);
-      }
-      claudeAgentModels[agent.key] = val;
-    }
-  }
+  const claudeAgentModels = await promptClaudeAgentModels(provider);
   let docsPath;
   if (flags.docs) {
     docsPath = flags.docs;
   } else {
     docsPath = await cliFormWithRetry(async () => {
-      const val = await p3.text({
+      const val = await p4.text({
         message: "Docs folder path (agents will search here)",
         initialValue: "./docs"
       });
-      if (p3.isCancel(val)) {
-        p3.cancel("Cancelled.");
+      if (p4.isCancel(val)) {
+        p4.cancel("Cancelled.");
         process.exit(0);
       }
       return val;
@@ -2234,7 +2349,7 @@ async function runInit(cwd2, flags) {
   if (flags.storageScope && ["local", "global"].includes(flags.storageScope)) {
     storageScope = flags.storageScope;
   } else {
-    const val = await p3.select({
+    const val = await p4.select({
       message: "Storage scope",
       options: [
         { value: "local", label: "Local \u2014 .harness/harness.db lives in this project" },
@@ -2245,8 +2360,8 @@ async function runInit(cwd2, flags) {
       ],
       initialValue: "local"
     });
-    if (p3.isCancel(val)) {
-      p3.cancel("Cancelled.");
+    if (p4.isCancel(val)) {
+      p4.cancel("Cancelled.");
       process.exit(0);
     }
     storageScope = val;
@@ -2255,7 +2370,7 @@ async function runInit(cwd2, flags) {
   if (flags.tasks && ["local", "jira", "linear"].includes(flags.tasks)) {
     tasksAdapter = flags.tasks;
   } else {
-    const val = await p3.select({
+    const val = await p4.select({
       message: "Task adapter",
       options: [
         { value: "local", label: "Local (feature_list.json)" },
@@ -2263,50 +2378,50 @@ async function runInit(cwd2, flags) {
         { value: "linear", label: "Linear (coming soon)" }
       ]
     });
-    if (p3.isCancel(val)) {
-      p3.cancel("Cancelled");
+    if (p4.isCancel(val)) {
+      p4.cancel("Cancelled");
       process.exit(0);
     }
     tasksAdapter = val;
   }
-  const addFirstTask = await p3.confirm({ message: "Add your first task now?", initialValue: false });
-  if (p3.isCancel(addFirstTask)) {
-    p3.cancel("Cancelled");
+  const addFirstTask = await p4.confirm({ message: "Add your first task now?", initialValue: false });
+  if (p4.isCancel(addFirstTask)) {
+    p4.cancel("Cancelled");
     process.exit(0);
   }
   let firstTask;
   if (addFirstTask) {
     const taskTitle = await cliFormWithRetry(async () => {
-      const val = await p3.text({ message: "Task title" });
-      if (p3.isCancel(val)) {
-        p3.cancel("Cancelled");
+      const val = await p4.text({ message: "Task title" });
+      if (p4.isCancel(val)) {
+        p4.cancel("Cancelled");
         process.exit(0);
       }
       return val.trim();
     }, taskTitleSchema);
     const taskDesc = await cliFormWithRetry(async () => {
-      const val = await p3.text({ message: "Task description", placeholder: "What and why" });
-      if (p3.isCancel(val)) {
-        p3.cancel("Cancelled");
+      const val = await p4.text({ message: "Task description", placeholder: "What and why" });
+      if (p4.isCancel(val)) {
+        p4.cancel("Cancelled");
         process.exit(0);
       }
       return val.trim();
     }, taskDescriptionSchema);
     const acceptance = [];
-    p3.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+    p4.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
     while (true) {
-      const criterionVal = await p3.text({
+      const criterionVal = await p4.text({
         message: ">",
         placeholder: "Criterion (or press Enter to finish)"
       });
-      if (p3.isCancel(criterionVal) || !criterionVal || !criterionVal.trim()) break;
+      if (p4.isCancel(criterionVal) || !criterionVal || !criterionVal.trim()) break;
       acceptance.push(criterionVal.trim());
     }
     firstTask = { title: taskTitle, description: taskDesc, acceptance };
   }
   let configExt = "ts";
   let featureListParseFailedPath = null;
-  const spinner6 = p3.spinner();
+  const spinner6 = p4.spinner();
   spinner6.start("Scaffolding...");
   try {
     const config = applyConfigDefaults({
@@ -2332,20 +2447,20 @@ async function runInit(cwd2, flags) {
       scope: config.storage.scope,
       projectId: config.storage.projectId
     });
-    writeFileSync7(join15(installDir, configFileName), configContent, "utf8");
-    mkdirSync6(join15(installDir, config.storage.dir), { recursive: true });
+    writeFileSync8(join16(installDir, configFileName), configContent, "utf8");
+    mkdirSync7(join16(installDir, config.storage.dir), { recursive: true });
     const db = await openDB(config, installDir);
     await db.writeStorageState(installDir);
     await materializer.scaffold(config, { cwd: installDir, firstTask, claudeAgentModels });
     const { parseFailed } = await reconcileFeatureList(db, installDir, config.storage.dir, firstTask);
     if (parseFailed) {
-      featureListParseFailedPath = join15(config.storage.dir, "feature_list.json");
+      featureListParseFailedPath = join16(config.storage.dir, "feature_list.json");
     }
     await db.close();
     spinner6.stop("");
   } catch (err) {
     spinner6.stop("Failed");
-    p3.log.error(err instanceof Error ? err.message : String(err));
+    p4.log.error(err instanceof Error ? err.message : String(err));
     throw err;
   }
   if (featureListParseFailedPath) {
@@ -2354,8 +2469,13 @@ async function runInit(cwd2, flags) {
     );
   }
   console.log(pc8.green("\u2713 Scaffolded harness in current directory"));
-  const agentsDir = provider === "claude-code" ? ".claude/agents/" : ".opencode/agents/";
-  const mcpFile = provider === "claude-code" ? ".claude/mcp.json" : "./opencode.json";
+  const PROVIDER_SUMMARY_INFO = {
+    "claude-code": { agentsDir: ".claude/agents/", mcpFile: ".mcp.json" },
+    opencode: { agentsDir: ".opencode/agents/", mcpFile: "./opencode.json" },
+    "codex-cli": { agentsDir: ".codex/agents/", mcpFile: ".codex/config.toml" },
+    "grok-cli": { agentsDir: ".grok/agents/", mcpFile: ".grok/config.toml" }
+  };
+  const { agentsDir, mcpFile } = PROVIDER_SUMMARY_INFO[provider];
   console.log("");
   console.log(pc8.green(`\u2713 agent-harness-kit.config.${configExt}`));
   console.log(pc8.green("\u2713 AGENTS.md"));
@@ -2392,24 +2512,25 @@ async function runInit(cwd2, flags) {
 }
 
 // src/commands/migrate.ts
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 import pc9 from "picocolors";
 async function runMigrate(cwd2, opts) {
   const config = await loadConfig(cwd2);
   let target;
-  if (opts.to && ["claude-code", "opencode", "codex-cli"].includes(opts.to)) {
+  if (opts.to && ["claude-code", "opencode", "codex-cli", "grok-cli"].includes(opts.to)) {
     target = opts.to;
   } else {
-    const val = await p4.select({
+    const val = await p5.select({
       message: "Migrate to provider",
       options: [
         { value: "claude-code", label: "Claude Code" },
         { value: "opencode", label: "OpenCode" },
-        { value: "codex-cli", label: "Codex CLI" }
+        { value: "codex-cli", label: "Codex CLI" },
+        { value: "grok-cli", label: "Grok CLI" }
       ]
     });
-    if (p4.isCancel(val)) {
-      p4.cancel("Cancelled.");
+    if (p5.isCancel(val)) {
+      p5.cancel("Cancelled.");
       process.exit(0);
     }
     target = val;
@@ -2418,25 +2539,25 @@ async function runMigrate(cwd2, opts) {
     console.log(pc9.dim(`Already on ${target} \u2014 nothing to migrate.`));
     return;
   }
-  const spinner6 = p4.spinner();
+  const spinner6 = p5.spinner();
   spinner6.start(`Migrating from ${config.provider} to ${target}...`);
   try {
     const targetMaterializer = getMaterializer(target);
     await targetMaterializer.build(config, cwd2);
     spinner6.stop(pc9.green(`Migrated to ${target}`));
-    p4.log.warn(`Update agent-harness-kit.config.ts: set provider: '${target}'`);
-    p4.log.warn(`Then run: ahk build`);
+    p5.log.warn(`Update agent-harness-kit.config.ts: set provider: '${target}'`);
+    p5.log.warn(`Then run: ahk build`);
   } catch (err) {
     spinner6.stop(pc9.red("Migration failed"));
-    p4.log.error(err instanceof Error ? err.message : String(err));
+    p5.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }
 
 // src/commands/migrate-storage.ts
-import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync8 } from "fs";
+import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync8, rmSync, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname7, join as join16, resolve as resolve6 } from "path";
+import { dirname as dirname7, join as join17, resolve as resolve7 } from "path";
 import pc10 from "picocolors";
 function log5(msg) {
   console.log(msg);
@@ -2448,17 +2569,17 @@ function defaultMarkdownPathForConfig(config) {
   return config.storage.scope === "local" ? config.storage.markdownFallback.path : DEFAULT_MARKDOWN_PATH;
 }
 function currentMdPathForScope(scope, config, cwd2, homeDir) {
-  return scope === "global" ? join16(resolveGlobalStorageDir(config, homeDir), "current.md") : resolve6(cwd2, defaultMarkdownPathForConfig(config));
+  return scope === "global" ? join17(resolveGlobalStorageDir(config, homeDir), "current.md") : resolve7(cwd2, defaultMarkdownPathForConfig(config));
 }
 function defaultSqlitePathForConfig(config) {
   return config.storage.scope === "local" && config.database.type === "sqlite" ? config.storage.sqlitePath ?? DEFAULT_SQLITE_PATH : DEFAULT_SQLITE_PATH;
 }
 async function backupDestination(cwd2, storageDir, data) {
-  const backupsDir = resolve6(cwd2, storageDir, "backups");
-  const path = join16(backupsDir, `pre-migrate-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
+  const backupsDir = resolve7(cwd2, storageDir, "backups");
+  const path = join17(backupsDir, `pre-migrate-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
   try {
-    mkdirSync7(backupsDir, { recursive: true });
-    writeFileSync8(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+    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.`
@@ -2467,14 +2588,14 @@ async function backupDestination(cwd2, storageDir, data) {
   return path;
 }
 function copySqliteFile(srcPath, destPath) {
-  mkdirSync7(dirname7(destPath), { recursive: true });
+  mkdirSync8(dirname7(destPath), { recursive: true });
   copyFileSync(srcPath, destPath);
   for (const suffix of ["-wal", "-shm"]) {
-    if (existsSync14(`${srcPath}${suffix}`)) {
+    if (existsSync15(`${srcPath}${suffix}`)) {
       copyFileSync(`${srcPath}${suffix}`, `${destPath}${suffix}`);
     }
   }
-  if (!existsSync14(destPath)) {
+  if (!existsSync15(destPath)) {
     throw new Error(`Copy verification failed: ${destPath} does not exist after copy.`);
   }
 }
@@ -2533,7 +2654,7 @@ async function runMigrateStorage(cwd2, opts, homeDir = homedir3()) {
   return migrateAcrossDbType(cwd2, config, homeDir, realScope, opts);
 }
 async function probeTaskCount(dbPath) {
-  if (!existsSync14(dbPath)) return 0;
+  if (!existsSync15(dbPath)) return 0;
   const { SQLiteDriver } = await import("./sqlite-5OWKTUUZ.js");
   const driver = new SQLiteDriver(dbPath);
   try {
@@ -2550,10 +2671,10 @@ async function migrateScopeOnly(cwd2, config, homeDir, fromScope, toScope, opts)
   const destDb = resolveSqlitePathForScope(toScope, sqlitePath, cwd2, config, homeDir);
   const srcMd = currentMdPathForScope(fromScope, config, cwd2, homeDir);
   const destMd = currentMdPathForScope(toScope, config, cwd2, homeDir);
-  if (!existsSync14(srcDb)) {
+  if (!existsSync15(srcDb)) {
     fail(`Source database not found at ${srcDb} (expected ${fromScope} scope) \u2014 nothing to move.`);
   }
-  const destExists = existsSync14(destDb);
+  const destExists = existsSync15(destDb);
   if (destExists) {
     const { SQLiteDriver } = await import("./sqlite-5OWKTUUZ.js");
     const destDriver = new SQLiteDriver(destDb);
@@ -2591,15 +2712,15 @@ async function migrateScopeOnly(cwd2, config, homeDir, fromScope, toScope, opts)
   }
   copySqliteFile(srcDb, destDb);
   log5(pc10.green(`\u2713 Copied database ${srcDb} \u2192 ${destDb}`));
-  if (existsSync14(srcMd)) {
-    mkdirSync7(dirname7(destMd), { recursive: true });
+  if (existsSync15(srcMd)) {
+    mkdirSync8(dirname7(destMd), { recursive: true });
     copyFileSync(srcMd, destMd);
     log5(pc10.green(`\u2713 Copied current.md ${srcMd} \u2192 ${destMd}`));
   }
   rmSync(srcDb, { force: true });
   rmSync(`${srcDb}-wal`, { force: true });
   rmSync(`${srcDb}-shm`, { force: true });
-  if (existsSync14(srcMd) && srcMd !== destMd) rmSync(srcMd, { force: true });
+  if (existsSync15(srcMd) && srcMd !== destMd) rmSync(srcMd, { force: true });
   const db = await openDB(config, cwd2, homeDir);
   try {
     await db.writeStorageState(cwd2);
@@ -2611,7 +2732,7 @@ async function migrateScopeOnly(cwd2, config, homeDir, fromScope, toScope, opts)
 async function migrateAcrossDbType(cwd2, config, homeDir, sourceScope, opts) {
   const sqlitePath = defaultSqlitePathForConfig(config);
   const srcPath = resolveSqlitePathForScope(sourceScope, sqlitePath, cwd2, config, homeDir);
-  if (!existsSync14(srcPath)) {
+  if (!existsSync15(srcPath)) {
     fail(`Source sqlite database not found at ${srcPath} (expected ${sourceScope} scope) \u2014 nothing to migrate.`);
   }
   const { SQLiteDriver } = await import("./sqlite-5OWKTUUZ.js");
@@ -2673,55 +2794,121 @@ async function migrateAcrossDbType(cwd2, config, homeDir, sourceScope, opts) {
   }
 }
 
+// src/commands/models.ts
+import { join as join18 } from "path";
+import pc11 from "picocolors";
+async function resolveModelsContext(cwd2) {
+  let config;
+  try {
+    config = await loadConfig(cwd2);
+  } catch {
+    return { ok: false, reason: "no-config" };
+  }
+  if (config.provider !== "claude-code") {
+    return { ok: false, reason: "not-claude-code", provider: config.provider };
+  }
+  return { ok: true, config };
+}
+async function runModels(cwd2) {
+  const ctx = await resolveModelsContext(cwd2);
+  if (!ctx.ok) {
+    if (ctx.reason === "no-config") {
+      console.log("");
+      console.log(`  ${pc11.cyan("config".padEnd(16))}${pc11.yellow("[!]")} no agent-harness-kit.config found`);
+      console.log(`  ${"".padEnd(16)}    ${pc11.dim("run: ahk init")}`);
+      console.log("");
+      return;
+    }
+    console.log(
+      pc11.dim(
+        `ahk models only applies to Claude Code projects (this project uses '${ctx.provider}') \u2014 nothing to do.`
+      )
+    );
+    return;
+  }
+  const { config } = ctx;
+  const claudeAgentModels = await promptClaudeAgentModels(config.provider);
+  const agents = writeAgentFiles(cwd2, claudeAgentFiles(config, claudeAgentModels), {
+    force: true,
+    backupRoot: join18(cwd2, config.storage.dir, "backups")
+  });
+  console.log("");
+  if (agents.overwritten.length > 0) {
+    console.log(pc11.green(`\u2713 Regenerated ${agents.overwritten.length} agent file(s) with updated models:`));
+    for (const file of agents.overwritten) console.log(pc11.green(`  \u2713 ${file}`));
+    if (agents.backupDir) {
+      console.log(pc11.dim(`  Previous content backed up \u2192 ${agents.backupDir}`));
+    }
+  }
+  if (agents.created.length > 0) {
+    console.log(pc11.green(`\u2713 Created ${agents.created.length} missing agent file(s):`));
+    for (const file of agents.created) console.log(pc11.green(`  \u2713 ${file}`));
+  }
+  console.log("");
+}
+
 // src/commands/reset.ts
-import { existsSync as existsSync15, readdirSync, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync16, readdirSync, rmSync as rmSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join17, resolve as resolve7 } from "path";
-import * as p5 from "@clack/prompts";
-import pc11 from "picocolors";
+import { join as join19, resolve as resolve8 } from "path";
+import * as p6 from "@clack/prompts";
+import pc12 from "picocolors";
 var AGENT_MD_FILES = ["lead", "explorer", "consultant", "builder", "reviewer"];
+var PROVIDER_AGENT_DIRS = {
+  "claude-code": ".claude/agents",
+  opencode: ".opencode/agents",
+  "codex-cli": ".codex/agents",
+  "grok-cli": ".grok/agents"
+};
+var PROVIDER_AGENT_EXT = {
+  "claude-code": ".md",
+  opencode: ".md",
+  "codex-cli": ".toml",
+  "grok-cli": ".md"
+};
 async function resetAgentMds(cwd2, provider) {
-  const agentDir = provider === "claude-code" ? ".claude/agents" : ".opencode/agents";
-  const agentDirPath = resolve7(cwd2, agentDir);
-  if (!existsSync15(agentDirPath)) {
-    console.log(pc11.yellow(`  Skipping agent files \u2014 directory not found: ${agentDirPath}`));
+  const agentDir = PROVIDER_AGENT_DIRS[provider];
+  const agentDirPath = resolve8(cwd2, agentDir);
+  const agentExt = PROVIDER_AGENT_EXT[provider];
+  if (!existsSync16(agentDirPath)) {
+    console.log(pc12.yellow(`  Skipping agent files \u2014 directory not found: ${agentDirPath}`));
     return;
   }
   const existingFiles = [];
   try {
     const files = readdirSync(agentDirPath);
     for (const f of files) {
-      if (f.endsWith(".md") && AGENT_MD_FILES.includes(f.replace(".md", ""))) {
+      if (f.endsWith(agentExt) && AGENT_MD_FILES.includes(f.replace(agentExt, ""))) {
         existingFiles.push(f);
       }
     }
   } catch {
-    console.log(pc11.yellow(`  Skipping agent files \u2014 ${agentDirPath} is not readable`));
+    console.log(pc12.yellow(`  Skipping agent files \u2014 ${agentDirPath} is not readable`));
     return;
   }
   if (existingFiles.length === 0) {
-    console.log(pc11.yellow(`  No agent MD files found in ${agentDir}/`));
+    console.log(pc12.yellow(`  No agent MD files found in ${agentDir}/`));
     return;
   }
   for (const file of existingFiles) {
-    const confirm3 = await p5.confirm({
+    const confirm3 = await p6.confirm({
       message: `Remove ${file}?`,
       initialValue: true
     });
-    if (p5.isCancel(confirm3)) {
-      console.log(pc11.red("  Cancelled by user."));
+    if (p6.isCancel(confirm3)) {
+      console.log(pc12.red("  Cancelled by user."));
       return;
     }
     if (confirm3) {
       try {
-        const filePath = join17(agentDirPath, file);
+        const filePath = join19(agentDirPath, file);
         rmSync2(filePath, { force: true });
-        console.log(pc11.green(`  Removed ${file}`));
+        console.log(pc12.green(`  Removed ${file}`));
       } catch {
-        console.error(pc11.red(`  Failed to remove ${file}`));
+        console.error(pc12.red(`  Failed to remove ${file}`));
       }
     } else {
-      console.log(pc11.cyan(`  Skipped ${file}`));
+      console.log(pc12.cyan(`  Skipped ${file}`));
     }
   }
 }
@@ -2730,47 +2917,47 @@ async function runReset(cwd2, opts) {
   try {
     config = await loadConfig(cwd2);
   } catch {
-    console.error(pc11.red("\u2717 No agent-harness-kit.config found. Run: ahk init"));
+    console.error(pc12.red("\u2717 No agent-harness-kit.config found. Run: ahk init"));
     process.exit(1);
   }
   const storageDir = config.storage.dir || ".harness";
   const dbPath = config.database.type === "sqlite" ? resolveSqlitePath(config, cwd2, homedir4()) : null;
-  const featureListPath = resolve7(cwd2, storageDir, "feature_list.json");
+  const featureListPath = resolve8(cwd2, storageDir, "feature_list.json");
   let resetDb = false;
   let resetFeatureList = false;
   let resetAgentMdsFlag = false;
-  if (dbPath && existsSync15(dbPath)) {
+  if (dbPath && existsSync16(dbPath)) {
     if (opts.force) {
       resetDb = true;
     } else {
       if (config.database.type !== "sqlite") {
-        console.log(pc11.yellow(`  Skipping DB reset \u2014 database type "${config.database.type}" is not managed by this command.`));
+        console.log(pc12.yellow(`  Skipping DB reset \u2014 database type "${config.database.type}" is not managed by this command.`));
         resetDb = false;
       } else {
-        const confirm3 = await p5.confirm({
+        const confirm3 = await p6.confirm({
           message: `Delete database (${dbPath})?`,
           initialValue: true
         });
-        if (p5.isCancel(confirm3)) {
-          console.log(pc11.red("  Cancelled by user."));
+        if (p6.isCancel(confirm3)) {
+          console.log(pc12.red("  Cancelled by user."));
           return;
         }
         resetDb = confirm3;
       }
     }
   } else if (!dbPath) {
-    console.log(pc11.dim(`  Skipping DB reset \u2014 remote ${config.database.type} database is not managed by this command.`));
+    console.log(pc12.dim(`  Skipping DB reset \u2014 remote ${config.database.type} database is not managed by this command.`));
   }
-  if (existsSync15(featureListPath)) {
+  if (existsSync16(featureListPath)) {
     if (opts.force) {
       resetFeatureList = true;
     } else {
-      const confirm3 = await p5.confirm({
+      const confirm3 = await p6.confirm({
         message: `Delete feature list (${storageDir}/feature_list.json)?`,
         initialValue: true
       });
-      if (p5.isCancel(confirm3)) {
-        console.log(pc11.red("  Cancelled by user."));
+      if (p6.isCancel(confirm3)) {
+        console.log(pc12.red("  Cancelled by user."));
         return;
       }
       resetFeatureList = confirm3;
@@ -2784,17 +2971,17 @@ async function runReset(cwd2, opts) {
       rmSync2(dbPath, { force: true });
       rmSync2(`${dbPath}-wal`, { force: true });
       rmSync2(`${dbPath}-shm`, { force: true });
-      console.log(pc11.green(`  \u2713 Removed ${dbPath}`));
+      console.log(pc12.green(`  \u2713 Removed ${dbPath}`));
     } catch {
-      console.error(pc11.red(`  \u2717 Failed to remove ${dbPath}`));
+      console.error(pc12.red(`  \u2717 Failed to remove ${dbPath}`));
     }
   }
   if (resetFeatureList) {
     try {
       rmSync2(featureListPath, { force: true });
-      console.log(pc11.green(`  \u2713 Removed ${storageDir}/feature_list.json`));
+      console.log(pc12.green(`  \u2713 Removed ${storageDir}/feature_list.json`));
     } catch {
-      console.error(pc11.red(`  \u2717 Failed to remove ${featureListPath}`));
+      console.error(pc12.red(`  \u2717 Failed to remove ${featureListPath}`));
     }
   }
   if (resetAgentMdsFlag) {
@@ -2802,16 +2989,16 @@ async function runReset(cwd2, opts) {
     await resetAgentMds(cwd2, opts.provider || "claude-code");
   }
   if (!resetDb && !resetFeatureList && !resetAgentMdsFlag) {
-    console.log(pc11.yellow("  Nothing to reset (all items missing or skipped)."));
+    console.log(pc12.yellow("  Nothing to reset (all items missing or skipped)."));
     return;
   }
   console.log("");
-  console.log(pc11.green('\u2713 Reset complete. Run "ahk init" to scaffold a fresh harness.'));
+  console.log(pc12.green('\u2713 Reset complete. Run "ahk init" to scaffold a fresh harness.'));
 }
 
 // src/core/mcp-server.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync, writeFileSync as writeFileSync9 } from "fs";
-import { join as join19, resolve as resolve8 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync, writeFileSync as writeFileSync10 } from "fs";
+import { join as join21, resolve as resolve9 } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -2820,8 +3007,8 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/core/permissions-check.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join20 } from "path";
 var AGENTS = ["lead", "explorer", "consultant", "builder", "reviewer"];
 function checkPermissionsSync(cwd2, config) {
   if (config.provider !== "claude-code") {
@@ -2830,8 +3017,8 @@ function checkPermissionsSync(cwd2, config) {
   const agents = {};
   let in_sync = true;
   for (const agent of AGENTS) {
-    const filePath = join18(cwd2, ".claude", "agents", `${agent}.md`);
-    const exists = existsSync16(filePath);
+    const filePath = join20(cwd2, ".claude", "agents", `${agent}.md`);
+    const exists = existsSync17(filePath);
     if (!exists) in_sync = false;
     agents[agent] = exists ? { ok: true } : { ok: false, reason: "missing_file" };
   }
@@ -3129,7 +3316,7 @@ var TOOLS = [
 ];
 async function startMcpServer(config, cwd2) {
   const db = await openDB(config, cwd2);
-  const docsPath = resolve8(cwd2, config.project.docsPath);
+  const docsPath = resolve9(cwd2, config.project.docsPath);
   const server = new Server(
     { name: "agent-harness-kit", version: VERSION },
     { capabilities: { tools: {} } }
@@ -3292,8 +3479,8 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
       return ok2(JSON.stringify(result));
     }
     case "deps.snapshot": {
-      const pkgPath2 = join19(cwd2, "package.json");
-      if (!existsSync17(pkgPath2)) {
+      const pkgPath2 = join21(cwd2, "package.json");
+      if (!existsSync18(pkgPath2)) {
         return ok2("package.json not found in project root", true);
       }
       const pkg2 = JSON.parse(readFileSync10(pkgPath2, "utf8"));
@@ -3302,9 +3489,9 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
         dependencies: pkg2.dependencies ?? {},
         devDependencies: pkg2.devDependencies ?? {}
       };
-      const harnessDir = join19(cwd2, ".harness");
-      mkdirSync8(harnessDir, { recursive: true });
-      writeFileSync9(join19(harnessDir, "deps-lock.json"), JSON.stringify(snapshot, null, 2), "utf8");
+      const harnessDir = join21(cwd2, ".harness");
+      mkdirSync9(harnessDir, { recursive: true });
+      writeFileSync10(join21(harnessDir, "deps-lock.json"), JSON.stringify(snapshot, null, 2), "utf8");
       return ok2(
         JSON.stringify({
           message: "Snapshot saved to .harness/deps-lock.json",
@@ -3313,12 +3500,12 @@ async function dispatch(name, args, db, docsPath, cwd2, config) {
       );
     }
     case "deps.check": {
-      const pkgPath2 = join19(cwd2, "package.json");
-      const lockPath = join19(cwd2, ".harness", "deps-lock.json");
-      if (!existsSync17(pkgPath2)) {
+      const pkgPath2 = join21(cwd2, "package.json");
+      const lockPath = join21(cwd2, ".harness", "deps-lock.json");
+      if (!existsSync18(pkgPath2)) {
         return ok2("package.json not found in project root", true);
       }
-      if (!existsSync17(lockPath)) {
+      if (!existsSync18(lockPath)) {
         return ok2(
           JSON.stringify({
             status: "no-snapshot",
@@ -3420,7 +3607,7 @@ function collectMarkdownFiles(dir) {
   const files = [];
   try {
     for (const entry of readdirSync2(dir)) {
-      const full = join19(dir, entry);
+      const full = join21(dir, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         files.push(...collectMarkdownFiles(full));
@@ -3477,12 +3664,12 @@ async function runServe(cwd2, opts) {
 
 // src/commands/status.ts
 import Table from "cli-table3";
-import pc12 from "picocolors";
+import pc13 from "picocolors";
 var STATUS_COLOR = {
-  pending: (s) => pc12.dim(s),
-  in_progress: (s) => pc12.cyan(s),
-  done: (s) => pc12.green(s),
-  blocked: (s) => pc12.red(s)
+  pending: (s) => pc13.dim(s),
+  in_progress: (s) => pc13.cyan(s),
+  done: (s) => pc13.green(s),
+  blocked: (s) => pc13.red(s)
 };
 async function runStatus(cwd2, opts) {
   const config = await loadConfig(cwd2);
@@ -3503,11 +3690,11 @@ async function runStatus(cwd2, opts) {
       return;
     }
     if (tasks.length === 0) {
-      console.log(pc12.dim("No tasks yet. Run: ahk task add"));
+      console.log(pc13.dim("No tasks yet. Run: ahk task add"));
       return;
     }
     const table = new Table({
-      head: ["ID", "Slug", "Title", "Status", "Assigned", "Started"].map((h) => pc12.bold(h)),
+      head: ["ID", "Slug", "Title", "Status", "Assigned", "Started"].map((h) => pc13.bold(h)),
       style: { head: [], border: [] }
     });
     for (const t of tasks) {
@@ -3525,12 +3712,12 @@ async function runStatus(cwd2, opts) {
     const inProgress = tasks.filter((t) => t.status === "in_progress");
     if (inProgress.length > 0) {
       console.log("");
-      console.log(pc12.bold("Active actions:"));
+      console.log(pc13.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(`  ${pc12.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
+          console.log(`  ${pc13.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
         }
       }
     }
@@ -3539,10 +3726,10 @@ async function runStatus(cwd2, opts) {
       const fn = STATUS_COLOR[s.status] ?? ((x) => x);
       return `${fn(s.status)}: ${s.total}`;
     });
-    console.log(pc12.dim("Tasks \u2014 ") + parts.join(pc12.dim(" | ")));
+    console.log(pc13.dim("Tasks \u2014 ") + parts.join(pc13.dim(" | ")));
     const archivedTasks = await db.getArchivedTasks();
     if (archivedTasks.length > 0) {
-      console.log(pc12.dim(`${archivedTasks.length} archived (use \`ahk task list --archived\` to view)`));
+      console.log(pc13.dim(`${archivedTasks.length} archived (use \`ahk task list --archived\` to view)`));
     }
   } finally {
     await db.close();
@@ -3550,13 +3737,13 @@ async function runStatus(cwd2, opts) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
-import { join as join20, resolve as resolve9 } from "path";
-import pc13 from "picocolors";
+import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
+import { join as join22, resolve as resolve10 } from "path";
+import pc14 from "picocolors";
 async function runSync(cwd2, opts) {
   const config = await loadConfig(cwd2);
   const direction = opts.direction ?? "both";
-  const featureListPath = resolve9(join20(cwd2, config.storage.dir, "feature_list.json"));
+  const featureListPath = resolve10(join22(cwd2, config.storage.dir, "feature_list.json"));
   const db = await openDB(config, cwd2);
   try {
     if (direction === "in" || direction === "both") {
@@ -3570,49 +3757,49 @@ async function runSync(cwd2, opts) {
   }
 }
 async function syncIn(featureListPath, db, dryRun) {
-  if (!existsSync18(featureListPath)) {
-    console.log(pc13.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
+  if (!existsSync19(featureListPath)) {
+    console.log(pc14.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
     return;
   }
   let seeds;
   try {
     seeds = JSON.parse(readFileSync11(featureListPath, "utf8"));
   } catch (err) {
-    console.error(pc13.red(`Failed to parse feature_list.json: ${err}`));
+    console.error(pc14.red(`Failed to parse feature_list.json: ${err}`));
     process.exit(1);
   }
   if (dryRun) {
-    console.log(pc13.bold("Dry run \u2014 in-sync (feature_list.json \u2192 SQLite):"));
+    console.log(pc14.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 ? pc13.dim("skip") : pc13.green("add ")} ${t.slug}`);
+      console.log(`  ${existing ? pc14.dim("skip") : pc14.green("add ")} ${t.slug}`);
     }
     return;
   }
   const result = await db.syncFromFeatureList(seeds);
-  console.log(pc13.green(`\u2713 In-sync: ${result.added} added, ${result.skipped} already existed`));
+  console.log(pc14.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(pc13.bold("Dry run \u2014 out-sync (SQLite \u2192 feature_list.json):"));
+    console.log(pc14.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(pc13.green("\u2713 Out-sync: feature_list.json updated"));
+  console.log(pc14.green("\u2713 Out-sync: feature_list.json updated"));
 }
 
 // src/commands/task/add.ts
-import * as p6 from "@clack/prompts";
-import pc14 from "picocolors";
+import * as p7 from "@clack/prompts";
+import pc15 from "picocolors";
 async function runTaskAdd(cwd2) {
-  p6.intro(pc14.bold("agent-harness-kit \u2014 add task"));
+  p7.intro(pc15.bold("agent-harness-kit \u2014 add task"));
   const title = await cliFormWithRetry(
     async () => {
-      const val = await p6.text({ message: "Task title" });
-      if (p6.isCancel(val)) {
-        p6.cancel("Cancelled.");
+      const val = await p7.text({ message: "Task title" });
+      if (p7.isCancel(val)) {
+        p7.cancel("Cancelled.");
         process.exit(0);
       }
       return val.trim();
@@ -3621,12 +3808,12 @@ async function runTaskAdd(cwd2) {
   );
   const description = await cliFormWithRetry(
     async () => {
-      const val = await p6.text({
+      const val = await p7.text({
         message: "Description (what and why)",
         placeholder: "Describe the task in more detail, including any relevant context or instructions for the agents."
       });
-      if (p6.isCancel(val)) {
-        p6.cancel("Cancelled.");
+      if (p7.isCancel(val)) {
+        p7.cancel("Cancelled.");
         process.exit(0);
       }
       return val.trim();
@@ -3634,13 +3821,13 @@ async function runTaskAdd(cwd2) {
     taskDescriptionSchema
   );
   const acceptance = [];
-  p6.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+  p7.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
   while (true) {
-    const val = await p6.text({ message: ">", placeholder: "Criterion (or press Enter to finish)" });
-    if (p6.isCancel(val) || !val || !val.trim()) break;
+    const val = await p7.text({ message: ">", placeholder: "Criterion (or press Enter to finish)" });
+    if (p7.isCancel(val) || !val || !val.trim()) break;
     acceptance.push(val.trim());
   }
-  const spinner6 = p6.spinner();
+  const spinner6 = p7.spinner();
   spinner6.start("Saving...");
   try {
     const config = await loadConfig(cwd2);
@@ -3650,28 +3837,28 @@ async function runTaskAdd(cwd2) {
     await db.writeFeatureList(cwd2);
     await db.close();
     spinner6.stop("");
-    console.log(pc14.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
-    console.log(pc14.cyan("\u2192") + " " + pc14.cyan("ahk status") + " to see all tasks");
+    console.log(pc15.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
+    console.log(pc15.cyan("\u2192") + " " + pc15.cyan("ahk status") + " to see all tasks");
   } catch (err) {
-    spinner6.stop(pc14.red("Failed"));
-    p6.log.error(err instanceof Error ? err.message : String(err));
+    spinner6.stop(pc15.red("Failed"));
+    p7.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }
 
 // src/commands/task/done.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync19 } from "fs";
-import { resolve as resolve10 } from "path";
-import pc15 from "picocolors";
+import { existsSync as existsSync20 } from "fs";
+import { resolve as resolve11 } from "path";
+import pc16 from "picocolors";
 async function runTaskDone(cwd2, idOrSlug) {
   const config = await loadConfig(cwd2);
   if (config.health.required) {
-    const scriptPath = resolve10(cwd2, config.health.scriptPath);
-    if (existsSync19(scriptPath)) {
+    const scriptPath = resolve11(cwd2, config.health.scriptPath);
+    if (existsSync20(scriptPath)) {
       const result = spawnSync2("bash", [scriptPath], { cwd: cwd2, stdio: "pipe", encoding: "utf8" });
       if (result.status !== 0) {
-        console.error(pc15.red("\u2717 Health check failed \u2014 cannot mark task as done."));
+        console.error(pc16.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);
@@ -3684,79 +3871,79 @@ async function runTaskDone(cwd2, idOrSlug) {
     const isId = !isNaN(parsed);
     const task2 = isId ? await db.getTaskById(parsed) : await db.getTaskBySlug(idOrSlug);
     if (!task2) {
-      console.error(pc15.red(`Task not found: ${idOrSlug}`));
+      console.error(pc16.red(`Task not found: ${idOrSlug}`));
       process.exit(1);
     }
     if (task2.status === "done") {
-      console.log(pc15.dim(`Task #${task2.id} is already done.`));
+      console.log(pc16.dim(`Task #${task2.id} is already done.`));
       return;
     }
     await db.updateTaskStatus(task2.id, "done");
     await db.writeFeatureList(cwd2);
-    console.log(pc15.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
+    console.log(pc16.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
   } finally {
     await db.close();
   }
 }
 
 // src/commands/task/edit.ts
-import * as p7 from "@clack/prompts";
-import pc16 from "picocolors";
+import * as p8 from "@clack/prompts";
+import pc17 from "picocolors";
 async function runTaskEdit(cwd2) {
-  p7.intro(pc16.bold("agent-harness-kit \u2014 edit task"));
+  p8.intro(pc17.bold("agent-harness-kit \u2014 edit task"));
   const config = await loadConfig(cwd2);
   const db = await openDB(config, cwd2);
   try {
     const allTasks = await db.getTasks();
     const activeTasks = allTasks.filter((t) => t.status !== "done");
     if (activeTasks.length === 0) {
-      p7.log.error("No active tasks to edit.");
+      p8.log.error("No active tasks to edit.");
       return;
     }
-    const taskId = await p7.select({
+    const taskId = await p8.select({
       message: "Select a task to edit",
       options: activeTasks.map((t) => ({
         label: `#${t.id} \u2014 ${t.title} (${t.slug})`,
         value: t.id
       }))
     });
-    if (p7.isCancel(taskId)) {
-      p7.cancel("Cancelled.");
+    if (p8.isCancel(taskId)) {
+      p8.cancel("Cancelled.");
       process.exit(0);
     }
     const task2 = await db.getTaskById(taskId);
     if (!task2) {
-      p7.log.error("Task not found");
+      p8.log.error("Task not found");
       process.exit(1);
     }
-    const title = await p7.text({
+    const title = await p8.text({
       message: "Title",
       initialValue: task2.title
     });
-    if (p7.isCancel(title)) {
-      p7.cancel("Cancelled.");
+    if (p8.isCancel(title)) {
+      p8.cancel("Cancelled.");
       process.exit(0);
     }
-    const description = await p7.text({
+    const description = await p8.text({
       message: "Description (what and why)",
       initialValue: task2.description ?? ""
     });
-    if (p7.isCancel(description)) {
-      p7.cancel("Cancelled.");
+    if (p8.isCancel(description)) {
+      p8.cancel("Cancelled.");
       process.exit(0);
     }
     const currentAcceptance = await db.getTaskAcceptance(task2.id);
     const newAcceptance = [];
-    p7.log.info("Acceptance criteria \u2014 edit each, empty to delete. Add new ones at the end.");
+    p8.log.info("Acceptance criteria \u2014 edit each, empty to delete. Add new ones at the end.");
     for (let i = 0; i < currentAcceptance.length; i++) {
       const ac = currentAcceptance[i];
-      const val = await p7.text({
+      const val = await p8.text({
         message: `#${i + 1}/${currentAcceptance.length}`,
         initialValue: ac.criterion,
         defaultValue: ""
       });
-      if (p7.isCancel(val)) {
-        p7.cancel("Cancelled.");
+      if (p8.isCancel(val)) {
+        p8.cancel("Cancelled.");
         process.exit(0);
       }
       const trimmed = val.trim();
@@ -3765,11 +3952,11 @@ async function runTaskEdit(cwd2) {
       }
     }
     while (true) {
-      const val = await p7.text({ message: "New acceptance criterion", placeholder: "(press Enter to finish)" });
-      if (p7.isCancel(val) || !val || !val.trim()) break;
+      const val = await p8.text({ message: "New acceptance criterion", placeholder: "(press Enter to finish)" });
+      if (p8.isCancel(val) || !val || !val.trim()) break;
       newAcceptance.push(val.trim());
     }
-    const spinner6 = p7.spinner();
+    const spinner6 = p8.spinner();
     spinner6.start("Saving...");
     try {
       const newSlug = slugify(title);
@@ -3781,10 +3968,10 @@ async function runTaskEdit(cwd2) {
       await db.updateTaskAcceptance(task2.id, newAcceptance);
       await db.writeFeatureList(cwd2);
       spinner6.stop("");
-      console.log(pc16.green(`\u2713 Task #${task2.id} updated \u2014 ${newSlug}`));
+      console.log(pc17.green(`\u2713 Task #${task2.id} updated \u2014 ${newSlug}`));
     } catch (err) {
-      spinner6.stop(pc16.red("Failed"));
-      p7.log.error(err instanceof Error ? err.message : String(err));
+      spinner6.stop(pc17.red("Failed"));
+      p8.log.error(err instanceof Error ? err.message : String(err));
       process.exit(1);
     }
   } finally {
@@ -3794,12 +3981,12 @@ async function runTaskEdit(cwd2) {
 
 // src/commands/task/list.ts
 import Table2 from "cli-table3";
-import pc17 from "picocolors";
+import pc18 from "picocolors";
 var STATUS_COLOR2 = {
-  pending: (s) => pc17.dim(s),
-  in_progress: (s) => pc17.cyan(s),
-  done: (s) => pc17.green(s),
-  blocked: (s) => pc17.red(s)
+  pending: (s) => pc18.dim(s),
+  in_progress: (s) => pc18.cyan(s),
+  done: (s) => pc18.green(s),
+  blocked: (s) => pc18.red(s)
 };
 async function runTaskList(cwd2, opts) {
   const config = await loadConfig(cwd2);
@@ -3816,11 +4003,11 @@ async function runTaskList(cwd2, opts) {
       let msg = "No tasks";
       if (filterStatus) msg += ` with status: ${filterStatus}`;
       if (opts.archived) msg += " (archived)";
-      console.log(pc17.dim(msg + "."));
+      console.log(pc18.dim(msg + "."));
       return;
     }
     const table = new Table2({
-      head: ["ID", "Slug", "Title", "Status"].map((h) => pc17.bold(h)),
+      head: ["ID", "Slug", "Title", "Status"].map((h) => pc18.bold(h)),
       style: { head: [], border: [] }
     });
     for (const t of tasks) {
@@ -3831,7 +4018,7 @@ async function runTaskList(cwd2, opts) {
     if (!opts.archived && !opts.includeArchived) {
       const archivedTasks = await db.getArchivedTasks();
       if (archivedTasks.length > 0) {
-        console.log(pc17.dim(`${archivedTasks.length} archived task${archivedTasks.length !== 1 ? "s" : ""} (use --archived to view)`));
+        console.log(pc18.dim(`${archivedTasks.length} archived task${archivedTasks.length !== 1 ? "s" : ""} (use --archived to view)`));
       }
     }
   } finally {
@@ -3841,8 +4028,8 @@ async function runTaskList(cwd2, opts) {
 
 // src/core/path-probe.ts
 import { accessSync, constants, readdirSync as readdirSync3 } from "fs";
-import { join as join21 } from "path";
-import pc18 from "picocolors";
+import { join as join23 } from "path";
+import pc19 from "picocolors";
 var DEFAULT_PATHEXT = [".COM", ".EXE", ".BAT", ".CMD"];
 function defaultIsExecutable(filePath) {
   try {
@@ -3886,7 +4073,7 @@ function resolveOnPath(name, options = {}) {
   }
   for (const dir of dirs) {
     try {
-      if (isExecutable(join21(dir, name))) return true;
+      if (isExecutable(join23(dir, name))) return true;
     } catch {
       continue;
     }
@@ -3897,35 +4084,35 @@ function isExecutableOnPath(name) {
   return resolveOnPath(name);
 }
 function printMissingGlobalBinaryWarning() {
-  console.error(pc18.yellow("\u26A0 `ahk` was not found on your PATH."));
-  console.error(pc18.dim("  Your project has no local install, so the generated MCP config launches"));
-  console.error(pc18.dim("  `ahk serve` directly. Without `ahk` on your PATH, starting the MCP server"));
-  console.error(pc18.dim("  from that config will fail. This is only a warning \u2014 the command continues."));
-  console.error(pc18.dim(`  Run: npm i -g ${pkg.name}   (install globally)`));
-  console.error(pc18.dim(`  or:  npm install --save-dev ${pkg.name}   (install locally in this project)`));
+  console.error(pc19.yellow("\u26A0 `ahk` was not found on your PATH."));
+  console.error(pc19.dim("  Your project has no local install, so the generated MCP config launches"));
+  console.error(pc19.dim("  `ahk serve` directly. Without `ahk` on your PATH, starting the MCP server"));
+  console.error(pc19.dim("  from that config will fail. This is only a warning \u2014 the command continues."));
+  console.error(pc19.dim(`  Run: npm i -g ${pkg.name}   (install globally)`));
+  console.error(pc19.dim(`  or:  npm install --save-dev ${pkg.name}   (install locally in this project)`));
 }
 
 // src/core/update-check.ts
-import pc19 from "picocolors";
+import pc20 from "picocolors";
 var REGISTRY_URL2 = `https://registry.npmjs.org/${pkg.name}/latest`;
 var TIMEOUT_MS2 = 2500;
 function checkForUpdate(currentVersion) {
-  return new Promise((resolve11) => {
-    const timer = setTimeout(() => resolve11(null), TIMEOUT_MS2);
+  return new Promise((resolve12) => {
+    const timer = setTimeout(() => resolve12(null), TIMEOUT_MS2);
     fetch(REGISTRY_URL2).then((res) => res.json()).then((data) => {
       clearTimeout(timer);
       const latest = data.version;
-      resolve11(isNewer2(latest, currentVersion) ? { current: currentVersion, latest } : null);
+      resolve12(isNewer2(latest, currentVersion) ? { current: currentVersion, latest } : null);
     }).catch(() => {
       clearTimeout(timer);
-      resolve11(null);
+      resolve12(null);
     });
   });
 }
 function printUpdateMessage({ current, latest }) {
   const lines = [
-    `  Update available ${pc19.dim(current)} \u2192 ${pc19.green(latest)}  `,
-    `  Run: ${pc19.cyan(`pnpm i ${pkg.name}@${latest}`)}          `
+    `  Update available ${pc20.dim(current)} \u2192 ${pc20.green(latest)}  `,
+    `  Run: ${pc20.cyan(`pnpm i ${pkg.name}@${latest}`)}          `
   ];
   drawBox(lines);
 }
@@ -3955,7 +4142,7 @@ function parsePort(raw) {
 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)").option("--storage-scope <scope>", "Storage scope: local | global (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 | codex-cli | grok-cli (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").option(
@@ -3993,7 +4180,7 @@ program.command("dashboard").description("Open web dashboard to visualize harnes
   await runDashboard(cwd, { port: opts.port, open: opts.open });
 });
 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) => {
+migrate.command("provider").description("Migrate provider-specific files to a different provider").option("--to <provider>", "Target provider: claude-code | opencode | codex-cli | grok-cli").action(async (opts) => {
   await runMigrate(cwd, opts);
 });
 migrate.command("storage").description(
@@ -4002,19 +4189,22 @@ migrate.command("storage").description(
   try {
     await runMigrateStorage(cwd, { force: opts.force, dryRun: opts["dry-run"] });
   } catch (err) {
-    console.error(pc20.red(`\u2717 ${err instanceof Error ? err.message : String(err)}`));
+    console.error(pc21.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);
 });
-program.command("reset").description("Reset/clear harness data (DB, feature list, agent files)").option("--force", "Skip confirmation prompts").option("--provider <claude-code|opencode>", "Reset agent MD files for specified provider").action(async (opts) => {
+program.command("reset").description("Reset/clear harness data (DB, feature list, agent files)").option("--force", "Skip confirmation prompts").option("--provider <claude-code|opencode|codex-cli|grok-cli>", "Reset agent MD files for specified provider").action(async (opts) => {
   await runReset(cwd, opts);
 });
 program.command("doctor").description("Check lib version, agent files, and harness skills sync status").action(async () => {
   await runDoctor(cwd);
 });
+program.command("models").description("Re-prompt per-role Claude Code models and regenerate .claude/agents/*.md (claude-code projects only)").action(async () => {
+  await runModels(cwd);
+});
 program.hook("preAction", () => {
   if (!isLocalInstallSatisfied(cwd)) {
     printLocalInstallWarning();