@cardor/agent-harness-kit 0.14.0 → 0.15.0

package/dist/cli.js

@@ -1,123 +1,1998 @@
-import { Command } from 'commander';
-import { createRequire } from 'node:module';
-import { runInit } from './commands/init.js';
-import { runBuild } from './commands/build.js';
-import { runHealth } from './commands/health.js';
-import { runStatus } from './commands/status.js';
-import { runSync } from './commands/sync.js';
-import { runServe } from './commands/serve.js';
-import { runMigrate } from './commands/migrate.js';
-import { runExport } from './commands/export.js';
-import { runTaskAdd, runTaskList, runTaskDone } from './commands/task/index.js';
-import { runDashboard } from './commands/dashboard.js';
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const pkg = require('../package.json');
-const cwd = process.cwd();
-const program = new Command();
-program
-    .name('ahk')
-    .description('agent-harness-kit — CLI scaffolding for multi-agent harness systems')
-    .version(pkg.version, '-v, --version');
-// ─── init ─────────────────────────────────────────────────────────────────────
-program
-    .command('init')
-    .description('Scaffold a harness interactively in the current directory')
-    .option('--name <name>', 'Project name (skip prompt)')
-    .option('--provider <provider>', 'AI provider: claude-code | opencode (skip prompt)')
-    .option('--docs <path>', 'Docs folder path (skip prompt)')
-    .option('--tasks <adapter>', 'Task adapter: local | jira | linear (skip prompt)')
-    .action(async (opts) => {
-    await runInit(cwd, opts);
+import {
+  loadConfig
+} from "./chunk-LQ7SDMK6.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/build.ts
+import { watch } from "fs";
+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";
+
+// src/core/materializer/mcp-merge.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function mergeClaudeMcpJson(filePath, port) {
+  const folderPath = dirname(filePath);
+  if (!existsSync(folderPath)) {
+    mkdirSync(folderPath, { recursive: true });
+  }
+  let existing = {};
+  if (existsSync(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf8"));
+    } catch {
+    }
+  }
+  const merged = {
+    ...existing,
+    mcpServers: {
+      ...existing.mcpServers ?? {},
+      "agent-harness-kit": {
+        type: "stdio",
+        command: "npx",
+        args: ["ahk", "serve", "--port", String(port)]
+      }
+    }
+  };
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+function mergeOpencodeJson(filePath, port) {
+  const folderPath = dirname(filePath);
+  if (!existsSync(folderPath)) {
+    mkdirSync(folderPath, { recursive: true });
+  }
+  let existing = {};
+  if (existsSync(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf8"));
+    } catch {
+    }
+  }
+  const existingMcp = existing.mcp ?? {};
+  const merged = {
+    ...existing,
+    mcp: {
+      ...existingMcp,
+      "agent-harness-kit": {
+        enabled: true,
+        type: "local",
+        command: ["npx", "ahk", "serve", "--port", String(port)]
+      }
+    }
+  };
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "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";
+
+// src/core/materializer/templates.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = join(__dirname, "agent-templates");
+function loadAgentTemplate(name, vars = {}) {
+  const raw = readFileSync2(join(TEMPLATES_DIR, `${name}.md`), "utf8");
+  return raw.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+var HEALTH_SH = `#!/usr/bin/env bash
+# health.sh \u2014 project health check for agent-harness-kit
+#
+# This script must exit 0 when the project is healthy.
+# Agents will run this before starting work.
+#
+# TODO: implement your project's health checks below.
+# Examples:
+#   npm test
+#   docker compose ps | grep -q "running"
+#   psql -c "SELECT 1" > /dev/null 2>&1
+#
+# Until you implement it, this script intentionally exits 1
+# so agents know the environment is not verified.
+
+echo "health.sh not implemented yet."
+echo "Edit this file with your project's health checks."
+echo "It must exit 0 for agents to start working."
+exit 1
+`;
+function agentsMd(config) {
+  const { name, description, docsPath } = config.project;
+  const port = config.tools.mcp.port;
+  return `# AGENTS.md \u2014 ${name}
+
+> **Read this file first.** It is the navigation map for every AI agent working in this repository.
+
+## Project
+
+**${name}** \u2014 ${description}
+
+## Health check (run before starting)
+
+\`\`\`bash
+bash health.sh
+\`\`\`
+
+If it exits non-zero, stop and report the issue. Do not proceed with tasks until health is green.
+
+## Harness data (source of truth)
+
+| File | Purpose |
+|------|---------|
+| \`.harness/harness.db\` | SQLite: all tasks, actions, file changes, tool calls |
+| \`.harness/current.md\` | Markdown fallback \u2014 read this if MCP server is unavailable |
+| \`.harness/feature_list.json\` | Human-editable task seed list |
+
+## MCP tools (preferred)
+
+The harness exposes tools via MCP server on port ${port}. Use these instead of reading files directly.
+
+\`\`\`
+actions.start      taskId agent          \u2192 start an action, returns actionId
+actions.write      actionId section text \u2192 record a section (result, tools_used, ...)
+actions.complete   actionId summary      \u2192 close the action
+actions.get        taskId               \u2192 full action history for a task
+tasks.get          [status]             \u2192 list tasks (pending | in_progress | done | blocked)
+tasks.claim        id                   \u2192 atomically claim a pending task
+tasks.update       id status            \u2192 change task status
+docs.search        query                \u2192 search ${docsPath} for relevant content
+\`\`\`
+
+## Workflow
+
+\`\`\`
+1. INIT
+   - Run health.sh \u2192 exit 1 means stop
+   - tasks.get('in_progress') \u2192 resume if something is in progress
+   - tasks.get('pending') \u2192 pick lowest id
+
+2. WORK  (lead \u2192 explorer \u2192 builder \u2192 reviewer)
+   - Each agent calls actions.start(taskId, agentName) \u2192 actionId
+   - Records work with actions.write(actionId, section, content)
+   - Closes with actions.complete(actionId, summary)
+
+3. CLOSE
+   - tasks.update(taskId, 'done')
+   - Run health.sh \u2192 must be green before closing
+\`\`\`
+
+## Agent roles
+
+| Agent | Responsibility |
+|-------|---------------|
+| lead | Decomposes the task into a plan, assigns sub-agents |
+| explorer | Reads and maps relevant code, never writes |
+| builder | Implements the plan, writes files |
+| reviewer | Verifies acceptance criteria, approves or blocks |
+
+## What to read
+
+\`\`\`
+Always:         .harness/current.md (or MCP tasks.get)
+If implementing: ${docsPath}/
+If orchestrating: Agent definition files in your provider's agents directory
+\`\`\`
+`;
+}
+function configTs(params) {
+  return `import { defineHarness } from '@cardor/agent-harness-kit'
+
+export default defineHarness({
+  project: {
+    name: '${params.name}',
+    description: '${params.description}',
+    docsPath: '${params.docsPath}',
+  },
+
+  provider: '${params.provider}',
+
+  agents: {
+    lead:     { instructionsPath: null },
+    explorer: { instructionsPath: null, allowedPaths: ['${params.docsPath}', './src'] },
+    builder:  { instructionsPath: null, writablePaths: ['./src', './tests'] },
+    reviewer: { instructionsPath: null },
+    custom:   [],
+  },
+
+  storage: {
+    dir:    '.harness',
+    dbPath: '.harness/harness.db',
+    tasks:  { adapter: '${params.tasksAdapter}' },
+    sections: {
+      toolsUsed:     true,
+      filesModified: true,
+      result:        true,
+      blockers:      true,
+      nextSteps:     false,
+    },
+    markdownFallback: { enabled: true, path: '.harness/current.md' },
+  },
+
+  health: {
+    scriptPath: './health.sh',
+    required:   true,
+  },
+
+  tools: {
+    mcp:     { enabled: true, port: ${params.port} },
+    scripts: { enabled: true, outputDir: './.harness/scripts' },
+  },
+})
+`;
+}
+function agentLead(vars) {
+  return loadAgentTemplate("lead", vars);
+}
+function agentExplorer(vars) {
+  return loadAgentTemplate("explorer", vars);
+}
+function agentBuilder(vars) {
+  return loadAgentTemplate("builder", vars);
+}
+function agentReviewer(vars) {
+  return loadAgentTemplate("reviewer", vars);
+}
+function featureListJson(tasks) {
+  return JSON.stringify(tasks, null, 2) + "\n";
+}
+var GITIGNORE_ENTRIES = `
+# agent-harness-kit
+.harness/harness.db
+.harness/harness.db-shm
+.harness/harness.db-wal
+.harness/current.md
+`;
+
+// src/core/materializer/scaffold-utils.ts
+function writeAgentFile(cwd2, relPath, content) {
+  const abs = join2(cwd2, relPath);
+  if (existsSync2(abs)) return;
+  mkdirSync2(resolve(abs, ".."), { recursive: true });
+  writeFileSync2(abs, content, "utf8");
+}
+function appendGitignore(cwd2) {
+  const giPath = join2(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");
+  }
+}
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+
+// src/core/materializer/claude-code.ts
+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));
+    if (!existsSync3(join3(cwd2, "health.sh"))) {
+      write("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(
+        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, ".claude/agents/lead.md", agentLead({ projectName }));
+    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, ".mcp.json"), config.tools.mcp.port);
+    appendGitignore(cwd2);
+  }
+  async build(config, cwd2) {
+    const write = (relPath, content) => {
+      const abs = join3(cwd2, relPath);
+      mkdirSync3(resolve2(abs, ".."), { recursive: true });
+      writeFileSync3(abs, content, "utf8");
+    };
+    write("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, ".claude/agents/lead.md", agentLead({ projectName }));
+    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, ".mcp.json"), config.tools.mcp.port);
+  }
+  async migrate(config, _to, _cwd) {
+    void config;
+  }
+};
+
+// 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";
+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 });
+    };
+    write("AGENTS.md", agentsMd(config));
+    if (!existsSync4(join4(cwd2, "health.sh"))) {
+      write("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(
+        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, ".opencode/agents/lead.md", agentLead({ projectName }));
+    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);
+    appendGitignore(cwd2);
+  }
+  async build(config, cwd2) {
+    const write = (relPath, content) => {
+      const abs = join4(cwd2, relPath);
+      mkdirSync4(resolve3(abs, ".."), { recursive: true });
+      writeFileSync4(abs, content, "utf8");
+    };
+    write("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, ".opencode/agents/lead.md", agentLead({ projectName }));
+    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);
+  }
+  async migrate(config, _to, _cwd) {
+    void config;
+  }
+};
+
+// src/core/materializer/index.ts
+function getMaterializer(provider) {
+  switch (provider) {
+    case "claude-code":
+      return new ClaudeCodeMaterializer();
+    case "opencode":
+      return new OpenCodeMaterializer();
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+// src/commands/build.ts
+async function runBuild(cwd2, opts) {
+  await buildOnce(cwd2);
+  if (opts.watch) {
+    p.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...");
+        await buildOnce(cwd2);
+      }
+    });
+    await new Promise(() => {
+    });
+  }
+}
+async function buildOnce(cwd2) {
+  const spinner5 = p.spinner();
+  spinner5.start("Loading config...");
+  try {
+    const config = await loadConfig(cwd2);
+    spinner5.message("Rebuilding files...");
+    const materializer = getMaterializer(config.provider);
+    await materializer.build(config, cwd2);
+    spinner5.stop(pc.green("Build complete"));
+    p.log.success("AGENTS.md");
+    p.log.success(`Agent definitions (${config.provider})`);
+    p.log.success("MCP config");
+  } catch (err) {
+    spinner5.stop(pc.red("Build failed"));
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/dashboard.ts
+import { dirname as dirname4, join as join7, resolve as resolve5 } 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 { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { WebSocketServer } from "ws";
+var AGENT_ORDER = ["lead", "explorer", "builder", "reviewer"];
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  "": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function fileResponse(filePath) {
+  const content = readFileSync4(filePath);
+  const mime = MIME[extname(filePath)] ?? "application/octet-stream";
+  return new Response(content, {
+    headers: { "Content-Type": mime, "Cache-Control": "no-cache" }
+  });
+}
+function startDashboardServer(db, dbPath, staticPath, port) {
+  const app = new Hono();
+  app.use("/api/*", async (c, next) => {
+    await next();
+    c.res.headers.set("Access-Control-Allow-Origin", "*");
+  });
+  app.get("/api/stats", (c) => {
+    const summary = db.getStatusSummary();
+    const byStatus = { pending: 0, in_progress: 0, done: 0, blocked: 0 };
+    for (const { status, total } of summary) byStatus[status] = total;
+    const [{ total: totalActions }] = db.queryRaw(`SELECT COUNT(*) as total FROM actions`);
+    const [{ total: totalFiles }] = db.queryRaw(`SELECT COUNT(*) as total FROM action_files`);
+    const [{ total: uniqueTools }] = db.queryRaw(`SELECT COUNT(DISTINCT tool_name) as total FROM action_tools`);
+    const [{ total: activeAgents }] = db.queryRaw(
+      `SELECT COUNT(DISTINCT agent) as total FROM actions WHERE status = 'in_progress'`
+    );
+    return c.json({ byStatus, totalActions, totalFiles, uniqueTools, activeAgents });
+  });
+  app.get("/api/meta", (c) => {
+    return c.json({ ok: true });
+  });
+  app.get("/api/tasks", (c) => {
+    const rows = db.queryRaw(`
+      SELECT t.*,
+        COUNT(ta.id) as acceptance_total,
+        COALESCE(SUM(ta.met), 0) as acceptance_met
+      FROM tasks t
+      LEFT JOIN task_acceptance ta ON ta.task_id = t.id
+      GROUP BY t.id
+      ORDER BY t.id
+    `);
+    return c.json(rows);
+  });
+  app.get("/api/tasks/:id", (c) => {
+    const id = parseInt(c.req.param("id"));
+    const task2 = db.getTaskById(id);
+    if (!task2) return c.json({ error: "Not found" }, 404);
+    const acceptance = db.getTaskAcceptance(id);
+    const actions = db.getActionsForTask(id).map((action) => ({
+      ...action,
+      sections: db.getActionSections(action.id),
+      files: db.queryRaw(`SELECT * FROM action_files WHERE action_id = ?`, action.id),
+      tools: db.queryRaw(`SELECT * FROM action_tools WHERE action_id = ? ORDER BY called_at`, action.id)
+    }));
+    return c.json({ ...task2, acceptance, actions });
+  });
+  app.get("/api/tools/top", (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "20");
+    return c.json(db.getTopTools(limit));
+  });
+  app.get("/api/tools/recent", (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "50");
+    const rows = db.queryRaw(`
+      SELECT at.*, t.id as task_id, t.title as task_title, t.slug as task_slug, a.agent
+      FROM action_tools at
+      JOIN actions a ON at.action_id = a.id
+      JOIN tasks t ON a.task_id = t.id
+      ORDER BY at.called_at DESC
+      LIMIT ?
+    `, limit);
+    return c.json(rows);
+  });
+  app.get("/api/files/top", (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "20");
+    const rows = db.queryRaw(`
+      SELECT
+        file_path,
+        COUNT(*) as total,
+        SUM(CASE WHEN operation='read'     THEN 1 ELSE 0 END) as read,
+        SUM(CASE WHEN operation='created'  THEN 1 ELSE 0 END) as created,
+        SUM(CASE WHEN operation='modified' THEN 1 ELSE 0 END) as modified,
+        SUM(CASE WHEN operation='deleted'  THEN 1 ELSE 0 END) as deleted
+      FROM action_files
+      GROUP BY file_path
+      ORDER BY total DESC
+      LIMIT ?
+    `, limit);
+    return c.json(rows);
+  });
+  app.get("/api/files/recent", (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "50");
+    const rows = db.queryRaw(`
+      SELECT af.*, t.id as task_id, t.title as task_title, t.slug as task_slug,
+        a.agent, a.created_at as called_at
+      FROM action_files af
+      JOIN actions a ON af.action_id = a.id
+      JOIN tasks t ON a.task_id = t.id
+      ORDER BY a.created_at DESC
+      LIMIT ?
+    `, limit);
+    return c.json(rows);
+  });
+  app.get("/api/agents/stats", (c) => {
+    const rows = db.queryRaw(`
+      SELECT
+        a.agent,
+        COUNT(*)                                                    as actions_total,
+        SUM(CASE WHEN a.status='completed' THEN 1 ELSE 0 END)      as actions_done,
+        SUM(CASE WHEN a.status='blocked'   THEN 1 ELSE 0 END)      as actions_blocked,
+        COUNT(DISTINCT a.task_id)                                   as tasks_worked,
+        COUNT(DISTINCT af.file_path)                                as files_touched
+      FROM actions a
+      LEFT JOIN action_files af ON af.action_id = a.id
+      GROUP BY a.agent
+      ORDER BY actions_total DESC
+    `);
+    const sorted = rows.sort((a, b) => {
+      const ai = AGENT_ORDER.indexOf(a.agent);
+      const bi = AGENT_ORDER.indexOf(b.agent);
+      if (ai === -1 && bi === -1) return 0;
+      if (ai === -1) return 1;
+      if (bi === -1) return -1;
+      return ai - bi;
+    });
+    return c.json(sorted);
+  });
+  app.get("/api/timeline", (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "50");
+    const rows = db.queryRaw(`
+      SELECT a.*, t.title as task_title, t.slug as task_slug, t.status as task_status
+      FROM actions a
+      JOIN tasks t ON a.task_id = t.id
+      ORDER BY a.created_at DESC
+      LIMIT ?
+    `, limit);
+    return c.json(rows);
+  });
+  app.get("/*", (c) => {
+    const urlPath = c.req.path;
+    if (urlPath !== "/") {
+      const candidate = join5(staticPath, urlPath);
+      if (existsSync5(candidate)) {
+        try {
+          return fileResponse(candidate);
+        } catch {
+        }
+      }
+    }
+    return fileResponse(join5(staticPath, "index.html"));
+  });
+  const httpServer = serve({ fetch: app.fetch, port });
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    if (req.url === "/ws") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+  let debounce;
+  const broadcast = () => {
+    clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      for (const client of wss.clients) {
+        if (client.readyState === 1) {
+          client.send(JSON.stringify({ type: "update" }));
+        }
+      }
+    }, 150);
+  };
+  const walPath = `${dbPath}-wal`;
+  const watchTarget = existsSync5(walPath) ? walPath : dbPath;
+  const watcher = watch2(watchTarget, broadcast);
+  return {
+    url: `http://localhost:${port}`,
+    close: () => {
+      clearTimeout(debounce);
+      watcher.close();
+      wss.close();
+      httpServer.close();
+    }
+  };
+}
+
+// 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";
+
+// src/core/sqlite-adapter.ts
+import { createRequire } from "module";
+var _require = createRequire(import.meta.url);
+var isBun = "bun" in process.versions;
+function openSQLite(path) {
+  if (isBun) {
+    const { Database } = _require("bun:sqlite");
+    return new Database(path);
+  }
+  const { DatabaseSync } = _require("node:sqlite");
+  return new DatabaseSync(path);
+}
+function lastInsertId(db) {
+  const row = db.prepare("SELECT last_insert_rowid() AS id").get();
+  return row.id;
+}
+
+// src/core/db.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS tasks (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  slug         TEXT    NOT NULL UNIQUE,
+  title        TEXT    NOT NULL,
+  description  TEXT,
+  status       TEXT    NOT NULL DEFAULT 'pending'
+               CHECK(status IN ('pending','in_progress','done','blocked')),
+  assigned_to  TEXT,
+  created_at   TEXT    NOT NULL,
+  started_at   TEXT,
+  completed_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS task_acceptance (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id   INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  criterion TEXT    NOT NULL,
+  met       INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS actions (
+  id           TEXT    PRIMARY KEY,
+  task_id      INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  agent        TEXT    NOT NULL
+               CHECK(agent IN ('lead','explorer','builder','reviewer') OR agent LIKE 'custom:%'),
+  status       TEXT    NOT NULL DEFAULT 'in_progress'
+               CHECK(status IN ('in_progress','completed','blocked')),
+  created_at   TEXT    NOT NULL,
+  completed_at TEXT,
+  summary      TEXT
+);
+
+CREATE TABLE IF NOT EXISTS action_sections (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  action_id    TEXT    NOT NULL REFERENCES actions(id) ON DELETE CASCADE,
+  section_type TEXT    NOT NULL,
+  content      TEXT    NOT NULL,
+  created_at   TEXT    NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS action_files (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  action_id   TEXT    NOT NULL REFERENCES actions(id) ON DELETE CASCADE,
+  file_path   TEXT    NOT NULL,
+  operation   TEXT    NOT NULL
+              CHECK(operation IN ('read','created','modified','deleted')),
+  notes       TEXT
+);
+
+CREATE TABLE IF NOT EXISTS action_tools (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  action_id      TEXT    NOT NULL REFERENCES actions(id) ON DELETE CASCADE,
+  tool_name      TEXT    NOT NULL,
+  args_json      TEXT,
+  result_summary TEXT,
+  called_at      TEXT    NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_status      ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_actions_task_id   ON actions(task_id);
+CREATE INDEX IF NOT EXISTS idx_actions_agent     ON actions(agent);
+CREATE INDEX IF NOT EXISTS idx_actions_status    ON actions(status);
+CREATE INDEX IF NOT EXISTS idx_action_files_path ON action_files(file_path);
+CREATE INDEX IF NOT EXISTS idx_action_tools_name ON action_tools(tool_name);
+`;
+var HarnessDB = class {
+  db;
+  config;
+  constructor(dbPath, config) {
+    this.config = config;
+    const abs = resolve4(dbPath);
+    mkdirSync5(dirname3(abs), { recursive: true });
+    this.db = openSQLite(abs);
+    this.db.exec(`PRAGMA journal_mode = WAL`);
+    this.db.exec(`PRAGMA foreign_keys = ON`);
+    this.db.exec(SCHEMA);
+  }
+  // ─── Tasks ────────────────────────────────────────────────────────────────
+  addTask(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO tasks (slug, title, description, status, created_at)
+         VALUES (@slug, @title, @description, 'pending', @created_at)`
+    ).run({
+      slug: params.slug,
+      title: params.title,
+      description: params.description ?? null,
+      created_at: now
+    });
+    const taskId = lastInsertId(this.db);
+    if (params.acceptance?.length) {
+      const accStmt = this.db.prepare(
+        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`
+      );
+      for (const criterion of params.acceptance) {
+        accStmt.run(taskId, criterion);
+      }
+    }
+    this.regenerateCurrentMd();
+    return this.getTaskById(taskId);
+  }
+  getTasks(status) {
+    if (status) {
+      return this.db.prepare(`SELECT * FROM tasks WHERE status = ? ORDER BY id`).all(status);
+    }
+    return this.db.prepare(`SELECT * FROM tasks ORDER BY id`).all();
+  }
+  getTaskById(id) {
+    return this.db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(id) ?? null;
+  }
+  getTaskBySlug(slug) {
+    return this.db.prepare(`SELECT * FROM tasks WHERE slug = ?`).get(slug) ?? null;
+  }
+  getTaskAcceptance(taskId) {
+    return this.db.prepare(`SELECT * FROM task_acceptance WHERE task_id = ?`).all(taskId);
+  }
+  updateTaskStatus(idOrSlug, status) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task2 = typeof idOrSlug === "number" ? this.getTaskById(idOrSlug) : this.getTaskBySlug(idOrSlug);
+    if (!task2) throw new Error(`Task not found: ${idOrSlug}`);
+    if (status === "in_progress" && !task2.started_at) {
+      this.db.prepare(
+        `UPDATE tasks SET status = ?, started_at = ? WHERE id = ?`
+      ).run(status, now, task2.id);
+    } else if (status === "done") {
+      this.db.prepare(
+        `UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?`
+      ).run(status, now, task2.id);
+    } else {
+      this.db.prepare(`UPDATE tasks SET status = ? WHERE id = ?`).run(status, task2.id);
+    }
+    this.regenerateCurrentMd();
+    return this.getTaskById(task2.id);
+  }
+  claimTask(id, agent) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare(
+        `UPDATE tasks SET status = 'in_progress', assigned_to = ?, started_at = ?
+           WHERE id = ? AND status = 'pending'`
+      ).run(agent, now, id);
+      this.db.exec("COMMIT");
+      const task2 = this.getTaskById(id);
+      if (!task2 || task2.status !== "in_progress" || task2.assigned_to !== agent) return null;
+      this.regenerateCurrentMd();
+      return task2;
+    } catch (err) {
+      this.db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+  // ─── Actions ──────────────────────────────────────────────────────────────
+  startAction(taskId, agent) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = randomUUID();
+    this.db.prepare(
+      `INSERT INTO actions (id, task_id, agent, status, created_at)
+         VALUES (?, ?, ?, 'in_progress', ?)`
+    ).run(id, taskId, agent, now);
+    this.regenerateCurrentMd();
+    return this.getAction(id);
+  }
+  writeSection(actionId, sectionType, content) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO action_sections (action_id, section_type, content, created_at)
+         VALUES (?, ?, ?, ?)`
+    ).run(actionId, sectionType, content, now);
+    this.regenerateCurrentMd();
+  }
+  completeAction(actionId, summary) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `UPDATE actions SET status = 'completed', completed_at = ?, summary = ?
+         WHERE id = ?`
+    ).run(now, summary, actionId);
+    this.regenerateCurrentMd();
+    return this.getAction(actionId);
+  }
+  getAction(actionId) {
+    return this.db.prepare(`SELECT * FROM actions WHERE id = ?`).get(actionId) ?? null;
+  }
+  getActionsForTask(taskId) {
+    return this.db.prepare(`SELECT * FROM actions WHERE task_id = ? ORDER BY created_at`).all(taskId);
+  }
+  getActionSections(actionId) {
+    return this.db.prepare(
+      `SELECT * FROM action_sections WHERE action_id = ? ORDER BY created_at`
+    ).all(actionId);
+  }
+  recordFile(actionId, filePath, operation, notes) {
+    this.db.prepare(
+      `INSERT INTO action_files (action_id, file_path, operation, notes)
+         VALUES (?, ?, ?, ?)`
+    ).run(actionId, filePath, operation, notes ?? null);
+  }
+  recordTool(actionId, toolName, argsJson, resultSummary) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO action_tools (action_id, tool_name, args_json, result_summary, called_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(actionId, toolName, argsJson ?? null, resultSummary ?? null, now);
+  }
+  getFilesForTask(taskId) {
+    return this.db.prepare(
+      `SELECT af.*, a.agent
+         FROM action_files af
+         JOIN actions a ON af.action_id = a.id
+         WHERE a.task_id = ?
+         ORDER BY a.agent, af.operation`
+    ).all(taskId);
+  }
+  getTopTools(limit = 10) {
+    return this.db.prepare(
+      `SELECT tool_name, COUNT(*) as uses
+         FROM action_tools
+         GROUP BY tool_name
+         ORDER BY uses DESC
+         LIMIT ?`
+    ).all(limit);
+  }
+  getStatusSummary() {
+    return this.db.prepare(`SELECT status, COUNT(*) as total FROM tasks GROUP BY status`).all();
+  }
+  // ─── current.md fallback ──────────────────────────────────────────────────
+  regenerateCurrentMd() {
+    if (!this.config.storage.markdownFallback.enabled) return;
+    const mdPath = resolve4(this.config.storage.markdownFallback.path);
+    mkdirSync5(dirname3(mdPath), { recursive: true });
+    const inProgress = this.getTasks("in_progress");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let md = `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
+`;
+    md += `<!-- Last updated: ${now} -->
+
+`;
+    md += `# Current Session
+
+`;
+    if (inProgress.length === 0) {
+      md += `## No tasks in progress
+
+`;
+      const pending = this.getTasks("pending");
+      if (pending.length > 0) {
+        md += `### Next pending tasks
+`;
+        for (const t of pending.slice(0, 5)) {
+          md += `- **#${t.id}** ${t.title} (\`${t.slug}\`)
+`;
+        }
+      }
+    } else {
+      for (const task2 of inProgress) {
+        md += `## Active Task
+`;
+        md += `- **ID:** ${task2.id}
+`;
+        md += `- **Slug:** ${task2.slug}
+`;
+        md += `- **Status:** ${task2.status}
+`;
+        md += `- **Started:** ${task2.started_at ?? "unknown"}
+
+`;
+        const actions = this.getActionsForTask(task2.id);
+        if (actions.length > 0) {
+          md += `## Actions this session
+`;
+          md += `| Agent    | Status      | Summary                          | Started     |
+`;
+          md += `|----------|-------------|----------------------------------|-------------|
+`;
+          for (const a of actions) {
+            const started = a.created_at.slice(11, 16);
+            const summary = (a.summary ?? "").slice(0, 34).padEnd(34);
+            md += `| ${a.agent.padEnd(8)} | ${a.status.padEnd(11)} | ${summary} | ${started}       |
+`;
+          }
+          md += `
+`;
+        }
+        const acceptance = this.getTaskAcceptance(task2.id);
+        if (acceptance.length > 0) {
+          md += `## Acceptance Criteria
+`;
+          for (const a of acceptance) {
+            md += `- [${a.met ? "x" : " "}] ${a.criterion}
+`;
+          }
+          md += `
+`;
+        }
+      }
+    }
+    writeFileSync5(mdPath, md, "utf8");
+  }
+  // ─── Raw query (dashboard / analytics) ───────────────────────────────────
+  queryRaw(sql, ...params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  // ─── Export helpers ───────────────────────────────────────────────────────
+  exportJson() {
+    return {
+      tasks: this.getTasks(),
+      actions: this.db.prepare(`SELECT * FROM actions ORDER BY created_at`).all(),
+      sections: this.db.prepare(`SELECT * FROM action_sections ORDER BY created_at`).all()
+    };
+  }
+  close() {
+    this.db.close();
+  }
+  // ─── feature_list.json sync ───────────────────────────────────────────────
+  syncFromFeatureList(tasks) {
+    let added = 0;
+    let skipped = 0;
+    for (const t of tasks) {
+      if (this.getTaskBySlug(t.slug)) {
+        skipped++;
+        continue;
+      }
+      this.addTask(t);
+      added++;
+    }
+    return { added, skipped };
+  }
+  writeFeatureList(cwd2) {
+    const tasks = this.getTasks();
+    const list = tasks.map((t) => ({
+      slug: t.slug,
+      title: t.title,
+      description: t.description ?? void 0,
+      acceptance: this.getTaskAcceptance(t.id).map((a) => a.criterion),
+      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");
+  }
+};
+function openDB(config, cwd2) {
+  const dbPath = join6(resolve4(cwd2), config.storage.dbPath);
+  return new HarnessDB(dbPath, config);
+}
+
+// src/commands/dashboard.ts
+var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+async function runDashboard(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  const db = openDB(config, cwd2);
+  const dbPath = resolve5(cwd2, config.storage.dbPath);
+  const staticPath = join7(__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`));
+  console.log(pc2.dim(`  Press Ctrl+C to stop`));
+  if (opts.open) {
+    const { default: open } = await import("open");
+    await open(url);
+  }
+  process.on("SIGINT", () => {
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+
+// src/commands/export.ts
+import { writeFileSync as writeFileSync6 } from "fs";
+import pc3 from "picocolors";
+async function runExport(cwd2, opts) {
+  if (!opts.sql && !opts.json) {
+    console.error(pc3.red("Specify --sql or --json"));
+    process.exit(1);
+  }
+  const config = await loadConfig(cwd2);
+  const db = openDB(config, cwd2);
+  try {
+    if (opts.json) {
+      const data = db.exportJson();
+      const out = JSON.stringify(data, null, 2) + "\n";
+      if (opts.output) {
+        writeFileSync6(opts.output, out, "utf8");
+        console.log(pc3.green(`\u2713 Exported JSON \u2192 ${opts.output}`));
+      } else {
+        process.stdout.write(out);
+      }
+    }
+    if (opts.sql) {
+      console.error(pc3.dim("SQL dump requires direct SQLite access \u2014 use: sqlite3 .harness/harness.db .dump"));
+      process.exit(1);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// 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 pc4 from "picocolors";
+function checkLine(label, ok2, message, indent = 0) {
+  const prefix = label ? pc4.cyan(`[${label}] `) : " ".repeat(indent);
+  const icon = ok2 ? pc4.green("\u2713") : pc4.red("\u2717");
+  console.log(prefix + icon + " " + (ok2 ? pc4.green(message) : pc4.red(message)));
+}
+async function runHealth(cwd2) {
+  let config;
+  try {
+    config = await loadConfig(cwd2);
+  } catch {
+    console.error(pc4.red("\u2717 No config found. Run: ahk init"));
+    process.exit(1);
+  }
+  let allOk = true;
+  const dbPath = resolve6(cwd2, config.storage.dbPath);
+  const dbOk = existsSync6(dbPath);
+  checkLine("checking DB", dbOk, `${config.storage.dbPath} reachable`);
+  if (!dbOk) allOk = false;
+  const agentsDir = config.provider === "claude-code" ? ".claude/agents" : ".opencode/agents";
+  const agentNames = ["lead", "explorer", "builder", "reviewer"];
+  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);
+    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);
+    checkLine("checking MCP", mcpOk, `${mcpFile} valid`);
+    if (!mcpOk) allOk = false;
+  }
+  if (!allOk) {
+    console.log("");
+    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)) {
+    console.error(pc4.red(`\u2717 health.sh not found: ${scriptPath}`));
+    console.error("  Run ahk init first.");
+    process.exit(1);
+  }
+  const result = spawnSync("bash", [scriptPath], {
+    cwd: cwd2,
+    stdio: "inherit",
+    encoding: "utf8"
+  });
+  if (result.error) {
+    console.error(pc4.red(`\u2717 Failed to run health.sh: ${result.error.message}`));
+    process.exit(1);
+  }
+  if (result.status === 0) {
+    console.log(pc4.green("\u2713 Health check passed"));
+    process.exit(0);
+  } else {
+    console.error(pc4.red(`\u2717 Health check failed (exit ${result.status ?? "unknown"})`));
+    process.exit(result.status ?? 1);
+  }
+}
+
+// src/commands/init.ts
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+import * as p2 from "@clack/prompts";
+import pc5 from "picocolors";
+
+// src/commands/init-helpers.ts
+function applyConfigDefaults(params) {
+  return {
+    provider: params.provider,
+    project: {
+      name: params.name,
+      description: params.description,
+      docsPath: params.docsPath,
+      agentsMd: "./AGENTS.md"
+    },
+    agents: {
+      lead: { instructionsPath: null },
+      explorer: { instructionsPath: null, allowedPaths: [params.docsPath, "./src"] },
+      builder: { instructionsPath: null, writablePaths: ["./src", "./tests"] },
+      reviewer: { instructionsPath: null },
+      custom: []
+    },
+    storage: {
+      dir: ".harness",
+      dbPath: ".harness/harness.db",
+      tasks: { adapter: params.tasksAdapter },
+      sections: {
+        toolsUsed: true,
+        filesModified: true,
+        result: true,
+        blockers: true,
+        nextSteps: false
+      },
+      markdownFallback: { enabled: true, path: ".harness/current.md" }
+    },
+    health: {
+      scriptPath: "./health.sh",
+      required: true
+    },
+    tools: {
+      mcp: { enabled: true, port: 3742 },
+      scripts: { enabled: true, outputDir: "./.harness/scripts" }
+    }
+  };
+}
+
+// src/commands/init.ts
+async function runInit(cwd2, flags) {
+  p2.intro(pc5.bold("agent-harness-kit \u2014 harness scaffolding"));
+  let name;
+  if (flags.name) {
+    name = flags.name;
+  } else {
+    const val = await p2.text({
+      message: "Project name",
+      placeholder: "my-app",
+      validate: (v) => v.trim() ? void 0 : "Project name is required"
+    });
+    if (p2.isCancel(val)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    name = val;
+  }
+  const descVal = await p2.text({
+    message: "Short description (shown to agents as context)",
+    placeholder: "A REST API for managing notes"
+  });
+  if (p2.isCancel(descVal)) {
+    p2.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const description = descVal.trim() || name;
+  let provider;
+  if (flags.provider && ["claude-code", "opencode"].includes(flags.provider)) {
+    provider = flags.provider;
+  } else {
+    const val = await p2.select({
+      message: "AI provider",
+      options: [
+        { value: "claude-code", label: "Claude Code" },
+        { value: "opencode", label: "OpenCode" }
+      ]
+    });
+    if (p2.isCancel(val)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    provider = val;
+  }
+  let docsPath;
+  if (flags.docs) {
+    docsPath = flags.docs;
+  } else {
+    const val = await p2.text({
+      message: "Docs folder path (agents will search here)",
+      initialValue: "./docs"
+    });
+    if (p2.isCancel(val)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    docsPath = val.trim() || "./docs";
+  }
+  let tasksAdapter;
+  if (flags.tasks && ["local", "jira", "linear"].includes(flags.tasks)) {
+    tasksAdapter = flags.tasks;
+  } else {
+    const val = await p2.select({
+      message: "Task adapter",
+      options: [
+        { value: "local", label: "Local (feature_list.json)" },
+        { value: "jira", label: "Jira (coming soon)" },
+        { value: "linear", label: "Linear (coming soon)" }
+      ]
+    });
+    if (p2.isCancel(val)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    tasksAdapter = val;
+  }
+  const addFirstTask = await p2.confirm({ message: "Add your first task now?", initialValue: true });
+  if (p2.isCancel(addFirstTask)) {
+    p2.cancel("Cancelled.");
+    process.exit(0);
+  }
+  let firstTask;
+  if (addFirstTask) {
+    const titleVal = await p2.text({
+      message: "Task title",
+      validate: (v) => v.trim() ? void 0 : "Title is required"
+    });
+    if (p2.isCancel(titleVal)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const taskTitle = titleVal.trim();
+    const taskDescVal = await p2.text({
+      message: "Task description",
+      placeholder: "What and why"
+    });
+    if (p2.isCancel(taskDescVal)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const taskDesc = taskDescVal.trim();
+    const acceptance = [];
+    p2.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+    while (true) {
+      const criterionVal = await p2.text({
+        message: ">",
+        placeholder: "Criterion (or press Enter to finish)"
+      });
+      if (p2.isCancel(criterionVal) || !criterionVal.trim()) break;
+      acceptance.push(criterionVal.trim());
+    }
+    firstTask = { title: taskTitle, description: taskDesc, acceptance };
+  }
+  const spinner5 = p2.spinner();
+  spinner5.start("Scaffolding...");
+  try {
+    const config = applyConfigDefaults({ name, description, provider, docsPath, tasksAdapter });
+    const materializer = getMaterializer(provider);
+    const configContent = configTs({
+      name,
+      description,
+      provider,
+      docsPath,
+      tasksAdapter,
+      port: config.tools.mcp.port
+    });
+    writeFileSync7(join9(cwd2, "agent-harness-kit.config.ts"), configContent, "utf8");
+    mkdirSync6(join9(cwd2, config.storage.dir), { recursive: true });
+    const db = openDB(config, cwd2);
+    await materializer.scaffold(config, { cwd: cwd2, firstTask });
+    if (firstTask) {
+      const slug = slugify(firstTask.title);
+      db.addTask({
+        slug,
+        title: firstTask.title,
+        description: firstTask.description,
+        acceptance: firstTask.acceptance
+      });
+    }
+    db.close();
+    spinner5.stop("");
+  } catch (err) {
+    spinner5.stop("Failed");
+    p2.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const agentsDir = provider === "claude-code" ? ".claude/agents/" : ".opencode/agents/";
+  const mcpFile = provider === "claude-code" ? ".claude/mcp.json" : "./opencode/opencode.json";
+  console.log("");
+  console.log(pc5.green("\u2713 agent-harness-kit.config.ts"));
+  console.log(pc5.green("\u2713 AGENTS.md"));
+  console.log(pc5.green("\u2713 health.sh"));
+  console.log(pc5.green("\u2713 .harness/harness.db"));
+  console.log(pc5.green("\u2713 .harness/current.md"));
+  console.log(pc5.green(`\u2713 ${agentsDir}lead.md`));
+  console.log(pc5.green(`\u2713 ${agentsDir}explorer.md`));
+  console.log(pc5.green(`\u2713 ${agentsDir}builder.md`));
+  console.log(pc5.green(`\u2713 ${agentsDir}reviewer.md`));
+  console.log(pc5.green(`\u2713 ${mcpFile}`));
+  console.log(pc5.green("\u2713 .gitignore entries added"));
+  console.log("");
+  console.log(pc5.cyan("\u2192") + ` Edit ${pc5.cyan("health.sh")} with your project checks`);
+  console.log(pc5.cyan("\u2192") + ` ${pc5.cyan("ahk task add")} to queue work for agents`);
+}
+
+// src/commands/migrate.ts
+import * as p3 from "@clack/prompts";
+import pc6 from "picocolors";
+async function runMigrate(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  let target;
+  if (opts.to && ["claude-code", "opencode"].includes(opts.to)) {
+    target = opts.to;
+  } else {
+    const val = await p3.select({
+      message: "Migrate to provider",
+      options: [
+        { value: "claude-code", label: "Claude Code" },
+        { value: "opencode", label: "OpenCode" }
+      ]
+    });
+    if (p3.isCancel(val)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+    target = val;
+  }
+  if (target === config.provider) {
+    console.log(pc6.dim(`Already on ${target} \u2014 nothing to migrate.`));
+    return;
+  }
+  const spinner5 = p3.spinner();
+  spinner5.start(`Migrating from ${config.provider} to ${target}...`);
+  try {
+    const targetMaterializer = getMaterializer(target);
+    await targetMaterializer.build(config, cwd2);
+    spinner5.stop(pc6.green(`Migrated to ${target}`));
+    p3.log.warn(`Update agent-harness-kit.config.ts: set provider: '${target}'`);
+    p3.log.warn(`Then run: ahk build`);
+  } catch (err) {
+    spinner5.stop(pc6.red("Migration failed"));
+    p3.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/core/mcp-server.ts
+import { readdirSync, readFileSync as readFileSync5, statSync } from "fs";
+import { join as join10, resolve as resolve7 } from "path";
+import { Server } from "@modelcontextprotocol/sdk/server/index";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types";
+var VERSION = "0.1.0";
+var TOOLS = [
+  {
+    name: "actions.start",
+    description: "Start a new action for a task. Returns an actionId (UUID).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "number", description: "The task ID from tasks.get" },
+        agent: {
+          type: "string",
+          description: "Agent name: lead | explorer | builder | reviewer | custom:<name>"
+        }
+      },
+      required: ["taskId", "agent"]
+    }
+  },
+  {
+    name: "actions.write",
+    description: "Record a section in an action. Standard sections: result, tools_used, files_modified, blockers, next_steps.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        actionId: { type: "string", description: "UUID returned by actions.start" },
+        sectionType: {
+          type: "string",
+          description: "Section name: result | tools_used | files_modified | blockers | next_steps | <custom>"
+        },
+        content: { type: "string", description: "Content for this section" }
+      },
+      required: ["actionId", "sectionType", "content"]
+    }
+  },
+  {
+    name: "actions.complete",
+    description: "Close an action with a one-line summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        actionId: { type: "string", description: "UUID of the action to close" },
+        summary: { type: "string", description: "One-line summary of what was done" }
+      },
+      required: ["actionId", "summary"]
+    }
+  },
+  {
+    name: "actions.get",
+    description: "Get the full action history for a task (all agents, all sections).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "number", description: "Task ID" }
+      },
+      required: ["taskId"]
+    }
+  },
+  {
+    name: "tasks.get",
+    description: "List tasks, optionally filtered by status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["pending", "in_progress", "done", "blocked"],
+          description: "Filter by status (omit for all tasks)"
+        }
+      }
+    }
+  },
+  {
+    name: "tasks.claim",
+    description: "Atomically claim a pending task. Returns task_already_claimed if another agent got it first.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "number", description: "Task ID to claim" },
+        agent: { type: "string", description: "Your agent name" }
+      },
+      required: ["id", "agent"]
+    }
+  },
+  {
+    name: "tasks.update",
+    description: "Change the status of a task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "number", description: "Task ID" },
+        status: {
+          type: "string",
+          enum: ["pending", "in_progress", "done", "blocked"]
+        }
+      },
+      required: ["id", "status"]
+    }
+  },
+  {
+    name: "docs.search",
+    description: "Search the project docs folder for content matching a query.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search terms" }
+      },
+      required: ["query"]
+    }
+  }
+];
+async function startMcpServer(config, cwd2) {
+  const db = openDB(config, cwd2);
+  const docsPath = resolve7(cwd2, config.project.docsPath);
+  const server = new Server(
+    { name: "agent-harness-kit", version: VERSION },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const a = args ?? {};
+    try {
+      const result = await dispatch(name, a, db, docsPath);
+      return result;
+    } catch (err) {
+      return ok(`Error: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+async function dispatch(name, args, db, docsPath) {
+  switch (name) {
+    case "actions.start": {
+      const taskId = num(args, "taskId");
+      const agent = str(args, "agent");
+      const action = db.startAction(taskId, agent);
+      return ok(JSON.stringify({ actionId: action.id, taskId, agent, status: "in_progress" }));
+    }
+    case "actions.write": {
+      const actionId = str(args, "actionId");
+      const sectionType = str(args, "sectionType");
+      const content = str(args, "content");
+      db.writeSection(actionId, sectionType, content);
+      return ok(JSON.stringify({ actionId, sectionType, recorded: true }));
+    }
+    case "actions.complete": {
+      const actionId = str(args, "actionId");
+      const summary = str(args, "summary");
+      const action = db.completeAction(actionId, summary);
+      return ok(JSON.stringify({ actionId, status: action.status, completedAt: action.completed_at }));
+    }
+    case "actions.get": {
+      const taskId = num(args, "taskId");
+      const actions = db.getActionsForTask(taskId);
+      const full = actions.map((a) => ({
+        ...a,
+        sections: db.getActionSections(a.id)
+      }));
+      return ok(JSON.stringify(full, null, 2));
+    }
+    case "tasks.get": {
+      const status = args["status"];
+      const tasks = status ? db.getTasks(status) : db.getTasks();
+      return ok(JSON.stringify(tasks, null, 2));
+    }
+    case "tasks.claim": {
+      const id = num(args, "id");
+      const agent = str(args, "agent");
+      const task2 = db.claimTask(id, agent);
+      if (!task2) {
+        return ok(JSON.stringify({ error: "task_already_claimed", taskId: id }));
+      }
+      return ok(JSON.stringify(task2));
+    }
+    case "tasks.update": {
+      const id = num(args, "id");
+      const status = str(args, "status");
+      const task2 = db.updateTaskStatus(id, status);
+      return ok(JSON.stringify(task2));
+    }
+    case "docs.search": {
+      const query = str(args, "query");
+      const results = searchDocs(docsPath, query);
+      return ok(JSON.stringify(results, null, 2));
+    }
+    default:
+      return ok(`Unknown tool: ${name}`, true);
+  }
+}
+function searchDocs(docsPath, query, maxResults = 10) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const results = [];
+  try {
+    const files = collectMarkdownFiles(docsPath);
+    for (const file of files) {
+      if (results.length >= maxResults) break;
+      try {
+        const content = readFileSync5(file, "utf8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const lower = lines[i].toLowerCase();
+          if (terms.every((t) => lower.includes(t))) {
+            results.push({ file: file.replace(docsPath + "/", ""), line: i + 1, text: lines[i].trim() });
+            if (results.length >= maxResults) break;
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [{ file: "", line: 0, text: `docs path not found: ${docsPath}` }];
+  }
+  return results;
+}
+function collectMarkdownFiles(dir) {
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir)) {
+      const full = join10(dir, entry);
+      const stat = statSync(full);
+      if (stat.isDirectory()) {
+        files.push(...collectMarkdownFiles(full));
+      } else if (entry.endsWith(".md") || entry.endsWith(".txt")) {
+        files.push(full);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function ok(text3, isError = false) {
+  return { content: [{ type: "text", text: text3 }], isError };
+}
+function str(args, key) {
+  const v = args[key];
+  if (typeof v !== "string") throw new Error(`${key} must be a string`);
+  return v;
+}
+function num(args, key) {
+  const v = args[key];
+  if (typeof v !== "number") throw new Error(`${key} must be a number`);
+  return v;
+}
+
+// src/commands/serve.ts
+async function runServe(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  if (opts.port) {
+    config.tools.mcp.port = opts.port;
+  }
+  process.stderr.write(`[agent-harness-kit] MCP server starting (stdio)
+`);
+  await startMcpServer(config, cwd2);
+}
+
+// src/commands/status.ts
+import Table from "cli-table3";
+import pc7 from "picocolors";
+var STATUS_COLOR = {
+  pending: (s) => pc7.dim(s),
+  in_progress: (s) => pc7.cyan(s),
+  done: (s) => pc7.green(s),
+  blocked: (s) => pc7.red(s)
+};
+async function runStatus(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  const db = openDB(config, cwd2);
+  try {
+    const tasks = db.getTasks();
+    const summary = db.getStatusSummary();
+    if (opts.json) {
+      const actions = tasks.map((t) => ({
+        ...t,
+        actions: db.getActionsForTask(t.id),
+        acceptance: db.getTaskAcceptance(t.id)
+      }));
+      console.log(JSON.stringify({ tasks: actions, summary }, null, 2));
+      return;
+    }
+    if (tasks.length === 0) {
+      console.log(pc7.dim("No tasks yet. Run: ahk task add"));
+      return;
+    }
+    const table = new Table({
+      head: ["ID", "Slug", "Title", "Status", "Assigned", "Started"].map((h) => pc7.bold(h)),
+      style: { head: [], border: [] }
+    });
+    for (const t of tasks) {
+      const colorFn = STATUS_COLOR[t.status] ?? ((s) => s);
+      table.push([
+        String(t.id),
+        t.slug,
+        t.title.slice(0, 40),
+        colorFn(t.status),
+        t.assigned_to ?? "\u2014",
+        t.started_at ? t.started_at.slice(0, 10) : "\u2014"
+      ]);
+    }
+    console.log(table.toString());
+    const inProgress = tasks.filter((t) => t.status === "in_progress");
+    if (inProgress.length > 0) {
+      console.log("");
+      console.log(pc7.bold("Active actions:"));
+      for (const t of inProgress) {
+        const actions = db.getActionsForTask(t.id);
+        const active = actions.filter((a) => a.status === "in_progress");
+        for (const a of active) {
+          console.log(`  ${pc7.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
+        }
+      }
+    }
+    console.log("");
+    const parts = summary.map((s) => {
+      const fn = STATUS_COLOR[s.status] ?? ((x) => x);
+      return `${fn(s.status)}: ${s.total}`;
+    });
+    console.log(pc7.dim("Tasks \u2014 ") + parts.join(pc7.dim(" | ")));
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join11, resolve as resolve8 } from "path";
+import pc8 from "picocolors";
+async function runSync(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  const direction = opts.direction ?? "both";
+  const featureListPath = resolve8(join11(cwd2, config.storage.dir, "feature_list.json"));
+  const db = openDB(config, cwd2);
+  try {
+    if (direction === "in" || direction === "both") {
+      await syncIn(featureListPath, db, opts.dryRun ?? false);
+    }
+    if (direction === "out" || direction === "both") {
+      syncOut(db, cwd2, opts.dryRun ?? false);
+    }
+  } finally {
+    db.close();
+  }
+}
+async function syncIn(featureListPath, db, dryRun) {
+  if (!existsSync7(featureListPath)) {
+    console.log(pc8.dim(`feature_list.json not found at ${featureListPath} \u2014 skipping in-sync`));
+    return;
+  }
+  let seeds;
+  try {
+    seeds = JSON.parse(readFileSync6(featureListPath, "utf8"));
+  } catch (err) {
+    console.error(pc8.red(`Failed to parse feature_list.json: ${err}`));
+    process.exit(1);
+  }
+  if (dryRun) {
+    console.log(pc8.bold("Dry run \u2014 in-sync (feature_list.json \u2192 SQLite):"));
+    for (const t of seeds) {
+      const existing = db.getTaskBySlug(t.slug);
+      console.log(`  ${existing ? pc8.dim("skip") : pc8.green("add ")} ${t.slug}`);
+    }
+    return;
+  }
+  const result = db.syncFromFeatureList(seeds);
+  console.log(pc8.green(`\u2713 In-sync: ${result.added} added, ${result.skipped} already existed`));
+}
+function syncOut(db, cwd2, dryRun) {
+  if (dryRun) {
+    const tasks = db.getTasks();
+    console.log(pc8.bold("Dry run \u2014 out-sync (SQLite \u2192 feature_list.json):"));
+    console.log(`  ${tasks.length} tasks would be written`);
+    return;
+  }
+  db.writeFeatureList(cwd2);
+  console.log(pc8.green("\u2713 Out-sync: feature_list.json updated"));
+}
+
+// src/commands/task/add.ts
+import * as p4 from "@clack/prompts";
+import pc9 from "picocolors";
+async function runTaskAdd(cwd2) {
+  p4.intro(pc9.bold("agent-harness-kit \u2014 add task"));
+  const titleVal = await p4.text({
+    message: "Task title",
+    validate: (v) => v.trim() ? void 0 : "Title is required"
+  });
+  if (p4.isCancel(titleVal)) {
+    p4.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const title = titleVal.trim();
+  const descVal = await p4.text({
+    message: "Description (what and why)",
+    placeholder: "Optional"
+  });
+  if (p4.isCancel(descVal)) {
+    p4.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const description = descVal.trim();
+  const acceptance = [];
+  p4.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+  while (true) {
+    const val = await p4.text({ message: ">", placeholder: "Criterion (or press Enter to finish)" });
+    if (p4.isCancel(val) || !val || !val.trim()) break;
+    acceptance.push(val.trim());
+  }
+  const spinner5 = p4.spinner();
+  spinner5.start("Saving...");
+  try {
+    const config = await loadConfig(cwd2);
+    const db = openDB(config, cwd2);
+    const slug = slugify(title);
+    const task2 = db.addTask({ slug, title, description: description || void 0, acceptance });
+    db.writeFeatureList(cwd2);
+    db.close();
+    spinner5.stop("");
+    console.log(pc9.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
+    console.log(pc9.cyan("\u2192") + " " + pc9.cyan("ahk status") + " to see all tasks");
+  } catch (err) {
+    spinner5.stop(pc9.red("Failed"));
+    p4.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 existsSync8 } from "fs";
+import { resolve as resolve9 } from "path";
+import pc10 from "picocolors";
+async function runTaskDone(cwd2, idOrSlug) {
+  const config = await loadConfig(cwd2);
+  if (config.health.required) {
+    const scriptPath = resolve9(cwd2, config.health.scriptPath);
+    if (existsSync8(scriptPath)) {
+      const result = spawnSync2("bash", [scriptPath], { cwd: cwd2, stdio: "pipe", encoding: "utf8" });
+      if (result.status !== 0) {
+        console.error(pc10.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);
+      }
+    }
+  }
+  const db = openDB(config, cwd2);
+  try {
+    const parsed = parseInt(idOrSlug, 10);
+    const isId = !isNaN(parsed);
+    const task2 = isId ? db.getTaskById(parsed) : db.getTaskBySlug(idOrSlug);
+    if (!task2) {
+      console.error(pc10.red(`Task not found: ${idOrSlug}`));
+      process.exit(1);
+    }
+    if (task2.status === "done") {
+      console.log(pc10.dim(`Task #${task2.id} is already done.`));
+      return;
+    }
+    db.updateTaskStatus(task2.id, "done");
+    db.writeFeatureList(cwd2);
+    console.log(pc10.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/task/list.ts
+import Table2 from "cli-table3";
+import pc11 from "picocolors";
+var STATUS_COLOR2 = {
+  pending: (s) => pc11.dim(s),
+  in_progress: (s) => pc11.cyan(s),
+  done: (s) => pc11.green(s),
+  blocked: (s) => pc11.red(s)
+};
+async function runTaskList(cwd2, opts) {
+  const config = await loadConfig(cwd2);
+  const db = openDB(config, cwd2);
+  try {
+    const validStatuses = ["pending", "in_progress", "done", "blocked"];
+    const filterStatus = opts.status && validStatuses.includes(opts.status) ? opts.status : void 0;
+    const tasks = filterStatus ? db.getTasks(filterStatus) : db.getTasks();
+    if (opts.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      return;
+    }
+    if (tasks.length === 0) {
+      console.log(pc11.dim("No tasks" + (filterStatus ? ` with status: ${filterStatus}` : "") + "."));
+      return;
+    }
+    const table = new Table2({
+      head: ["ID", "Slug", "Title", "Status"].map((h) => pc11.bold(h)),
+      style: { head: [], border: [] }
+    });
+    for (const t of tasks) {
+      const colorFn = STATUS_COLOR2[t.status] ?? ((s) => s);
+      table.push([String(t.id), t.slug, t.title.slice(0, 50), colorFn(t.status)]);
+    }
+    console.log(table.toString());
+  } finally {
+    db.close();
+  }
+}
+
+// src/core/package-data.ts
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2(import.meta.url);
+var pkg = require2("@/../package.json");
+
+// src/core/update-check.ts
+import pc12 from "picocolors";
+var REGISTRY_URL = `https://registry.npmjs.org/${pkg.name}/latest`;
+var TIMEOUT_MS = 2500;
+function checkForUpdate(currentVersion) {
+  return new Promise((resolve10) => {
+    const timer = setTimeout(() => resolve10(null), TIMEOUT_MS);
+    fetch(REGISTRY_URL).then((res) => res.json()).then((data) => {
+      clearTimeout(timer);
+      const latest = data.version;
+      resolve10(isNewer(latest, currentVersion) ? { current: currentVersion, latest } : null);
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve10(null);
+    });
+  });
+}
+function printUpdateMessage({ current, latest }) {
+  const lines = [
+    `  Update available ${pc12.dim(current)} \u2192 ${pc12.green(latest)}  `,
+    `  Run: ${pc12.cyan(`npm i -g ${pkg.name}@latest`)}          `
+  ];
+  const width = Math.max(...lines.map((l) => stripAnsi(l).length));
+  const border = "\u2500".repeat(width);
+  console.log();
+  console.log(pc12.yellow(`\u250C${border}\u2510`));
+  for (const line of lines) {
+    const pad = width - stripAnsi(line).length;
+    console.log(pc12.yellow("\u2502") + line + " ".repeat(pad) + pc12.yellow("\u2502"));
+  }
+  console.log(pc12.yellow(`\u2514${border}\u2518`));
+  console.log();
+}
+function isNewer(latest, current) {
+  const toNum = (v) => v.split(".").map(Number);
+  const [lMaj, lMin, lPat] = toNum(latest);
+  const [cMaj, cMin, cPat] = toNum(current);
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPat > cPat;
+}
+function stripAnsi(str2) {
+  return str2.replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+// src/cli.ts
+var cwd = process.cwd();
+var updateCheck = checkForUpdate(pkg.version);
+var program = new Command();
+program.name("ahk").description("agent-harness-kit \u2014 CLI scaffolding for multi-agent harness systems").version(pkg.version, "-v, --version");
+program.command("init").description("Scaffold a harness interactively in the current directory").option("--name <name>", "Project name (skip prompt)").option("--provider <provider>", "AI provider: claude-code | opencode (skip prompt)").option("--docs <path>", "Docs folder path (skip prompt)").option("--tasks <adapter>", "Task adapter: local | jira | linear (skip prompt)").action(async (opts) => {
+  await runInit(cwd, opts);
 });
-// ─── build ────────────────────────────────────────────────────────────────────
-program
-    .command('build')
-    .description('Regenerate AGENTS.md and provider files from agent-harness-kit.config.ts')
-    .option('--watch', 'Rebuild on config changes')
-    .action(async (opts) => {
-    await runBuild(cwd, opts);
+program.command("build").description("Regenerate AGENTS.md and provider files from agent-harness-kit.config.ts").option("--watch", "Rebuild on config changes").action(async (opts) => {
+  await runBuild(cwd, opts);
 });
-// ─── health ───────────────────────────────────────────────────────────────────
-program
-    .command('health')
-    .description('Run health.sh and report result')
-    .action(async () => {
-    await runHealth(cwd);
+program.command("health").description("Run health.sh and report result").action(async () => {
+  await runHealth(cwd);
 });
-// ─── status ───────────────────────────────────────────────────────────────────
-program
-    .command('status')
-    .description('Show task table and active actions')
-    .option('--json', 'Output as JSON')
-    .action(async (opts) => {
-    await runStatus(cwd, opts);
+program.command("status").description("Show task table and active actions").option("--json", "Output as JSON").action(async (opts) => {
+  await runStatus(cwd, opts);
 });
-// ─── sync ─────────────────────────────────────────────────────────────────────
-program
-    .command('sync')
-    .description('Sync feature_list.json ↔ SQLite')
-    .option('--dry-run', 'Show what would change without applying')
-    .option('--direction <direction>', 'in | out | both (default: both)')
-    .action(async (opts) => {
-    await runSync(cwd, { dryRun: opts['dry-run'], direction: opts.direction });
+program.command("sync").description("Sync feature_list.json \u2194 SQLite").option("--dry-run", "Show what would change without applying").option("--direction <direction>", "in | out | both (default: both)").action(async (opts) => {
+  await runSync(cwd, { dryRun: opts["dry-run"], direction: opts.direction });
 });
-// ─── serve ────────────────────────────────────────────────────────────────────
-program
-    .command('serve')
-    .description('Start the MCP server (stdio)')
-    .option('--port <port>', 'Port hint stored in config (default: 3742)', parseInt)
-    .action(async (opts) => {
-    await runServe(cwd, { port: opts.port });
+program.command("serve").description("Start the MCP server (stdio)").option("--port <port>", "Port hint stored in config (default: 3742)", parseInt).action(async (opts) => {
+  await runServe(cwd, { port: opts.port });
 });
-// ─── task ─────────────────────────────────────────────────────────────────────
-const task = program.command('task').description('Manage tasks');
-task
-    .command('add')
-    .description('Add a task interactively')
-    .action(async () => {
-    await runTaskAdd(cwd);
+var task = program.command("task").description("Manage tasks");
+task.command("add").description("Add a task interactively").action(async () => {
+  await runTaskAdd(cwd);
 });
-task
-    .command('list')
-    .description('List tasks')
-    .option('--status <status>', 'Filter by status: pending | in_progress | done | blocked')
-    .option('--json', 'Output as JSON')
-    .action(async (opts) => {
-    await runTaskList(cwd, opts);
+task.command("list").description("List tasks").option("--status <status>", "Filter by status: pending | in_progress | done | blocked").option("--json", "Output as JSON").action(async (opts) => {
+  await runTaskList(cwd, opts);
 });
-task
-    .command('done <id|slug>')
-    .description('Mark a task as done')
-    .action(async (idOrSlug) => {
-    await runTaskDone(cwd, idOrSlug);
+task.command("done <id|slug>").description("Mark a task as done").action(async (idOrSlug) => {
+  await runTaskDone(cwd, idOrSlug);
 });
-// ─── dashboard ────────────────────────────────────────────────────────────────
-program
-    .command('dashboard')
-    .description('Open web dashboard to visualize harness data')
-    .option('-p, --port <port>', 'Port to listen on', '4242')
-    .option('--no-open', 'Do not open browser automatically')
-    .action(async (opts) => {
-    await runDashboard(cwd, { port: parseInt(opts.port), open: opts.open });
+program.command("dashboard").description("Open web dashboard to visualize harness data").option("-p, --port <port>", "Port to listen on", "4242").option("--no-open", "Do not open browser automatically").action(async (opts) => {
+  await runDashboard(cwd, { port: parseInt(opts.port), open: opts.open });
 });
-// ─── migrate ──────────────────────────────────────────────────────────────────
-program
-    .command('migrate')
-    .description('Migrate provider-specific files to a different provider')
-    .option('--to <provider>', 'Target provider: claude-code | opencode')
-    .action(async (opts) => {
-    await runMigrate(cwd, opts);
+program.command("migrate").description("Migrate provider-specific files to a different provider").option("--to <provider>", "Target provider: claude-code | opencode").action(async (opts) => {
+  await runMigrate(cwd, opts);
 });
-// ─── export ───────────────────────────────────────────────────────────────────
-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("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.hook("postAction", async () => {
+  const update = await updateCheck;
+  if (update) printUpdateMessage(update);
 });
 program.parse();
 //# sourceMappingURL=cli.js.map