@cardor/agent-harness-kit 1.1.7 → 1.2.0

package/dist/cli.js

@@ -11,23 +11,25 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 
 // src/core/materializer/claude-code.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
+
+// src/utils/file.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+var write = (cwd2, relPath, content, mode) => {
+  const abs = join(cwd2, relPath);
+  mkdirSync(resolve(abs, ".."), { recursive: true });
+  writeFileSync(abs, content, { encoding: "utf8", mode });
+};
 
 // src/core/materializer/mcp-merge.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
-var compactionConfig = {
-  compaction: {
-    auto: true,
-    prune: true,
-    reserved: 1e4
-  }
-};
 function mergeClaudeMcpJson(filePath, port) {
   const folderPath = dirname(filePath);
   if (!existsSync(folderPath)) {
-    mkdirSync(folderPath, { recursive: true });
+    mkdirSync2(folderPath, { recursive: true });
   }
   let existing = {};
   if (existsSync(filePath)) {
@@ -36,27 +38,39 @@ function mergeClaudeMcpJson(filePath, port) {
     } catch {
     }
   }
-  const agentHarnessKitConfig = {
-    type: "stdio",
-    command: "npx",
-    args: ["ahk", "serve", "--port", String(port)]
-  };
   const merged = {
     ...existing,
-    compaction: existing.compaction ?? compactionConfig.compaction,
-    default_agent: "lead",
     mcpServers: {
       ...existing.mcpServers ?? {},
-      "agent-harness-kit": agentHarnessKitConfig
+      "agent-harness-kit": {
+        type: "stdio",
+        command: "npx",
+        args: ["ahk", "serve", "--port", String(port)]
+      }
+    }
+  };
+  mkdirSync2(dirname(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+function mergeClaudeSettingsJson(filePath) {
+  mkdirSync2(dirname(filePath), { recursive: true });
+  let existing = {};
+  if (existsSync(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf8"));
+    } catch {
     }
+  }
+  const merged = {
+    ...existing,
+    agent: "lead"
   };
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  writeFileSync2(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
 }
 function mergeOpencodeJson(filePath, port) {
   const folderPath = dirname(filePath);
   if (!existsSync(folderPath)) {
-    mkdirSync(folderPath, { recursive: true });
+    mkdirSync2(folderPath, { recursive: true });
   }
   let existing = {};
   if (existsSync(filePath)) {
@@ -66,35 +80,73 @@ function mergeOpencodeJson(filePath, port) {
     }
   }
   const existingMcp = existing.mcp ?? {};
-  const agentHarnessKitConfig = {
-    enabled: true,
-    type: "local",
-    command: ["npx", "ahk", "serve", "--port", String(port)]
-  };
   const merged = {
     ...existing,
-    compaction: existing.compaction ?? compactionConfig.compaction,
     default_agent: "lead",
+    compaction: existing.compaction ?? { auto: true, prune: true, reserved: 1e4 },
+    permission: existing.permission ?? { write: "ask" },
     mcp: {
       ...existingMcp,
-      "agent-harness-kit": agentHarnessKitConfig
+      "agent-harness-kit": {
+        enabled: true,
+        type: "local",
+        command: ["npx", "ahk", "serve", "--port", String(port)]
+      }
     }
   };
-  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  writeFileSync2(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+function mergeTomlSection(content, sectionName, sectionBody) {
+  const lines = content.split("\n");
+  const header = `[${sectionName}]`;
+  const startIdx = lines.findIndex((l) => l.trim() === header);
+  if (startIdx === -1) {
+    const trimmed = content.trimEnd();
+    return trimmed + (trimmed ? "\n\n" : "") + header + "\n" + sectionBody.trimEnd() + "\n";
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^\[/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  const newLines = [
+    ...lines.slice(0, startIdx),
+    header,
+    ...sectionBody.trimEnd().split("\n"),
+    "",
+    ...lines.slice(endIdx)
+  ];
+  return newLines.join("\n");
+}
+function mergeCodexConfigToml(filePath, port) {
+  mkdirSync2(dirname(filePath), { recursive: true });
+  let content = "";
+  if (existsSync(filePath)) {
+    content = readFileSync(filePath, "utf8");
+  }
+  const sectionBody = [
+    'command = "npx"',
+    `args = ["ahk", "serve", "--port", "${port}"]`,
+    'default_tools_approval_mode = "auto"'
+  ].join("\n");
+  content = mergeTomlSection(content, "mcp_servers.agent-harness-kit", sectionBody);
+  writeFileSync2(filePath, content, "utf8");
 }
 
 // src/core/materializer/scaffold-utils.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
 
 // src/core/materializer/templates.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var TEMPLATES_DIR = join(__dirname, "agent-templates");
+var TEMPLATES_DIR = join2(__dirname, "agent-templates");
 function loadAgentTemplate(name, vars = {}) {
-  const raw = readFileSync2(join(TEMPLATES_DIR, `${name}.md`), "utf8");
+  const raw = readFileSync2(join2(TEMPLATES_DIR, `${name}.md`), "utf8");
   return raw.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
 }
 var HEALTH_SH = `#!/usr/bin/env bash
@@ -349,6 +401,55 @@ function agentReviewer(vars) {
 function featureListJson(tasks) {
   return JSON.stringify(tasks, null, 2) + "\n";
 }
+function stripFrontmatter(md) {
+  const parts = md.split(/^---\s*$/m);
+  if (parts.length < 3) return { description: "", body: md };
+  const frontmatter = parts[1];
+  const body = parts.slice(2).join("---").replace(/^\n/, "");
+  let description = "";
+  const foldedMatch = frontmatter.match(/^description:\s*[>|]\s*\n((?:[ \t]+[^\n]*\n?)*)/m);
+  if (foldedMatch) {
+    description = foldedMatch[1].split("\n").map((l) => l.trim()).filter(Boolean).join(" ");
+  } else {
+    const inlineMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    if (inlineMatch) description = inlineMatch[1].trim();
+  }
+  return { description, body };
+}
+function toCodexToml(name, description, body, sandboxMode) {
+  const safe = (s) => s.replace(/"""/g, '""\\u0022');
+  return `name = "${name}"
+sandbox_mode = "${sandboxMode}"
+
+description = """
+${safe(description)}
+"""
+
+developer_instructions = """
+${safe(body.trimEnd())}
+"""
+`;
+}
+function agentLeadToml(vars) {
+  const { description, body } = stripFrontmatter(loadAgentTemplate("lead", vars));
+  return toCodexToml("lead", description, body, "read-only");
+}
+function agentLeadAsDefaultToml(vars) {
+  const { description, body } = stripFrontmatter(loadAgentTemplate("lead", vars));
+  return toCodexToml("default", description, body, "read-only");
+}
+function agentExplorerToml(vars) {
+  const { description, body } = stripFrontmatter(loadAgentTemplate("explorer", vars));
+  return toCodexToml("explorer", description, body, "read-only");
+}
+function agentBuilderToml(vars) {
+  const { description, body } = stripFrontmatter(loadAgentTemplate("builder", vars));
+  return toCodexToml("builder", description, body, "workspace-write");
+}
+function agentReviewerToml(vars) {
+  const { description, body } = stripFrontmatter(loadAgentTemplate("reviewer", vars));
+  return toCodexToml("reviewer", description, body, "read-only");
+}
 var GITIGNORE_ENTRIES = `
 # agent-harness-kit
 .harness/harness.db
@@ -359,17 +460,17 @@ var GITIGNORE_ENTRIES = `
 
 // src/core/materializer/scaffold-utils.ts
 function writeAgentFile(cwd2, relPath, content) {
-  const abs = join2(cwd2, relPath);
+  const abs = join3(cwd2, relPath);
   if (existsSync2(abs)) return;
-  mkdirSync2(resolve(abs, ".."), { recursive: true });
-  writeFileSync2(abs, content, "utf8");
+  mkdirSync3(resolve2(abs, ".."), { recursive: true });
+  writeFileSync3(abs, content, "utf8");
 }
 function appendGitignore(cwd2) {
-  const giPath = join2(cwd2, ".gitignore");
+  const giPath = join3(cwd2, ".gitignore");
   const existing = existsSync2(giPath) ? readFileSync3(giPath, "utf8") : "";
   const toAdd = GITIGNORE_ENTRIES.split("\n").filter((line) => line && !existing.includes(line)).join("\n");
   if (toAdd.trim()) {
-    writeFileSync2(giPath, existing + (existing.endsWith("\n") ? "" : "\n") + toAdd + "\n", "utf8");
+    writeFileSync3(giPath, existing + (existing.endsWith("\n") ? "" : "\n") + toAdd + "\n", "utf8");
   }
 }
 function slugify(title) {
@@ -380,20 +481,16 @@ function slugify(title) {
 var ClaudeCodeMaterializer = class {
   async scaffold(config, opts) {
     const { cwd: cwd2 } = opts;
-    const write = (relPath, content, mode) => {
-      const abs = join3(cwd2, relPath);
-      mkdirSync3(resolve2(abs, ".."), { recursive: true });
-      writeFileSync3(abs, content, { encoding: "utf8", mode });
-    };
-    write("AGENTS.md", agentsMd(config));
-    write("CLAUDE.md", claudeMd(config));
-    if (!existsSync3(join3(cwd2, "health.sh"))) {
-      write("health.sh", HEALTH_SH, 493);
+    write(cwd2, "AGENTS.md", agentsMd(config));
+    write(cwd2, "CLAUDE.md", claudeMd(config));
+    if (!existsSync3(join4(cwd2, "health.sh"))) {
+      write(cwd2, "health.sh", HEALTH_SH, 493);
     }
     const tasks = opts.firstTask ? [{ slug: slugify(opts.firstTask.title), ...opts.firstTask }] : [];
-    write(join3(config.storage.dir, "feature_list.json"), featureListJson(tasks));
-    if (!existsSync3(join3(cwd2, config.storage.markdownFallback.path))) {
+    write(cwd2, "feature_list.json", featureListJson(tasks));
+    if (!existsSync3(join4(cwd2, config.storage.markdownFallback.path))) {
       write(
+        cwd2,
         config.storage.markdownFallback.path,
         `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
 <!-- Run ahk status to refresh -->
@@ -411,17 +508,18 @@ No tasks in progress.
     writeAgentFile(cwd2, ".claude/agents/explorer.md", agentExplorer({ projectName, allowedPaths }));
     writeAgentFile(cwd2, ".claude/agents/builder.md", agentBuilder({ projectName, writablePaths }));
     writeAgentFile(cwd2, ".claude/agents/reviewer.md", agentReviewer({ projectName }));
-    mergeClaudeMcpJson(join3(cwd2, ".claude/mcp.json"), config.tools.mcp.port);
+    mergeClaudeMcpJson(join4(cwd2, ".claude/mcp.json"), config.tools.mcp.port);
+    mergeClaudeSettingsJson(join4(cwd2, ".claude/settings.json"));
     appendGitignore(cwd2);
   }
   async build(config, cwd2) {
-    const write = (relPath, content) => {
-      const abs = join3(cwd2, relPath);
-      mkdirSync3(resolve2(abs, ".."), { recursive: true });
-      writeFileSync3(abs, content, "utf8");
+    const write2 = (relPath, content) => {
+      const abs = join4(cwd2, relPath);
+      mkdirSync4(resolve3(abs, ".."), { recursive: true });
+      writeFileSync4(abs, content, "utf8");
     };
-    write("AGENTS.md", agentsMd(config));
-    write("CLAUDE.md", claudeMd(config));
+    write2("AGENTS.md", agentsMd(config));
+    write2("CLAUDE.md", claudeMd(config));
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
@@ -429,7 +527,70 @@ No tasks in progress.
     writeAgentFile(cwd2, ".claude/agents/explorer.md", agentExplorer({ projectName, allowedPaths }));
     writeAgentFile(cwd2, ".claude/agents/builder.md", agentBuilder({ projectName, writablePaths }));
     writeAgentFile(cwd2, ".claude/agents/reviewer.md", agentReviewer({ projectName }));
-    mergeClaudeMcpJson(join3(cwd2, ".claude/mcp.json"), config.tools.mcp.port);
+    mergeClaudeMcpJson(join4(cwd2, ".claude/mcp.json"), config.tools.mcp.port);
+    mergeClaudeSettingsJson(join4(cwd2, ".claude/settings.json"));
+  }
+  async migrate(config, _to, _cwd) {
+    void config;
+  }
+};
+
+// 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";
+var CodexCliMaterializer = class {
+  async scaffold(config, opts) {
+    const { cwd: cwd2 } = opts;
+    const write2 = (relPath, content, mode) => {
+      const abs = join5(cwd2, relPath);
+      mkdirSync5(resolve4(abs, ".."), { recursive: true });
+      writeFileSync5(abs, content, { encoding: "utf8", mode });
+    };
+    write2("AGENTS.md", agentsMd(config));
+    if (!existsSync4(join5(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(
+        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.
+`
+      );
+    }
+    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/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);
+    appendGitignore(cwd2);
+  }
+  async build(config, cwd2) {
+    const write2 = (relPath, content) => {
+      const abs = join5(cwd2, relPath);
+      mkdirSync5(resolve4(abs, ".."), { recursive: true });
+      writeFileSync5(abs, content, "utf8");
+    };
+    write2("AGENTS.md", agentsMd(config));
+    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/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);
   }
   async migrate(config, _to, _cwd) {
     void config;
@@ -437,24 +598,24 @@ No tasks in progress.
 };
 
 // src/core/materializer/opencode.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
 var OpenCodeMaterializer = class {
   async scaffold(config, opts) {
     const { cwd: cwd2 } = opts;
-    const write = (relPath, content, mode) => {
-      const abs = join4(cwd2, relPath);
-      mkdirSync4(resolve3(abs, ".."), { recursive: true });
-      writeFileSync4(abs, content, { encoding: "utf8", mode });
+    const write2 = (relPath, content, mode) => {
+      const abs = join6(cwd2, relPath);
+      mkdirSync6(resolve5(abs, ".."), { recursive: true });
+      writeFileSync6(abs, content, { encoding: "utf8", mode });
     };
-    write("AGENTS.md", agentsMd(config));
-    if (!existsSync4(join4(cwd2, "health.sh"))) {
-      write("health.sh", HEALTH_SH, 493);
+    write2("AGENTS.md", agentsMd(config));
+    if (!existsSync5(join6(cwd2, "health.sh"))) {
+      write2("health.sh", HEALTH_SH, 493);
     }
     const tasks = opts.firstTask ? [{ slug: slugify(opts.firstTask.title), ...opts.firstTask }] : [];
-    write(join4(config.storage.dir, "feature_list.json"), featureListJson(tasks));
-    if (!existsSync4(join4(cwd2, config.storage.markdownFallback.path))) {
-      write(
+    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 -->
 <!-- Run ahk status to refresh -->
@@ -472,16 +633,16 @@ No tasks in progress.
     writeAgentFile(cwd2, ".opencode/agents/explorer.md", agentExplorer({ projectName, allowedPaths }));
     writeAgentFile(cwd2, ".opencode/agents/builder.md", agentBuilder({ projectName, writablePaths }));
     writeAgentFile(cwd2, ".opencode/agents/reviewer.md", agentReviewer({ projectName }));
-    mergeOpencodeJson(join4(cwd2, "opencode.json"), config.tools.mcp.port);
+    mergeOpencodeJson(join6(cwd2, "opencode.json"), config.tools.mcp.port);
     appendGitignore(cwd2);
   }
   async build(config, cwd2) {
-    const write = (relPath, content) => {
-      const abs = join4(cwd2, relPath);
-      mkdirSync4(resolve3(abs, ".."), { recursive: true });
-      writeFileSync4(abs, content, "utf8");
+    const write2 = (relPath, content) => {
+      const abs = join6(cwd2, relPath);
+      mkdirSync6(resolve5(abs, ".."), { recursive: true });
+      writeFileSync6(abs, content, "utf8");
     };
-    write("AGENTS.md", agentsMd(config));
+    write2("AGENTS.md", agentsMd(config));
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
@@ -489,7 +650,7 @@ No tasks in progress.
     writeAgentFile(cwd2, ".opencode/agents/explorer.md", agentExplorer({ projectName, allowedPaths }));
     writeAgentFile(cwd2, ".opencode/agents/builder.md", agentBuilder({ projectName, writablePaths }));
     writeAgentFile(cwd2, ".opencode/agents/reviewer.md", agentReviewer({ projectName }));
-    mergeOpencodeJson(join4(cwd2, "opencode.json"), config.tools.mcp.port);
+    mergeOpencodeJson(join6(cwd2, "opencode.json"), config.tools.mcp.port);
   }
   async migrate(config, _to, _cwd) {
     void config;
@@ -503,6 +664,8 @@ function getMaterializer(provider) {
       return new ClaudeCodeMaterializer();
     case "opencode":
       return new OpenCodeMaterializer();
+    case "codex-cli":
+      return new CodexCliMaterializer();
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
@@ -543,14 +706,14 @@ async function buildOnce(cwd2) {
 }
 
 // src/commands/dashboard.ts
-import { dirname as dirname4, join as join7, resolve as resolve5 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import pc2 from "picocolors";
 
 // src/core/dashboard-server.ts
 import { watch as watch2 } from "fs";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { extname, join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { extname, join as join7 } from "path";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { WebSocketServer } from "ws";
@@ -628,15 +791,15 @@ function startDashboardServer(db, dbPath, staticPath, port) {
   app.get("/*", (c) => {
     const urlPath = c.req.path;
     if (urlPath !== "/") {
-      const candidate = join5(staticPath, urlPath);
-      if (existsSync5(candidate)) {
+      const candidate = join7(staticPath, urlPath);
+      if (existsSync6(candidate)) {
         try {
           return fileResponse(candidate);
         } catch {
         }
       }
     }
-    return fileResponse(join5(staticPath, "index.html"));
+    return fileResponse(join7(staticPath, "index.html"));
   });
   const httpServer = serve({ fetch: app.fetch, port });
   const wss = new WebSocketServer({ noServer: true });
@@ -663,7 +826,7 @@ function startDashboardServer(db, dbPath, staticPath, port) {
   let watcher = null;
   if (dbPath) {
     const walPath = `${dbPath}-wal`;
-    const watchTarget = existsSync5(walPath) ? walPath : dbPath;
+    const watchTarget = existsSync6(walPath) ? walPath : dbPath;
     watcher = watch2(watchTarget, broadcast);
   }
   return {
@@ -679,8 +842,8 @@ function startDashboardServer(db, dbPath, staticPath, port) {
 
 // src/core/db.ts
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3, join as join6, resolve as resolve4 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname3, join as join8, resolve as resolve6 } from "path";
 
 // src/core/repositories/ActionRepository.ts
 var ActionRepository = class {
@@ -1081,8 +1244,8 @@ var HarnessDB = class {
   // ─── current.md fallback ──────────────────────────────────────────────────
   async regenerateCurrentMd() {
     if (!this.config.storage.markdownFallback.enabled) return;
-    const mdPath = resolve4(this.config.storage.markdownFallback.path);
-    mkdirSync5(dirname3(mdPath), { recursive: true });
+    const mdPath = resolve6(this.config.storage.markdownFallback.path);
+    mkdirSync7(dirname3(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 -->
@@ -1149,7 +1312,7 @@ var HarnessDB = class {
         }
       }
     }
-    writeFileSync5(mdPath, md, "utf8");
+    writeFileSync7(mdPath, md, "utf8");
   }
   // ─── Raw query escape hatch ───────────────────────────────────────────────
   async queryRaw(sql, ...params) {
@@ -1191,9 +1354,9 @@ var HarnessDB = class {
         status: t.status
       }))
     );
-    const path = join6(resolve4(cwd2), this.config.storage.dir, "feature_list.json");
-    mkdirSync5(dirname3(path), { recursive: true });
-    writeFileSync5(path, JSON.stringify(list, null, 2) + "\n", "utf8");
+    const path = join8(resolve6(cwd2), this.config.storage.dir, "feature_list.json");
+    mkdirSync7(dirname3(path), { recursive: true });
+    writeFileSync7(path, JSON.stringify(list, null, 2) + "\n", "utf8");
   }
 };
 async function openDB(config, cwd2) {
@@ -1210,7 +1373,7 @@ async function openDB(config, cwd2) {
     if (dbConfig.type !== "sqlite") {
       throw new Error("Invalid database type");
     }
-    driver = new SQLiteDriver(resolve4(cwd2, dbConfig.path));
+    driver = new SQLiteDriver(resolve6(cwd2, dbConfig.path));
   }
   await driver.ensureSchema();
   return new HarnessDB(driver, config);
@@ -1221,8 +1384,8 @@ var __dirname2 = dirname4(fileURLToPath2(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" ? resolve5(cwd2, config.database.path) : null;
-  const staticPath = join7(__dirname2, "dashboard-dist");
+  const dbPath = config.database.type === "sqlite" ? resolve7(cwd2, config.database.path) : null;
+  const staticPath = join9(__dirname2, "dashboard-dist");
   const { url } = startDashboardServer(db, dbPath, staticPath, opts.port);
   console.log(pc2.green(`\u2713`) + ` Dashboard running at ${pc2.bold(pc2.cyan(url))}`);
   console.log(pc2.dim(`  WebSocket live updates enabled`));
@@ -1239,7 +1402,7 @@ async function runDashboard(cwd2, opts) {
 }
 
 // src/commands/export.ts
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync8 } from "fs";
 import pc3 from "picocolors";
 async function runExport(cwd2, opts) {
   if (!opts.sql && !opts.json) {
@@ -1253,7 +1416,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");
+        writeFileSync8(opts.output, out, "utf8");
         console.log(pc3.green(`\u2713 Exported JSON \u2192 ${opts.output}`));
       } else {
         process.stdout.write(out);
@@ -1270,8 +1433,8 @@ async function runExport(cwd2, opts) {
 
 // src/commands/health.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { join as join8, resolve as resolve6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join10, resolve as resolve8 } from "path";
 import pc4 from "picocolors";
 function checkLine(label, ok2, message, indent = 0) {
   const prefix = label ? pc4.cyan(`[${label}] `) : " ".repeat(indent);
@@ -1289,8 +1452,8 @@ async function runHealth(cwd2) {
   let allOk = true;
   let dbOk;
   if (config.database.type === "sqlite") {
-    const dbPath = resolve6(cwd2, config.database.path);
-    dbOk = existsSync6(dbPath);
+    const dbPath = resolve8(cwd2, config.database.path);
+    dbOk = existsSync7(dbPath);
     checkLine("checking DB", dbOk, `${config.database.path} reachable`);
   } else {
     dbOk = true;
@@ -1302,15 +1465,15 @@ async function runHealth(cwd2) {
   const agentsLabelWidth = "[checking agents] ".length;
   for (let i = 0; i < agentNames.length; i++) {
     const name = agentNames[i];
-    const agentPath = join8(cwd2, agentsDir, `${name}.md`);
-    const ok2 = existsSync6(agentPath);
+    const agentPath = join10(cwd2, agentsDir, `${name}.md`);
+    const ok2 = existsSync7(agentPath);
     checkLine(i === 0 ? "checking agents" : null, ok2, `${name}.md present`, agentsLabelWidth);
     if (!ok2) allOk = false;
   }
   if (config.tools.mcp.enabled) {
     const mcpFile = config.provider === "claude-code" ? ".claude/mcp.json" : "opencode.json";
-    const mcpPath = resolve6(cwd2, mcpFile);
-    const mcpOk = existsSync6(mcpPath);
+    const mcpPath = resolve8(cwd2, mcpFile);
+    const mcpOk = existsSync7(mcpPath);
     checkLine("checking MCP", mcpOk, `${mcpFile} valid`);
     if (!mcpOk) allOk = false;
   }
@@ -1319,8 +1482,8 @@ async function runHealth(cwd2) {
     console.error(pc4.red("\u2717 Harness checks failed \u2014 fix the above before running health.sh"));
     process.exit(1);
   }
-  const scriptPath = resolve6(cwd2, config.health.scriptPath);
-  if (!existsSync6(scriptPath)) {
+  const scriptPath = resolve8(cwd2, config.health.scriptPath);
+  if (!existsSync7(scriptPath)) {
     console.error(pc4.red(`\u2717 health.sh not found: ${scriptPath}`));
     console.error("  Run ahk init first.");
     process.exit(1);
@@ -1344,9 +1507,9 @@ async function runHealth(cwd2) {
 }
 
 // src/commands/init.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
 import { homedir } from "os";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import * as p3 from "@clack/prompts";
 import pc6 from "picocolors";
 
@@ -1401,13 +1564,13 @@ var cliFormWithRetry = async (formFn, schema) => {
 };
 
 // src/commands/init-helpers.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join11 } from "path";
 import pc5 from "picocolors";
 function readProjectNameFromPackageJson(cwd2) {
   try {
-    const pkgPath2 = join9(cwd2, "package.json");
-    if (!existsSync7(pkgPath2)) return null;
+    const pkgPath2 = join11(cwd2, "package.json");
+    if (!existsSync8(pkgPath2)) return null;
     const content = readFileSync5(pkgPath2, "utf8");
     const pkg2 = JSON.parse(content);
     const name = pkg2?.name;
@@ -1498,36 +1661,30 @@ async function runInit(cwd2, flags) {
   if (flags.name) {
     name = flags.name;
   } else {
-    name = await cliFormWithRetry(
-      async () => {
-        const val = await p3.text({
-          message: "Project name",
-          placeholder: "my-app",
-          ...detectedName && { initialValue: detectedName }
-        });
-        if (p3.isCancel(val)) {
-          p3.cancel("Cancelled.");
-          process.exit(0);
-        }
-        return val;
-      },
-      initNameSchema
-    );
-  }
-  const description = await cliFormWithRetry(
-    async () => {
+    name = await cliFormWithRetry(async () => {
       const val = await p3.text({
-        message: "Short description (shown to agents as context)",
-        placeholder: "A REST API for managing notes"
+        message: "Project name",
+        placeholder: "my-app",
+        ...detectedName && { initialValue: detectedName }
       });
       if (p3.isCancel(val)) {
         p3.cancel("Cancelled.");
         process.exit(0);
       }
       return val;
-    },
-    initDescriptionSchema
-  );
+    }, initNameSchema);
+  }
+  const description = await cliFormWithRetry(async () => {
+    const val = await p3.text({
+      message: "Short description (shown to agents as context)",
+      placeholder: "A REST API for managing notes"
+    });
+    if (p3.isCancel(val)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+    return val;
+  }, initDescriptionSchema);
   let provider;
   if (flags.provider && ["claude-code", "opencode"].includes(flags.provider)) {
     provider = flags.provider;
@@ -1535,8 +1692,9 @@ async function runInit(cwd2, flags) {
     const val = await p3.select({
       message: "AI provider",
       options: [
+        { value: "opencode", label: "OpenCode" },
         { value: "claude-code", label: "Claude Code" },
-        { value: "opencode", label: "OpenCode" }
+        { value: "codex-cli", label: "Codex CLI" }
       ]
     });
     if (p3.isCancel(val)) {
@@ -1561,20 +1719,17 @@ async function runInit(cwd2, flags) {
   if (flags.docs) {
     docsPath = flags.docs;
   } else {
-    docsPath = await cliFormWithRetry(
-      async () => {
-        const val = await p3.text({
-          message: "Docs folder path (agents will search here)",
-          initialValue: "./docs"
-        });
-        if (p3.isCancel(val)) {
-          p3.cancel("Cancelled.");
-          process.exit(0);
-        }
-        return val;
-      },
-      initDocsSchema
-    );
+    docsPath = await cliFormWithRetry(async () => {
+      const val = await p3.text({
+        message: "Docs folder path (agents will search here)",
+        initialValue: "./docs"
+      });
+      if (p3.isCancel(val)) {
+        p3.cancel("Cancelled.");
+        process.exit(0);
+      }
+      return val;
+    }, initDocsSchema);
   }
   let tasksAdapter;
   if (flags.tasks && ["local", "jira", "linear"].includes(flags.tasks)) {
@@ -1594,35 +1749,29 @@ async function runInit(cwd2, flags) {
     }
     tasksAdapter = val;
   }
-  const addFirstTask = await p3.confirm({ message: "Add your first task now?", initialValue: true });
+  const addFirstTask = await p3.confirm({ message: "Add your first task now?", initialValue: false });
   if (p3.isCancel(addFirstTask)) {
     p3.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");
-          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");
-          process.exit(0);
-        }
-        return val.trim();
-      },
-      taskDescriptionSchema
-    );
+    const taskTitle = await cliFormWithRetry(async () => {
+      const val = await p3.text({ message: "Task title" });
+      if (p3.isCancel(val)) {
+        p3.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");
+        process.exit(0);
+      }
+      return val.trim();
+    }, taskDescriptionSchema);
     const acceptance = [];
     p3.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
     while (true) {
@@ -1643,9 +1792,9 @@ async function runInit(cwd2, flags) {
     let installDir = cwd2;
     if (globalInstallation) {
       if (provider === "claude-code") {
-        installDir = join10(homedir(), ".claude");
+        installDir = join12(homedir(), ".claude");
       } else {
-        installDir = join10(homedir(), ".config", "opencode");
+        installDir = join12(homedir(), ".config", "opencode");
       }
     }
     const configContent = configTs({
@@ -1656,8 +1805,8 @@ async function runInit(cwd2, flags) {
       tasksAdapter,
       port: config.tools.mcp.port
     });
-    writeFileSync7(join10(installDir, "agent-harness-kit.config.ts"), configContent, "utf8");
-    mkdirSync6(join10(installDir, config.storage.dir), { recursive: true });
+    writeFileSync9(join12(installDir, "agent-harness-kit.config.ts"), configContent, "utf8");
+    mkdirSync8(join12(installDir, config.storage.dir), { recursive: true });
     const db = await openDB(config, installDir);
     await materializer.scaffold(config, { cwd: installDir, firstTask });
     if (firstTask) {
@@ -1695,7 +1844,9 @@ async function runInit(cwd2, flags) {
   console.log("");
   console.log(pc6.cyan("\u2192") + ` Edit ${pc6.cyan("health.sh")} with your project checks`);
   console.log(pc6.cyan("\u2192") + ` ${pc6.cyan("ahk task add")} to queue work for agents`);
-  console.log(pc6.cyan("\u2192") + ` Enrich your docs with knowledge graphs: ${pc6.cyan("https://github.com/safishamsi/graphify")}`);
+  console.log(
+    pc6.cyan("\u2192") + ` Enrich your docs with knowledge graphs: ${pc6.cyan("https://github.com/safishamsi/graphify")}`
+  );
   const recommendations = [
     `   Give a try to Heimdall MCP: Transparent proxy that traces every MCP tool call with OpenTelemetry.  `,
     `   Learn more: ${pc6.cyan("https://github.com/enmanuelmag/heimdall-mcp")}                              `
@@ -1746,15 +1897,15 @@ async function runMigrate(cwd2, opts) {
 }
 
 // src/commands/reset.ts
-import { existsSync as existsSync8, readdirSync, rmSync } from "fs";
-import { join as join11, resolve as resolve7 } from "path";
+import { existsSync as existsSync9, readdirSync, rmSync } from "fs";
+import { join as join13, resolve as resolve9 } from "path";
 import * as p5 from "@clack/prompts";
 import pc8 from "picocolors";
 var AGENT_MD_FILES = ["lead", "explorer", "builder", "reviewer"];
 async function resetAgentMds(cwd2, provider) {
   const agentDir = provider === "claude-code" ? ".claude/agents" : ".opencode/agents";
-  const agentDirPath = resolve7(cwd2, agentDir);
-  if (!existsSync8(agentDirPath)) {
+  const agentDirPath = resolve9(cwd2, agentDir);
+  if (!existsSync9(agentDirPath)) {
     console.log(pc8.yellow(`  Skipping agent files \u2014 directory not found: ${agentDirPath}`));
     return;
   }
@@ -1785,7 +1936,7 @@ async function resetAgentMds(cwd2, provider) {
     }
     if (confirm3) {
       try {
-        const filePath = join11(agentDirPath, file);
+        const filePath = join13(agentDirPath, file);
         rmSync(filePath, { force: true });
         console.log(pc8.green(`  Removed ${file}`));
       } catch {
@@ -1805,12 +1956,12 @@ async function runReset(cwd2, opts) {
     process.exit(1);
   }
   const storageDir = config.storage.dir || ".harness";
-  const dbPath = config.database.type === "sqlite" ? resolve7(cwd2, config.database.path) : null;
-  const featureListPath = resolve7(cwd2, storageDir, "feature_list.json");
+  const dbPath = config.database.type === "sqlite" ? resolve9(cwd2, config.database.path) : null;
+  const featureListPath = resolve9(cwd2, storageDir, "feature_list.json");
   let resetDb = false;
   let resetFeatureList = false;
   let resetAgentMdsFlag = false;
-  if (dbPath && existsSync8(dbPath)) {
+  if (dbPath && existsSync9(dbPath)) {
     if (opts.force) {
       resetDb = true;
     } else {
@@ -1832,7 +1983,7 @@ async function runReset(cwd2, opts) {
   } else if (!dbPath) {
     console.log(pc8.dim(`  Skipping DB reset \u2014 remote ${config.database.type} database is not managed by this command.`));
   }
-  if (existsSync8(featureListPath)) {
+  if (existsSync9(featureListPath)) {
     if (opts.force) {
       resetFeatureList = true;
     } else {
@@ -1882,7 +2033,7 @@ async function runReset(cwd2, opts) {
 
 // src/core/mcp-server.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync } from "fs";
-import { join as join12, resolve as resolve8 } from "path";
+import { join as join14, resolve as resolve10 } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -2061,7 +2212,7 @@ var TOOLS = [
 ];
 async function startMcpServer(config, cwd2) {
   const db = await openDB(config, cwd2);
-  const docsPath = resolve8(cwd2, config.project.docsPath);
+  const docsPath = resolve10(cwd2, config.project.docsPath);
   const server = new Server(
     { name: "agent-harness-kit", version: VERSION },
     { capabilities: { tools: {} } }
@@ -2202,7 +2353,7 @@ function collectMarkdownFiles(dir) {
   const files = [];
   try {
     for (const entry of readdirSync2(dir)) {
-      const full = join12(dir, entry);
+      const full = join14(dir, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         files.push(...collectMarkdownFiles(full));
@@ -2309,13 +2460,13 @@ async function runStatus(cwd2, opts) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join13, resolve as resolve9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join15, resolve as resolve11 } from "path";
 import pc10 from "picocolors";
 async function runSync(cwd2, opts) {
   const config = await loadConfig(cwd2);
   const direction = opts.direction ?? "both";
-  const featureListPath = resolve9(join13(cwd2, config.storage.dir, "feature_list.json"));
+  const featureListPath = resolve11(join15(cwd2, config.storage.dir, "feature_list.json"));
   const db = await openDB(config, cwd2);
   try {
     if (direction === "in" || direction === "both") {
@@ -2329,7 +2480,7 @@ async function runSync(cwd2, opts) {
   }
 }
 async function syncIn(featureListPath, db, dryRun) {
-  if (!existsSync9(featureListPath)) {
+  if (!existsSync10(featureListPath)) {
     console.log(pc10.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
     return;
   }
@@ -2420,14 +2571,14 @@ async function runTaskAdd(cwd2) {
 
 // src/commands/task/done.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve12 } from "path";
 import pc12 from "picocolors";
 async function runTaskDone(cwd2, idOrSlug) {
   const config = await loadConfig(cwd2);
   if (config.health.required) {
-    const scriptPath = resolve10(cwd2, config.health.scriptPath);
-    if (existsSync10(scriptPath)) {
+    const scriptPath = resolve12(cwd2, config.health.scriptPath);
+    if (existsSync11(scriptPath)) {
       const result = spawnSync2("bash", [scriptPath], { cwd: cwd2, stdio: "pipe", encoding: "utf8" });
       if (result.status !== 0) {
         console.error(pc12.red("\u2717 Health check failed \u2014 cannot mark task as done."));
@@ -2498,10 +2649,10 @@ async function runTaskList(cwd2, opts) {
 
 // src/core/package-data.ts
 import { createRequire } from "module";
-import { dirname as dirname5, join as join14 } from "path";
+import { dirname as dirname5, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var require2 = createRequire(import.meta.url);
-var pkgPath = join14(dirname5(fileURLToPath3(import.meta.url)), "..", "package.json");
+var pkgPath = join16(dirname5(fileURLToPath3(import.meta.url)), "..", "package.json");
 var pkg = require2(pkgPath);
 
 // src/core/update-check.ts
@@ -2509,15 +2660,15 @@ import pc14 from "picocolors";
 var REGISTRY_URL = `https://registry.npmjs.org/${pkg.name}/latest`;
 var TIMEOUT_MS = 2500;
 function checkForUpdate(currentVersion) {
-  return new Promise((resolve11) => {
-    const timer = setTimeout(() => resolve11(null), TIMEOUT_MS);
+  return new Promise((resolve13) => {
+    const timer = setTimeout(() => resolve13(null), TIMEOUT_MS);
     fetch(REGISTRY_URL).then((res) => res.json()).then((data) => {
       clearTimeout(timer);
       const latest = data.version;
-      resolve11(isNewer(latest, currentVersion) ? { current: currentVersion, latest } : null);
+      resolve13(isNewer(latest, currentVersion) ? { current: currentVersion, latest } : null);
     }).catch(() => {
       clearTimeout(timer);
-      resolve11(null);
+      resolve13(null);
     });
   });
 }