@cardor/agent-harness-kit 0.18.0 → 1.1.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 import {
   loadConfig
-} from "./chunk-LQ7SDMK6.js";
+} from "./chunk-X7FOJOZB.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -155,6 +155,7 @@ actions.record_tool  actionId toolName [argsJson] [summary] \u2192 log a tool ca
 actions.record_file  actionId filePath operation [notes]   \u2192 log a file touch to the Files dashboard
 actions.complete     actionId summary                       \u2192 close the action
 actions.get          taskId                                 \u2192 full action history for a task
+tasks.add            title [slug] [description] [acceptance] \u2192 create a new task from natural language
 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
@@ -199,6 +200,90 @@ If orchestrating: Agent definition files in your provider's agents directory
 \`\`\`
 `;
 }
+function claudeMd(config) {
+  const { name, description, docsPath } = config.project;
+  const port = config.tools.mcp.port;
+  return `# CLAUDE.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, blockers, ...)
+actions.record_tool  actionId toolName [argsJson] [summary] \u2192 log a tool call to the Tools dashboard
+actions.record_file  actionId filePath operation [notes]   \u2192 log a file touch to the Files dashboard
+actions.complete     actionId summary                       \u2192 close the action
+actions.get          taskId                                 \u2192 full action history for a task
+tasks.add            title [slug] [description] [acceptance] \u2192 create a new task from natural language
+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
+tasks.acceptance.update criterionId                        \u2192 mark an acceptance criterion as met
+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
+   - No pending tasks? \u2192 ask user, infer fields, call tasks.add, then tasks.claim
+
+2. WORK  (lead \u2192 explorer \u2192 builder \u2192 reviewer)
+   - Each agent calls actions.start(taskId, agentName) \u2192 actionId
+   - After EVERY tool call: actions.record_tool(actionId, toolName, args, summary)
+   - After EVERY file change: actions.record_file(actionId, filePath, operation, notes)
+   - 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 .claude/agents/
+\`\`\`
+`;
+}
 function configTs(params) {
   return `import { defineHarness } from '@cardor/agent-harness-kit'
 
@@ -219,9 +304,13 @@ export default defineHarness({
     custom:   [],
   },
 
+  // SQLite (default). Switch to postgres/mysql by changing database.type.
+  // database: { type: 'postgres', connectionString: process.env.DATABASE_URL },
+  // database: { type: 'mysql',    connectionString: process.env.DATABASE_URL },
+  database: { type: 'sqlite', path: '.harness/harness.db' },
+
   storage: {
     dir:    '.harness',
-    dbPath: '.harness/harness.db',
     tasks:  { adapter: '${params.tasksAdapter}' },
     sections: {
       toolsUsed:     true,
@@ -297,6 +386,7 @@ var ClaudeCodeMaterializer = class {
       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);
     }
@@ -331,6 +421,7 @@ No tasks in progress.
       writeFileSync3(abs, content, "utf8");
     };
     write("AGENTS.md", agentsMd(config));
+    write("CLAUDE.md", claudeMd(config));
     const projectName = config.project.name;
     const allowedPaths = (config.agents.explorer.allowedPaths ?? []).join(", ");
     const writablePaths = (config.agents.builder.writablePaths ?? []).join(", ");
@@ -463,7 +554,6 @@ 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",
   ".js": "application/javascript; charset=utf-8",
@@ -486,130 +576,54 @@ function fileResponse(filePath) {
 }
 function startDashboardServer(db, dbPath, staticPath, port) {
   const app = new Hono();
+  const { tasks, actions, stats } = db;
   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();
+  app.get("/api/stats", async (c) => {
+    const summary = await tasks.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 });
+    const counts = await stats.getCounts();
+    return c.json({ byStatus, ...counts });
   });
   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", async (c) => {
+    return c.json(await tasks.getAllWithAcceptanceCounts());
   });
-  app.get("/api/tasks/:id", (c) => {
+  app.get("/api/tasks/:id", async (c) => {
     const id = parseInt(c.req.param("id"));
-    const task2 = db.getTaskById(id);
+    const task2 = await tasks.getById(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 });
+    const acceptance = await tasks.getAcceptance(id);
+    const taskActions = await actions.getWithDetails(id);
+    return c.json({ ...task2, acceptance, actions: taskActions });
   });
-  app.get("/api/tools/top", (c) => {
+  app.get("/api/tools/top", async (c) => {
     const limit = parseInt(c.req.query("limit") ?? "20");
-    return c.json(db.getTopTools(limit));
+    return c.json(await actions.getTopTools(limit));
   });
-  app.get("/api/tools/recent", (c) => {
+  app.get("/api/tools/recent", async (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);
+    return c.json(await stats.getRecentTools(limit));
   });
-  app.get("/api/files/top", (c) => {
+  app.get("/api/files/top", async (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);
+    return c.json(await stats.getTopFiles(limit));
   });
-  app.get("/api/files/recent", (c) => {
+  app.get("/api/files/recent", async (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);
+    return c.json(await stats.getRecentFiles(limit));
   });
-  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/agents/stats", async (c) => {
+    return c.json(await stats.getAgentStats());
   });
-  app.get("/api/timeline", (c) => {
+  app.get("/api/timeline", async (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);
+    return c.json(await stats.getTimeline(limit));
   });
   app.get("/*", (c) => {
     const urlPath = c.req.path;
@@ -646,14 +660,17 @@ function startDashboardServer(db, dbPath, staticPath, port) {
       }
     }, 150);
   };
-  const walPath = `${dbPath}-wal`;
-  const watchTarget = existsSync5(walPath) ? walPath : dbPath;
-  const watcher = watch2(watchTarget, broadcast);
+  let watcher = null;
+  if (dbPath) {
+    const walPath = `${dbPath}-wal`;
+    const watchTarget = existsSync5(walPath) ? walPath : dbPath;
+    watcher = watch2(watchTarget, broadcast);
+  }
   return {
     url: `http://localhost:${port}`,
     close: () => {
       clearTimeout(debounce);
-      watcher.close();
+      watcher?.close();
       wss.close();
       httpServer.close();
     }
@@ -665,264 +682,408 @@ 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
-);
+// src/core/repositories/ActionRepository.ts
+var ActionRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async create(id, taskId, agent, now) {
+    await this.driver.exec(
+      `INSERT INTO actions (id, task_id, agent, status, created_at) VALUES (?, ?, ?, 'in_progress', ?)`,
+      [id, taskId, agent, now]
+    );
+  }
+  async complete(actionId, summary, now) {
+    await this.driver.exec(
+      `UPDATE actions SET status = 'completed', completed_at = ?, summary = ? WHERE id = ?`,
+      [now, summary, actionId]
+    );
+  }
+  async closeOrphaned(taskId, now) {
+    return this.driver.exec(
+      `UPDATE actions SET status = 'completed', completed_at = ?, summary = 'Auto-closed: task marked done' WHERE task_id = ? AND status = 'in_progress'`,
+      [now, taskId]
+    );
+  }
+  async getById(actionId) {
+    return this.driver.queryOne(`SELECT * FROM actions WHERE id = ?`, [actionId]);
+  }
+  async getForTask(taskId) {
+    return this.driver.query(
+      `SELECT * FROM actions WHERE task_id = ? ORDER BY created_at`,
+      [taskId]
+    );
+  }
+  async getAll() {
+    return this.driver.query(`SELECT * FROM actions ORDER BY created_at`);
+  }
+  async getWithDetails(taskId) {
+    const actions = await this.getForTask(taskId);
+    return Promise.all(
+      actions.map(async (action) => ({
+        ...action,
+        sections: await this.getSections(action.id),
+        files: await this.getFiles(action.id),
+        tools: await this.getTools(action.id)
+      }))
+    );
+  }
+  // ─── Sections ─────────────────────────────────────────────────────────────
+  async addSection(actionId, sectionType, content, now) {
+    await this.driver.exec(
+      `INSERT INTO action_sections (action_id, section_type, content, created_at) VALUES (?, ?, ?, ?)`,
+      [actionId, sectionType, content, now]
+    );
+  }
+  async getSections(actionId) {
+    return this.driver.query(
+      `SELECT * FROM action_sections WHERE action_id = ? ORDER BY created_at`,
+      [actionId]
+    );
+  }
+  async getAllSections() {
+    return this.driver.query(`SELECT * FROM action_sections ORDER BY created_at`);
+  }
+  // ─── Files ────────────────────────────────────────────────────────────────
+  async addFile(actionId, filePath, operation, notes) {
+    await this.driver.exec(
+      `INSERT INTO action_files (action_id, file_path, operation, notes) VALUES (?, ?, ?, ?)`,
+      [actionId, filePath, operation, notes]
+    );
+  }
+  async getFiles(actionId) {
+    return this.driver.query(
+      `SELECT * FROM action_files WHERE action_id = ?`,
+      [actionId]
+    );
+  }
+  async getFilesForTask(taskId) {
+    return this.driver.query(
+      `SELECT af.*, a.agent FROM action_files af JOIN actions a ON af.action_id = a.id WHERE a.task_id = ? ORDER BY a.agent, af.operation`,
+      [taskId]
+    );
+  }
+  // ─── Tools ────────────────────────────────────────────────────────────────
+  async addTool(actionId, toolName, argsJson, resultSummary, now) {
+    await this.driver.exec(
+      `INSERT INTO action_tools (action_id, tool_name, args_json, result_summary, called_at) VALUES (?, ?, ?, ?, ?)`,
+      [actionId, toolName, argsJson, resultSummary, now]
+    );
+  }
+  async getTools(actionId) {
+    return this.driver.query(
+      `SELECT * FROM action_tools WHERE action_id = ? ORDER BY called_at`,
+      [actionId]
+    );
+  }
+  async getTopTools(limit) {
+    return this.driver.query(
+      `SELECT tool_name, COUNT(*) as uses FROM action_tools GROUP BY tool_name ORDER BY uses DESC LIMIT ?`,
+      [limit]
+    );
+  }
+};
 
-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
-);
+// src/core/repositories/StatsRepository.ts
+var AGENT_ORDER = ["lead", "explorer", "builder", "reviewer"];
+var StatsRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async getCounts() {
+    const [{ total: totalActions }] = await this.driver.query(
+      `SELECT COUNT(*) as total FROM actions`
+    );
+    const [{ total: totalFiles }] = await this.driver.query(
+      `SELECT COUNT(*) as total FROM action_files`
+    );
+    const [{ total: uniqueTools }] = await this.driver.query(
+      `SELECT COUNT(DISTINCT tool_name) as total FROM action_tools`
+    );
+    const [{ total: activeAgents }] = await this.driver.query(
+      `SELECT COUNT(DISTINCT agent) as total FROM actions WHERE status = 'in_progress'`
+    );
+    return { totalActions, totalFiles, uniqueTools, activeAgents };
+  }
+  async getRecentTools(limit) {
+    return this.driver.query(
+      `SELECT at.*, t.id as task_id, t.title as task_title, t.slug as task_slug, a.agent
+       FROM action_tools at
+       JOIN actions a ON at.action_id = a.id
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY at.called_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getTopFiles(limit) {
+    return this.driver.query(
+      `SELECT
+        file_path,
+        COUNT(*) as total,
+        SUM(CASE WHEN operation='read'     THEN 1 ELSE 0 END) as read,
+        SUM(CASE WHEN operation='created'  THEN 1 ELSE 0 END) as created,
+        SUM(CASE WHEN operation='modified' THEN 1 ELSE 0 END) as modified,
+        SUM(CASE WHEN operation='deleted'  THEN 1 ELSE 0 END) as deleted
+       FROM action_files
+       GROUP BY file_path
+       ORDER BY total DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getRecentFiles(limit) {
+    return this.driver.query(
+      `SELECT af.*, t.id as task_id, t.title as task_title, t.slug as task_slug,
+        a.agent, a.created_at as called_at
+       FROM action_files af
+       JOIN actions a ON af.action_id = a.id
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY a.created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getAgentStats() {
+    const rows = await this.driver.query(
+      `SELECT
+        a.agent,
+        COUNT(*)                                              as actions_total,
+        SUM(CASE WHEN a.status='completed' THEN 1 ELSE 0 END) as actions_done,
+        SUM(CASE WHEN a.status='blocked'   THEN 1 ELSE 0 END) as actions_blocked,
+        COUNT(DISTINCT a.task_id)                             as tasks_worked,
+        COUNT(DISTINCT af.file_path)                          as files_touched
+       FROM actions a
+       LEFT JOIN action_files af ON af.action_id = a.id
+       GROUP BY a.agent
+       ORDER BY actions_total DESC`
+    );
+    return rows.sort((a, b) => {
+      const ai = AGENT_ORDER.indexOf(a.agent);
+      const bi = AGENT_ORDER.indexOf(b.agent);
+      if (ai === -1 && bi === -1) return 0;
+      if (ai === -1) return 1;
+      if (bi === -1) return -1;
+      return ai - bi;
+    });
+  }
+  async getTimeline(limit) {
+    return this.driver.query(
+      `SELECT a.*, t.title as task_title, t.slug as task_slug, t.status as task_status
+       FROM actions a
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY a.created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+};
 
-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
-);
+// src/core/repositories/TaskRepository.ts
+var TaskRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async add(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.driver.insert(
+      `INSERT INTO tasks (slug, title, description, status, created_at) VALUES (?, ?, ?, ?, ?)`,
+      [params.slug, params.title, params.description ?? null, params.status ?? "pending", now]
+    );
+  }
+  async addAcceptance(taskId, criteria) {
+    for (const criterion of criteria) {
+      await this.driver.exec(
+        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`,
+        [taskId, criterion]
+      );
+    }
+  }
+  async getAll(status) {
+    if (status) {
+      return this.driver.query(`SELECT * FROM tasks WHERE status = ? ORDER BY id`, [status]);
+    }
+    return this.driver.query(`SELECT * FROM tasks ORDER BY id`);
+  }
+  async getAllWithAcceptanceCounts() {
+    return this.driver.query(`
+      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
+    `);
+  }
+  async getById(id) {
+    return this.driver.queryOne(`SELECT * FROM tasks WHERE id = ?`, [id]);
+  }
+  async getBySlug(slug) {
+    return this.driver.queryOne(`SELECT * FROM tasks WHERE slug = ?`, [slug]);
+  }
+  async getAcceptance(taskId) {
+    return this.driver.query(
+      `SELECT * FROM task_acceptance WHERE task_id = ?`,
+      [taskId]
+    );
+  }
+  async setStatus(id, status, extra) {
+    if (extra?.started_at) {
+      await this.driver.exec(
+        `UPDATE tasks SET status = ?, started_at = ? WHERE id = ?`,
+        [status, extra.started_at, id]
+      );
+    } else if (extra?.completed_at) {
+      await this.driver.exec(
+        `UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?`,
+        [status, extra.completed_at, id]
+      );
+    } else {
+      await this.driver.exec(`UPDATE tasks SET status = ? WHERE id = ?`, [status, id]);
+    }
+  }
+  async claim(id, agent, now) {
+    return this.driver.exec(
+      `UPDATE tasks SET status = 'in_progress', assigned_to = ?, started_at = ? WHERE id = ? AND status = 'pending'`,
+      [agent, now, id]
+    );
+  }
+  async markAcceptanceMet(criterionId) {
+    await this.driver.exec(`UPDATE task_acceptance SET met = 1 WHERE id = ?`, [criterionId]);
+  }
+  async getStatusSummary() {
+    return this.driver.query(
+      `SELECT status, COUNT(*) as total FROM tasks GROUP BY status`
+    );
+  }
+};
 
-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);
-`;
+// src/core/db.ts
 var HarnessDB = class {
-  db;
+  tasks;
+  actions;
+  stats;
+  driver;
   config;
-  constructor(dbPath, config) {
+  constructor(driver, config) {
+    this.driver = driver;
     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({
+    this.tasks = new TaskRepository(driver);
+    this.actions = new ActionRepository(driver);
+    this.stats = new StatsRepository(driver);
+  }
+  // ─── Tasks (public facade — delegates to TaskRepository) ──────────────────
+  async addTask(params) {
+    const taskId = await this.tasks.add({
       slug: params.slug,
       title: params.title,
-      description: params.description ?? null,
-      created_at: now
+      description: params.description
     });
-    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);
-      }
+      await this.tasks.addAcceptance(taskId, params.acceptance);
     }
-    this.regenerateCurrentMd();
-    return this.getTaskById(taskId);
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(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();
+  async getTasks(status) {
+    return this.tasks.getAll(status);
   }
-  getTaskById(id) {
-    return this.db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(id) ?? null;
+  async getTaskById(id) {
+    return this.tasks.getById(id);
   }
-  getTaskBySlug(slug) {
-    return this.db.prepare(`SELECT * FROM tasks WHERE slug = ?`).get(slug) ?? null;
+  async getTaskBySlug(slug) {
+    return this.tasks.getBySlug(slug);
   }
-  getTaskAcceptance(taskId) {
-    return this.db.prepare(`SELECT * FROM task_acceptance WHERE task_id = ?`).all(taskId);
+  async getTaskAcceptance(taskId) {
+    return this.tasks.getAcceptance(taskId);
   }
-  updateTaskStatus(idOrSlug, status) {
+  async updateTaskStatus(idOrSlug, status) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const task2 = typeof idOrSlug === "number" ? this.getTaskById(idOrSlug) : this.getTaskBySlug(idOrSlug);
+    const task2 = typeof idOrSlug === "number" ? await this.tasks.getById(idOrSlug) : await this.tasks.getBySlug(idOrSlug);
     if (!task2) throw new Error(`Task not found: ${idOrSlug}`);
     if (status === "in_progress" && !task2.started_at) {
-      this.db.prepare(
-        `UPDATE tasks SET status = ?, started_at = ? WHERE id = ?`
-      ).run(status, now, task2.id);
+      await this.tasks.setStatus(task2.id, status, { started_at: now });
     } else if (status === "done") {
-      this.db.prepare(
-        `UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?`
-      ).run(status, now, task2.id);
+      await this.tasks.setStatus(task2.id, status, { completed_at: now });
     } else {
-      this.db.prepare(`UPDATE tasks SET status = ? WHERE id = ?`).run(status, task2.id);
+      await this.tasks.setStatus(task2.id, status);
     }
-    this.regenerateCurrentMd();
-    return this.getTaskById(task2.id);
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(task2.id);
   }
-  claimTask(id, agent) {
+  async 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);
+    return this.driver.transaction(async (tx) => {
+      const txTasks = new TaskRepository(tx);
+      const changed = await txTasks.claim(id, agent, now);
+      if (!changed) return null;
+      const task2 = await txTasks.getById(id);
       if (!task2 || task2.status !== "in_progress" || task2.assigned_to !== agent) return null;
-      this.regenerateCurrentMd();
+      await this.regenerateCurrentMd();
       return task2;
-    } catch (err) {
-      this.db.exec("ROLLBACK");
-      throw err;
-    }
+    });
   }
-  // ─── Actions ──────────────────────────────────────────────────────────────
-  startAction(taskId, agent) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+  async markAcceptanceMet(criterionId) {
+    return this.tasks.markAcceptanceMet(criterionId);
+  }
+  async getStatusSummary() {
+    return this.tasks.getStatusSummary();
+  }
+  // ─── Actions (public facade — delegates to ActionRepository) ──────────────
+  async startAction(taskId, agent) {
     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();
+    await this.actions.create(id, taskId, agent, now);
+    await this.regenerateCurrentMd();
+    return await this.actions.getById(id);
   }
-  completeAction(actionId, summary) {
+  async writeSection(actionId, sectionType, content) {
     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);
-  }
-  closeOrphanedActions(taskId) {
+    await this.actions.addSection(actionId, sectionType, content, now);
+    await this.regenerateCurrentMd();
+  }
+  async completeAction(actionId, summary) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const result = this.db.prepare(
-      `UPDATE actions SET status = 'completed', completed_at = ?, summary = 'Auto-closed: task marked done'
-         WHERE task_id = ? AND status = 'in_progress'`
-    ).run(now, taskId);
-    return result.changes;
-  }
-  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) {
+    await this.actions.complete(actionId, summary, now);
+    await this.regenerateCurrentMd();
+    return await this.actions.getById(actionId);
+  }
+  async closeOrphanedActions(taskId) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    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();
+    return this.actions.closeOrphaned(taskId, now);
+  }
+  async getAction(actionId) {
+    return this.actions.getById(actionId);
+  }
+  async getActionsForTask(taskId) {
+    return this.actions.getForTask(taskId);
+  }
+  async getActionSections(actionId) {
+    return this.actions.getSections(actionId);
+  }
+  async recordFile(actionId, filePath, operation, notes) {
+    return this.actions.addFile(actionId, filePath, operation, notes ?? null);
+  }
+  async recordTool(actionId, toolName, argsJson, resultSummary) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.actions.addTool(actionId, toolName, argsJson ?? null, resultSummary ?? null, now);
+  }
+  async getFilesForTask(taskId) {
+    return this.actions.getFilesForTask(taskId);
+  }
+  async getTopTools(limit = 10) {
+    return this.actions.getTopTools(limit);
   }
   // ─── current.md fallback ──────────────────────────────────────────────────
-  regenerateCurrentMd() {
+  async 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 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 -->
 `;
@@ -936,7 +1097,7 @@ var HarnessDB = class {
       md += `## No tasks in progress
 
 `;
-      const pending = this.getTasks("pending");
+      const pending = await this.tasks.getAll("pending");
       if (pending.length > 0) {
         md += `### Next pending tasks
 `;
@@ -958,15 +1119,15 @@ var HarnessDB = class {
         md += `- **Started:** ${task2.started_at ?? "unknown"}
 
 `;
-        const actions = this.getActionsForTask(task2.id);
-        if (actions.length > 0) {
+        const taskActions = await this.actions.getForTask(task2.id);
+        if (taskActions.length > 0) {
           md += `## Actions this session
 `;
           md += `| Agent    | Status      | Summary                          | Started     |
 `;
           md += `|----------|-------------|----------------------------------|-------------|
 `;
-          for (const a of actions) {
+          for (const a of taskActions) {
             const started = a.created_at.slice(11, 16);
             const summary = (a.summary ?? "").slice(0, 34).padEnd(34);
             md += `| ${a.agent.padEnd(8)} | ${a.status.padEnd(11)} | ${summary} | ${started}       |
@@ -975,7 +1136,7 @@ var HarnessDB = class {
           md += `
 `;
         }
-        const acceptance = this.getTaskAcceptance(task2.id);
+        const acceptance = await this.tasks.getAcceptance(task2.id);
         if (acceptance.length > 0) {
           md += `## Acceptance Criteria
 `;
@@ -990,63 +1151,77 @@ var HarnessDB = class {
     }
     writeFileSync5(mdPath, md, "utf8");
   }
-  // ─── Raw query (dashboard / analytics) ───────────────────────────────────
-  queryRaw(sql, ...params) {
-    return this.db.prepare(sql).all(...params);
+  // ─── Raw query escape hatch ───────────────────────────────────────────────
+  async queryRaw(sql, ...params) {
+    return this.driver.query(sql, params);
   }
   // ─── Export helpers ───────────────────────────────────────────────────────
-  exportJson() {
+  async 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()
+      tasks: await this.tasks.getAll(),
+      actions: await this.actions.getAll(),
+      sections: await this.actions.getAllSections()
     };
   }
-  close() {
-    this.db.close();
+  async close() {
+    await this.driver.close();
   }
   // ─── feature_list.json sync ───────────────────────────────────────────────
-  syncFromFeatureList(tasks) {
+  async syncFromFeatureList(seeds) {
     let added = 0;
     let skipped = 0;
-    for (const t of tasks) {
-      if (this.getTaskBySlug(t.slug)) {
+    for (const t of seeds) {
+      if (await this.tasks.getBySlug(t.slug)) {
         skipped++;
         continue;
       }
-      this.addTask(t);
+      await this.addTask(t);
       added++;
     }
     return { added, skipped };
   }
-  markAcceptanceMet(criterionId) {
-    this.db.prepare(`UPDATE task_acceptance SET met = 1 WHERE id = ?`).run(criterionId);
-  }
-  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
-    }));
+  async writeFeatureList(cwd2) {
+    const allTasks = await this.tasks.getAll();
+    const list = await Promise.all(
+      allTasks.map(async (t) => ({
+        slug: t.slug,
+        title: t.title,
+        description: t.description ?? void 0,
+        acceptance: (await this.tasks.getAcceptance(t.id)).map((a) => a.criterion),
+        status: t.status
+      }))
+    );
     const path = 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);
+async function openDB(config, cwd2) {
+  const dbConfig = config.database;
+  let driver;
+  if (dbConfig.type === "postgres") {
+    const { PostgresDriver } = await import("./postgres-TYINLEAT.js");
+    driver = new PostgresDriver(dbConfig);
+  } else if (dbConfig.type === "mysql") {
+    const { MySQLDriver } = await import("./mysql-IMDWH2CU.js");
+    driver = new MySQLDriver(dbConfig);
+  } else {
+    const { SQLiteDriver } = await import("./sqlite-5R6LB3RX.js");
+    if (dbConfig.type !== "sqlite") {
+      throw new Error("Invalid database type");
+    }
+    driver = new SQLiteDriver(resolve4(cwd2, dbConfig.path));
+  }
+  await driver.ensureSchema();
+  return new HarnessDB(driver, 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 db = await openDB(config, cwd2);
+  const dbPath = config.database.type === "sqlite" ? resolve5(cwd2, config.database.path) : null;
   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))}`);
@@ -1072,10 +1247,10 @@ async function runExport(cwd2, opts) {
     process.exit(1);
   }
   const config = await loadConfig(cwd2);
-  const db = openDB(config, cwd2);
+  const db = await openDB(config, cwd2);
   try {
     if (opts.json) {
-      const data = db.exportJson();
+      const data = await db.exportJson();
       const out = JSON.stringify(data, null, 2) + "\n";
       if (opts.output) {
         writeFileSync6(opts.output, out, "utf8");
@@ -1089,7 +1264,7 @@ async function runExport(cwd2, opts) {
       process.exit(1);
     }
   } finally {
-    db.close();
+    await db.close();
   }
 }
 
@@ -1112,9 +1287,15 @@ async function runHealth(cwd2) {
     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`);
+  let dbOk;
+  if (config.database.type === "sqlite") {
+    const dbPath = resolve6(cwd2, config.database.path);
+    dbOk = existsSync6(dbPath);
+    checkLine("checking DB", dbOk, `${config.database.path} reachable`);
+  } else {
+    dbOk = true;
+    checkLine("checking DB", true, `${config.database.type}://${config.database.connectionString.replace(/:[^:@]*@/, ":***@")} configured`);
+  }
   if (!dbOk) allOk = false;
   const agentsDir = config.provider === "claude-code" ? ".claude/agents" : ".opencode/agents";
   const agentNames = ["lead", "explorer", "builder", "reviewer"];
@@ -1166,9 +1347,59 @@ async function runHealth(cwd2) {
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
 import { homedir } from "os";
 import { join as join10 } from "path";
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import pc6 from "picocolors";
 
+// src/schema/init.ts
+import * as v from "valibot";
+var initNameSchema = v.pipe(
+  v.string(),
+  v.nonEmpty("Project name is required"),
+  v.minLength(3, "Project name must be at least 3 characters"),
+  v.maxLength(50, "Project name must be at most 50 characters"),
+  v.trim()
+);
+var initDescriptionSchema = v.pipe(
+  v.string(),
+  v.nonEmpty("Description is required"),
+  v.maxLength(300, "Description must be at most 300 characters"),
+  v.trim()
+);
+var initDocsSchema = v.pipe(
+  v.string(),
+  v.nonEmpty("Docs folder path is required"),
+  v.regex(/^[\w\-./]+$/, "Docs folder path can only contain letters, numbers, dashes, underscores, dots, and slashes"),
+  v.trim()
+);
+
+// src/schema/task.ts
+import * as v2 from "valibot";
+var taskTitleSchema = v2.pipe(
+  v2.string(),
+  v2.nonEmpty("Task title is required"),
+  v2.minLength(3, "Task title must be at least 3 characters"),
+  v2.maxLength(100, "Task title must be at most 100 characters")
+);
+var taskDescriptionSchema = v2.pipe(
+  v2.string(),
+  v2.nonEmpty("Description is required"),
+  v2.maxLength(1e3, "Description must be at most 1000 characters")
+);
+
+// src/utils/form.ts
+import * as p2 from "@clack/prompts";
+import * as v3 from "valibot";
+var cliFormWithRetry = async (formFn, schema) => {
+  while (true) {
+    const res = await formFn();
+    const result = v3.safeParse(schema, res);
+    if (result.success) return result.output;
+    const messages = result.issues.map((i) => i.message).join(", ");
+    p2.log.error(messages);
+    p2.log.info("Please try again.\n");
+  }
+};
+
 // src/commands/init-helpers.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 import { join as join9 } from "path";
@@ -1202,9 +1433,9 @@ function applyConfigDefaults(params) {
       reviewer: { instructionsPath: null },
       custom: []
     },
+    database: { type: "sqlite", path: ".harness/harness.db" },
     storage: {
       dir: ".harness",
-      dbPath: ".harness/harness.db",
       tasks: { adapter: params.tasksAdapter },
       sections: {
         toolsUsed: true,
@@ -1267,51 +1498,60 @@ async function runInit(cwd2, flags) {
   if (flags.name) {
     name = flags.name;
   } else {
-    const val = await p2.text({
-      message: "Project name",
-      placeholder: "my-app",
-      ...detectedName && { initialValue: detectedName },
-      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);
+    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 = descVal.trim() || name;
+  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;
   } else {
-    const val = await p2.select({
+    const val = await p3.select({
       message: "AI provider",
       options: [
         { value: "claude-code", label: "Claude Code" },
         { value: "opencode", label: "OpenCode" }
       ]
     });
-    if (p2.isCancel(val)) {
-      p2.cancel("Cancelled.");
+    if (p3.isCancel(val)) {
+      p3.cancel("Cancelled.");
       process.exit(0);
     }
     provider = val;
   }
   let globalInstallation = false;
-  const globalVal = await p2.confirm({
+  const globalVal = await p3.confirm({
     message: "Install globally (to home directory)?",
     initialValue: false
   });
-  if (p2.isCancel(globalVal)) {
-    p2.cancel("Cancelled.");
+  if (p3.isCancel(globalVal)) {
+    p3.cancel("Cancelled.");
     process.exit(0);
   }
   if (globalVal) {
@@ -1321,21 +1561,26 @@ async function runInit(cwd2, flags) {
   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";
+    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)) {
     tasksAdapter = flags.tasks;
   } else {
-    const val = await p2.select({
+    const val = await p3.select({
       message: "Task adapter",
       options: [
         { value: "local", label: "Local (feature_list.json)" },
@@ -1343,50 +1588,54 @@ async function runInit(cwd2, flags) {
         { value: "linear", label: "Linear (coming soon)" }
       ]
     });
-    if (p2.isCancel(val)) {
-      p2.cancel("Cancelled");
+    if (p3.isCancel(val)) {
+      p3.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");
+  const addFirstTask = await p3.confirm({ message: "Add your first task now?", initialValue: true });
+  if (p3.isCancel(addFirstTask)) {
+    p3.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 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 = [];
-    p2.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+    p3.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
     while (true) {
-      const criterionVal = await p2.text({
+      const criterionVal = await p3.text({
         message: ">",
         placeholder: "Criterion (or press Enter to finish)"
       });
-      if (p2.isCancel(criterionVal) || !criterionVal.trim()) break;
+      if (p3.isCancel(criterionVal) || !criterionVal.trim()) break;
       acceptance.push(criterionVal.trim());
     }
     firstTask = { title: taskTitle, description: taskDesc, acceptance };
   }
-  const spinner5 = p2.spinner();
+  const spinner5 = p3.spinner();
   spinner5.start("Scaffolding...");
   try {
     const config = applyConfigDefaults({ name, description, provider, docsPath, tasksAdapter });
@@ -1409,23 +1658,23 @@ async function runInit(cwd2, flags) {
     });
     writeFileSync7(join10(installDir, "agent-harness-kit.config.ts"), configContent, "utf8");
     mkdirSync6(join10(installDir, config.storage.dir), { recursive: true });
-    const db = openDB(config, installDir);
+    const db = await openDB(config, installDir);
     await materializer.scaffold(config, { cwd: installDir, firstTask });
     if (firstTask) {
       const slug = slugify(firstTask.title);
-      db.addTask({
+      await db.addTask({
         slug,
         title: firstTask.title,
         description: firstTask.description,
         acceptance: firstTask.acceptance
       });
     }
-    db.close();
+    await db.close();
     spinner5.stop("");
   } catch (err) {
     spinner5.stop("Failed");
-    p2.log.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
+    p3.log.error(err instanceof Error ? err.message : String(err));
+    throw err;
   }
   const agentHarnessKitDir = globalInstallation ? "home directory" : "current directory";
   console.log(pc6.green(`\u2713 Scaffolded harness in ${agentHarnessKitDir}`));
@@ -1449,7 +1698,7 @@ async function runInit(cwd2, flags) {
 }
 
 // src/commands/migrate.ts
-import * as p3 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 import pc7 from "picocolors";
 async function runMigrate(cwd2, opts) {
   const config = await loadConfig(cwd2);
@@ -1457,15 +1706,15 @@ async function runMigrate(cwd2, opts) {
   if (opts.to && ["claude-code", "opencode"].includes(opts.to)) {
     target = opts.to;
   } else {
-    const val = await p3.select({
+    const val = await p4.select({
       message: "Migrate to provider",
       options: [
         { value: "claude-code", label: "Claude Code" },
         { value: "opencode", label: "OpenCode" }
       ]
     });
-    if (p3.isCancel(val)) {
-      p3.cancel("Cancelled.");
+    if (p4.isCancel(val)) {
+      p4.cancel("Cancelled.");
       process.exit(0);
     }
     target = val;
@@ -1474,17 +1723,17 @@ async function runMigrate(cwd2, opts) {
     console.log(pc7.dim(`Already on ${target} \u2014 nothing to migrate.`));
     return;
   }
-  const spinner5 = p3.spinner();
+  const spinner5 = p4.spinner();
   spinner5.start(`Migrating from ${config.provider} to ${target}...`);
   try {
     const targetMaterializer = getMaterializer(target);
     await targetMaterializer.build(config, cwd2);
     spinner5.stop(pc7.green(`Migrated to ${target}`));
-    p3.log.warn(`Update agent-harness-kit.config.ts: set provider: '${target}'`);
-    p3.log.warn(`Then run: ahk build`);
+    p4.log.warn(`Update agent-harness-kit.config.ts: set provider: '${target}'`);
+    p4.log.warn(`Then run: ahk build`);
   } catch (err) {
     spinner5.stop(pc7.red("Migration failed"));
-    p3.log.error(err instanceof Error ? err.message : String(err));
+    p4.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }
@@ -1492,8 +1741,9 @@ 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 * as p4 from "@clack/prompts";
+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);
@@ -1505,7 +1755,7 @@ async function resetAgentMds(cwd2, provider) {
   try {
     const files = readdirSync(agentDirPath);
     for (const f of files) {
-      if (f.endsWith(".md")) {
+      if (f.endsWith(".md") && AGENT_MD_FILES.includes(f.replace(".md", ""))) {
         existingFiles.push(f);
       }
     }
@@ -1518,11 +1768,11 @@ async function resetAgentMds(cwd2, provider) {
     return;
   }
   for (const file of existingFiles) {
-    const confirm3 = await p4.confirm({
+    const confirm3 = await p5.confirm({
       message: `Remove ${file}?`,
       initialValue: true
     });
-    if (p4.isCancel(confirm3)) {
+    if (p5.isCancel(confirm3)) {
       console.log(pc8.red("  Cancelled by user."));
       return;
     }
@@ -1548,35 +1798,42 @@ async function runReset(cwd2, opts) {
     process.exit(1);
   }
   const storageDir = config.storage.dir || ".harness";
-  const dbPath = resolve7(cwd2, storageDir, "harness.db");
+  const dbPath = config.database.type === "sqlite" ? resolve7(cwd2, config.database.path) : null;
   const featureListPath = resolve7(cwd2, storageDir, "feature_list.json");
   let resetDb = false;
   let resetFeatureList = false;
   let resetAgentMdsFlag = false;
-  if (existsSync8(dbPath)) {
+  if (dbPath && existsSync8(dbPath)) {
     if (opts.force) {
       resetDb = true;
     } else {
-      const confirm3 = await p4.confirm({
-        message: `Delete database (${storageDir}/harness.db)?`,
-        initialValue: true
-      });
-      if (p4.isCancel(confirm3)) {
-        console.log(pc8.red("  Cancelled by user."));
-        return;
+      if (config.database.type !== "sqlite") {
+        console.log(pc8.yellow(`  Skipping DB reset \u2014 database type "${config.database.type}" is not managed by this command.`));
+        resetDb = false;
+      } else {
+        const confirm3 = await p5.confirm({
+          message: `Delete database (${config.database.path})?`,
+          initialValue: true
+        });
+        if (p5.isCancel(confirm3)) {
+          console.log(pc8.red("  Cancelled by user."));
+          return;
+        }
+        resetDb = confirm3;
       }
-      resetDb = confirm3;
     }
+  } 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 (opts.force) {
       resetFeatureList = true;
     } else {
-      const confirm3 = await p4.confirm({
+      const confirm3 = await p5.confirm({
         message: `Delete feature list (${storageDir}/feature_list.json)?`,
         initialValue: true
       });
-      if (p4.isCancel(confirm3)) {
+      if (p5.isCancel(confirm3)) {
         console.log(pc8.red("  Cancelled by user."));
         return;
       }
@@ -1586,12 +1843,12 @@ async function runReset(cwd2, opts) {
   if (opts.provider) {
     resetAgentMdsFlag = true;
   }
-  let changed = false;
-  if (resetDb) {
+  if (resetDb && dbPath) {
     try {
       rmSync(dbPath, { force: true });
-      console.log(pc8.green(`  \u2713 Removed ${storageDir}/harness.db`));
-      changed = true;
+      rmSync(`${dbPath}-wal`, { force: true });
+      rmSync(`${dbPath}-shm`, { force: true });
+      console.log(pc8.green(`  \u2713 Removed ${dbPath}`));
     } catch {
       console.error(pc8.red(`  \u2717 Failed to remove ${dbPath}`));
     }
@@ -1600,7 +1857,6 @@ async function runReset(cwd2, opts) {
     try {
       rmSync(featureListPath, { force: true });
       console.log(pc8.green(`  \u2713 Removed ${storageDir}/feature_list.json`));
-      changed = true;
     } catch {
       console.error(pc8.red(`  \u2717 Failed to remove ${featureListPath}`));
     }
@@ -1763,6 +2019,24 @@ var TOOLS = [
       required: ["criterionId"]
     }
   },
+  {
+    name: "tasks.add",
+    description: "Create a new task in the harness. Use this when the user describes work in natural language. Infer slug, title, description, and acceptance criteria from the conversation. Ask for missing critical info before calling.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short human-readable title for the task" },
+        slug: { type: "string", description: "URL-safe identifier (lowercase, hyphens). Auto-derived from title if omitted." },
+        description: { type: "string", description: "Longer description of the task goal" },
+        acceptance: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of acceptance criteria (plain sentences)"
+        }
+      },
+      required: ["title"]
+    }
+  },
   {
     name: "actions.record_tool",
     description: "Record a tool call made during an action. This is the only way to populate the Tools dashboard. Call once per tool invocation.",
@@ -1779,7 +2053,7 @@ var TOOLS = [
   }
 ];
 async function startMcpServer(config, cwd2) {
-  const db = openDB(config, cwd2);
+  const db = await openDB(config, cwd2);
   const docsPath = resolve8(cwd2, config.project.docsPath);
   const server = new Server(
     { name: "agent-harness-kit", version: VERSION },
@@ -1804,52 +2078,62 @@ async function dispatch(name, args, db, docsPath) {
     case "actions.start": {
       const taskId = num(args, "taskId");
       const agent = str(args, "agent");
-      const action = db.startAction(taskId, agent);
+      const action = await 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);
+      await 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);
+      const action = await 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)
-      }));
+      const actions = await db.getActionsForTask(taskId);
+      const full = await Promise.all(
+        actions.map(async (a) => ({
+          ...a,
+          sections: await 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();
+      const tasks = status ? await db.getTasks(status) : await 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);
+      const task2 = await db.claimTask(id, agent);
       if (!task2) {
         return ok(JSON.stringify({ error: "task_already_claimed", taskId: id }));
       }
       return ok(JSON.stringify(task2));
     }
+    case "tasks.add": {
+      const title = str(args, "title");
+      const slug = args["slug"] ?? slugify(title);
+      const description = args["description"];
+      const acceptance = args["acceptance"];
+      const task2 = await db.addTask({ slug, title, description, acceptance });
+      return ok(JSON.stringify(task2));
+    }
     case "tasks.update": {
       const id = num(args, "id");
       const status = str(args, "status");
       if (status === "done") {
-        db.closeOrphanedActions(id);
+        await db.closeOrphanedActions(id);
       }
-      const task2 = db.updateTaskStatus(id, status);
+      const task2 = await db.updateTaskStatus(id, status);
       return ok(JSON.stringify(task2));
     }
     case "docs.search": {
@@ -1862,12 +2146,12 @@ async function dispatch(name, args, db, docsPath) {
       const filePath = str(args, "filePath");
       const operation = str(args, "operation");
       const notes = args["notes"];
-      db.recordFile(actionId, filePath, operation, notes);
+      await db.recordFile(actionId, filePath, operation, notes);
       return ok(JSON.stringify({ actionId, filePath, operation, recorded: true }));
     }
     case "tasks.acceptance.update": {
       const criterionId = num(args, "criterionId");
-      db.markAcceptanceMet(criterionId);
+      await db.markAcceptanceMet(criterionId);
       return ok(JSON.stringify({ criterionId, met: true }));
     }
     case "actions.record_tool": {
@@ -1875,7 +2159,7 @@ async function dispatch(name, args, db, docsPath) {
       const toolName = str(args, "toolName");
       const argsJson = args["argsJson"];
       const resultSummary = args["resultSummary"];
-      db.recordTool(actionId, toolName, argsJson, resultSummary);
+      await db.recordTool(actionId, toolName, argsJson, resultSummary);
       return ok(JSON.stringify({ actionId, toolName, recorded: true }));
     }
     default:
@@ -1927,14 +2211,14 @@ 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;
+  const v4 = args[key];
+  if (typeof v4 !== "string") throw new Error(`${key} must be a string`);
+  return v4;
 }
 function num(args, key) {
-  const v = args[key];
-  if (typeof v !== "number") throw new Error(`${key} must be a number`);
-  return v;
+  const v4 = args[key];
+  if (typeof v4 !== "number") throw new Error(`${key} must be a number`);
+  return v4;
 }
 
 // src/commands/serve.ts
@@ -1959,16 +2243,18 @@ var STATUS_COLOR = {
 };
 async function runStatus(cwd2, opts) {
   const config = await loadConfig(cwd2);
-  const db = openDB(config, cwd2);
+  const db = await openDB(config, cwd2);
   try {
-    const tasks = db.getTasks();
-    const summary = db.getStatusSummary();
+    const tasks = await db.getTasks();
+    const summary = await db.getStatusSummary();
     if (opts.json) {
-      const actions = tasks.map((t) => ({
-        ...t,
-        actions: db.getActionsForTask(t.id),
-        acceptance: db.getTaskAcceptance(t.id)
-      }));
+      const actions = await Promise.all(
+        tasks.map(async (t) => ({
+          ...t,
+          actions: await db.getActionsForTask(t.id),
+          acceptance: await db.getTaskAcceptance(t.id)
+        }))
+      );
       console.log(JSON.stringify({ tasks: actions, summary }, null, 2));
       return;
     }
@@ -1997,7 +2283,7 @@ async function runStatus(cwd2, opts) {
       console.log("");
       console.log(pc9.bold("Active actions:"));
       for (const t of inProgress) {
-        const actions = db.getActionsForTask(t.id);
+        const actions = await db.getActionsForTask(t.id);
         const active = actions.filter((a) => a.status === "in_progress");
         for (const a of active) {
           console.log(`  ${pc9.cyan(a.agent.padEnd(10))} \u2192 task #${t.id} ${t.slug}`);
@@ -2011,7 +2297,7 @@ async function runStatus(cwd2, opts) {
     });
     console.log(pc9.dim("Tasks \u2014 ") + parts.join(pc9.dim(" | ")));
   } finally {
-    db.close();
+    await db.close();
   }
 }
 
@@ -2023,16 +2309,16 @@ 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 db = openDB(config, cwd2);
+  const db = await 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);
+      await syncOut(db, cwd2, opts.dryRun ?? false);
     }
   } finally {
-    db.close();
+    await db.close();
   }
 }
 async function syncIn(featureListPath, db, dryRun) {
@@ -2050,70 +2336,77 @@ async function syncIn(featureListPath, db, dryRun) {
   if (dryRun) {
     console.log(pc10.bold("Dry run \u2014 in-sync (feature_list.json \u2192 SQLite):"));
     for (const t of seeds) {
-      const existing = db.getTaskBySlug(t.slug);
+      const existing = await db.getTaskBySlug(t.slug);
       console.log(`  ${existing ? pc10.dim("skip") : pc10.green("add ")} ${t.slug}`);
     }
     return;
   }
-  const result = db.syncFromFeatureList(seeds);
+  const result = await db.syncFromFeatureList(seeds);
   console.log(pc10.green(`\u2713 In-sync: ${result.added} added, ${result.skipped} already existed`));
 }
-function syncOut(db, cwd2, dryRun) {
+async function syncOut(db, cwd2, dryRun) {
   if (dryRun) {
-    const tasks = db.getTasks();
+    const tasks = await db.getTasks();
     console.log(pc10.bold("Dry run \u2014 out-sync (SQLite \u2192 feature_list.json):"));
     console.log(`  ${tasks.length} tasks would be written`);
     return;
   }
-  db.writeFeatureList(cwd2);
+  await db.writeFeatureList(cwd2);
   console.log(pc10.green("\u2713 Out-sync: feature_list.json updated"));
 }
 
 // src/commands/task/add.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import pc11 from "picocolors";
 async function runTaskAdd(cwd2) {
-  p5.intro(pc11.bold("agent-harness-kit \u2014 add task"));
-  const titleVal = await p5.text({
-    message: "Task title",
-    validate: (v) => v.trim() ? void 0 : "Title is required"
-  });
-  if (p5.isCancel(titleVal)) {
-    p5.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const title = titleVal.trim();
-  const descVal = await p5.text({
-    message: "Description (what and why)",
-    placeholder: "Optional"
-  });
-  if (p5.isCancel(descVal)) {
-    p5.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const description = descVal.trim();
+  p6.intro(pc11.bold("agent-harness-kit \u2014 add task"));
+  const title = await cliFormWithRetry(
+    async () => {
+      const val = await p6.text({ message: "Task title" });
+      if (p6.isCancel(val)) {
+        p6.cancel("Cancelled.");
+        process.exit(0);
+      }
+      return val.trim();
+    },
+    taskTitleSchema
+  );
+  const description = await cliFormWithRetry(
+    async () => {
+      const val = await p6.text({
+        message: "Description (what and why)",
+        placeholder: "Describe the task in more detail, including any relevant context or instructions for the agents."
+      });
+      if (p6.isCancel(val)) {
+        p6.cancel("Cancelled.");
+        process.exit(0);
+      }
+      return val.trim();
+    },
+    taskDescriptionSchema
+  );
   const acceptance = [];
-  p5.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
+  p6.log.info("Acceptance criteria \u2014 one per line, empty line to finish");
   while (true) {
-    const val = await p5.text({ message: ">", placeholder: "Criterion (or press Enter to finish)" });
-    if (p5.isCancel(val) || !val || !val.trim()) break;
+    const val = await p6.text({ message: ">", placeholder: "Criterion (or press Enter to finish)" });
+    if (p6.isCancel(val) || !val || !val.trim()) break;
     acceptance.push(val.trim());
   }
-  const spinner5 = p5.spinner();
+  const spinner5 = p6.spinner();
   spinner5.start("Saving...");
   try {
     const config = await loadConfig(cwd2);
-    const db = openDB(config, cwd2);
+    const db = await openDB(config, cwd2);
     const slug = slugify(title);
-    const task2 = db.addTask({ slug, title, description: description || void 0, acceptance });
-    db.writeFeatureList(cwd2);
-    db.close();
+    const task2 = await db.addTask({ slug, title, description: description || void 0, acceptance });
+    await db.writeFeatureList(cwd2);
+    await db.close();
     spinner5.stop("");
     console.log(pc11.green(`\u2713 Task #${task2.id} added \u2014 ${task2.slug} (pending)`));
     console.log(pc11.cyan("\u2192") + " " + pc11.cyan("ahk status") + " to see all tasks");
   } catch (err) {
     spinner5.stop(pc11.red("Failed"));
-    p5.log.error(err instanceof Error ? err.message : String(err));
+    p6.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }
@@ -2137,11 +2430,11 @@ async function runTaskDone(cwd2, idOrSlug) {
       }
     }
   }
-  const db = openDB(config, cwd2);
+  const db = await openDB(config, cwd2);
   try {
     const parsed = parseInt(idOrSlug, 10);
     const isId = !isNaN(parsed);
-    const task2 = isId ? db.getTaskById(parsed) : db.getTaskBySlug(idOrSlug);
+    const task2 = isId ? await db.getTaskById(parsed) : await db.getTaskBySlug(idOrSlug);
     if (!task2) {
       console.error(pc12.red(`Task not found: ${idOrSlug}`));
       process.exit(1);
@@ -2150,11 +2443,11 @@ async function runTaskDone(cwd2, idOrSlug) {
       console.log(pc12.dim(`Task #${task2.id} is already done.`));
       return;
     }
-    db.updateTaskStatus(task2.id, "done");
-    db.writeFeatureList(cwd2);
+    await db.updateTaskStatus(task2.id, "done");
+    await db.writeFeatureList(cwd2);
     console.log(pc12.green(`\u2713 Task #${task2.id} \u2014 ${task2.slug} marked as done`));
   } finally {
-    db.close();
+    await db.close();
   }
 }
 
@@ -2169,11 +2462,11 @@ var STATUS_COLOR2 = {
 };
 async function runTaskList(cwd2, opts) {
   const config = await loadConfig(cwd2);
-  const db = openDB(config, cwd2);
+  const db = await 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();
+    const tasks = filterStatus ? await db.getTasks(filterStatus) : await db.getTasks();
     if (opts.json) {
       console.log(JSON.stringify(tasks, null, 2));
       return;
@@ -2192,15 +2485,15 @@ async function runTaskList(cwd2, opts) {
     }
     console.log(table.toString());
   } finally {
-    db.close();
+    await db.close();
   }
 }
 
 // src/core/package-data.ts
-import { createRequire as createRequire2 } from "module";
+import { createRequire } from "module";
 import { dirname as dirname5, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var require2 = createRequire2(import.meta.url);
+var require2 = createRequire(import.meta.url);
 var pkgPath = join14(dirname5(fileURLToPath3(import.meta.url)), "..", "package.json");
 var pkg = require2(pkgPath);
 
@@ -2238,7 +2531,7 @@ function printUpdateMessage({ current, latest }) {
   console.log();
 }
 function isNewer(latest, current) {
-  const toNum = (v) => v.split(".").map(Number);
+  const toNum = (v4) => v4.split(".").map(Number);
   const [lMaj, lMin, lPat] = toNum(latest);
   const [cMaj, cMin, cPat] = toNum(current);
   if (lMaj !== cMaj) return lMaj > cMaj;