@cardor/agent-harness-kit 1.8.1 → 1.10.0

package/dist/chunk-DNFFWQWR.js

@@ -0,0 +1,821 @@
+// src/core/db.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+
+// src/core/repositories/ActionRepository.ts
+var ActionRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async create(id, taskId, agent, now) {
+    await this.driver.exec(
+      `INSERT INTO actions (id, task_id, agent, status, created_at) VALUES (?, ?, ?, 'in_progress', ?)`,
+      [id, taskId, agent, now]
+    );
+  }
+  async complete(actionId, summary, now) {
+    await this.driver.exec(
+      `UPDATE actions SET status = 'completed', completed_at = ?, summary = ? WHERE id = ?`,
+      [now, summary, actionId]
+    );
+  }
+  async closeOrphaned(taskId, now) {
+    return this.driver.exec(
+      `UPDATE actions SET status = 'completed', completed_at = ?, summary = 'Auto-closed: task marked done' WHERE task_id = ? AND status = 'in_progress'`,
+      [now, taskId]
+    );
+  }
+  async getById(actionId) {
+    return this.driver.queryOne(`SELECT * FROM actions WHERE id = ?`, [actionId]);
+  }
+  async getForTask(taskId) {
+    return this.driver.query(
+      `SELECT * FROM actions WHERE task_id = ? ORDER BY created_at`,
+      [taskId]
+    );
+  }
+  async getAll() {
+    return this.driver.query(`SELECT * FROM actions ORDER BY created_at`);
+  }
+  async getWithDetails(taskId) {
+    const actions = await this.getForTask(taskId);
+    return Promise.all(
+      actions.map(async (action) => ({
+        ...action,
+        sections: await this.getSections(action.id),
+        files: await this.getFiles(action.id),
+        tools: await this.getTools(action.id)
+      }))
+    );
+  }
+  // ─── Sections ─────────────────────────────────────────────────────────────
+  async addSection(actionId, sectionType, content, now) {
+    await this.driver.exec(
+      `INSERT INTO action_sections (action_id, section_type, content, created_at) VALUES (?, ?, ?, ?)`,
+      [actionId, sectionType, content, now]
+    );
+  }
+  async getSections(actionId) {
+    return this.driver.query(
+      `SELECT * FROM action_sections WHERE action_id = ? ORDER BY created_at`,
+      [actionId]
+    );
+  }
+  async getAllSections() {
+    return this.driver.query(`SELECT * FROM action_sections ORDER BY created_at`);
+  }
+  // ─── Files ────────────────────────────────────────────────────────────────
+  async addFile(actionId, filePath, operation, notes) {
+    await this.driver.exec(
+      `INSERT INTO action_files (action_id, file_path, operation, notes) VALUES (?, ?, ?, ?)`,
+      [actionId, filePath, operation, notes]
+    );
+  }
+  async getFiles(actionId) {
+    return this.driver.query(
+      `SELECT * FROM action_files WHERE action_id = ?`,
+      [actionId]
+    );
+  }
+  async getFilesForTask(taskId) {
+    return this.driver.query(
+      `SELECT af.*, a.agent FROM action_files af JOIN actions a ON af.action_id = a.id WHERE a.task_id = ? ORDER BY a.agent, af.operation`,
+      [taskId]
+    );
+  }
+  /** Returns ALL action_files rows regardless of action — used by full DB
+   *  exports (e.g. `ahk migrate storage`) so file-touch records aren't lost. */
+  async getAllFiles() {
+    return this.driver.query(`SELECT * FROM action_files ORDER BY id`);
+  }
+  // ─── 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]
+    );
+  }
+  /** Returns ALL action_tools rows regardless of action — used by full DB
+   *  exports (e.g. `ahk migrate storage`) so tool-call records aren't lost. */
+  async getAllTools() {
+    return this.driver.query(`SELECT * FROM action_tools ORDER BY id`);
+  }
+  async getTopTools(limit) {
+    return this.driver.query(
+      `SELECT tool_name, COUNT(*) as uses FROM action_tools GROUP BY tool_name ORDER BY uses DESC LIMIT ?`,
+      [limit]
+    );
+  }
+};
+
+// src/core/repositories/StatsRepository.ts
+var AGENT_ORDER = ["lead", "explorer", "builder", "reviewer"];
+var StatsRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async getCounts() {
+    const [{ total: totalActions }] = await this.driver.query(
+      `SELECT COUNT(*) as total FROM actions`
+    );
+    const [{ total: totalFiles }] = await this.driver.query(
+      `SELECT COUNT(*) as total FROM action_files`
+    );
+    const [{ total: uniqueTools }] = await this.driver.query(
+      `SELECT COUNT(DISTINCT tool_name) as total FROM action_tools`
+    );
+    const [{ total: activeAgents }] = await this.driver.query(
+      `SELECT COUNT(DISTINCT agent) as total FROM actions WHERE status = 'in_progress'`
+    );
+    return { totalActions, totalFiles, uniqueTools, activeAgents };
+  }
+  async getRecentTools(limit) {
+    return this.driver.query(
+      `SELECT at.*, t.id as task_id, t.title as task_title, t.slug as task_slug, a.agent
+       FROM action_tools at
+       JOIN actions a ON at.action_id = a.id
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY at.called_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getTopFiles(limit) {
+    return this.driver.query(
+      `SELECT
+        file_path,
+        COUNT(*) as total,
+        SUM(CASE WHEN operation='read'     THEN 1 ELSE 0 END) as read,
+        SUM(CASE WHEN operation='created'  THEN 1 ELSE 0 END) as created,
+        SUM(CASE WHEN operation='modified' THEN 1 ELSE 0 END) as modified,
+        SUM(CASE WHEN operation='deleted'  THEN 1 ELSE 0 END) as deleted
+       FROM action_files
+       GROUP BY file_path
+       ORDER BY total DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getRecentFiles(limit) {
+    return this.driver.query(
+      `SELECT af.*, t.id as task_id, t.title as task_title, t.slug as task_slug,
+        a.agent, a.created_at as called_at
+       FROM action_files af
+       JOIN actions a ON af.action_id = a.id
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY a.created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+  async getAgentStats() {
+    const rows = await this.driver.query(
+      `SELECT
+        a.agent,
+        COUNT(*)                                              as actions_total,
+        SUM(CASE WHEN a.status='completed' THEN 1 ELSE 0 END) as actions_done,
+        SUM(CASE WHEN a.status='blocked'   THEN 1 ELSE 0 END) as actions_blocked,
+        COUNT(DISTINCT a.task_id)                             as tasks_worked,
+        COUNT(DISTINCT af.file_path)                          as files_touched
+       FROM actions a
+       LEFT JOIN action_files af ON af.action_id = a.id
+       GROUP BY a.agent
+       ORDER BY actions_total DESC`
+    );
+    return rows.sort((a, b) => {
+      const ai = AGENT_ORDER.indexOf(a.agent);
+      const bi = AGENT_ORDER.indexOf(b.agent);
+      if (ai === -1 && bi === -1) return 0;
+      if (ai === -1) return 1;
+      if (bi === -1) return -1;
+      return ai - bi;
+    });
+  }
+  async getTimeline(limit) {
+    return this.driver.query(
+      `SELECT a.*, t.title as task_title, t.slug as task_slug, t.status as task_status
+       FROM actions a
+       JOIN tasks t ON a.task_id = t.id
+       ORDER BY a.created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+  }
+};
+
+// src/core/repositories/TaskRepository.ts
+var TaskRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async add(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.driver.insert(
+      `INSERT INTO tasks (slug, title, description, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.slug, params.title, params.description ?? null, params.status ?? "pending", now, now]
+    );
+  }
+  async addAcceptance(taskId, criteria) {
+    for (const criterion of criteria) {
+      await this.driver.exec(
+        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`,
+        [taskId, criterion]
+      );
+    }
+  }
+  async getAll(status, includeArchived = false) {
+    let sql = `SELECT * FROM tasks`;
+    const params = [];
+    const conditions = [];
+    if (!includeArchived) {
+      conditions.push(`archived_at IS NULL`);
+    }
+    if (status) {
+      conditions.push(`status = ?`);
+      params.push(status);
+    }
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    sql += ` ORDER BY CASE status WHEN 'pending' THEN 1 WHEN 'in_progress' THEN 2 WHEN 'blocked' THEN 3 WHEN 'done' THEN 4 ELSE 5 END, updated_at DESC`;
+    return this.driver.query(sql, params);
+  }
+  async getAllWithAcceptanceCounts(includeArchived = false) {
+    let sql = `
+      SELECT t.*,
+        COUNT(ta.id) as acceptance_total,
+        COALESCE(SUM(ta.met), 0) as acceptance_met
+      FROM tasks t
+      LEFT JOIN task_acceptance ta ON ta.task_id = t.id
+    `;
+    if (!includeArchived) {
+      sql += ` WHERE t.archived_at IS NULL`;
+    }
+    sql += ` GROUP BY t.id ORDER BY CASE t.status WHEN 'pending' THEN 1 WHEN 'in_progress' THEN 2 WHEN 'blocked' THEN 3 WHEN 'done' THEN 4 ELSE 5 END, t.updated_at DESC`;
+    return this.driver.query(sql);
+  }
+  async getById(id) {
+    return this.driver.queryOne(`SELECT * FROM tasks WHERE id = ?`, [id]);
+  }
+  async getBySlug(slug) {
+    return this.driver.queryOne(`SELECT * FROM tasks WHERE slug = ?`, [slug]);
+  }
+  async getAcceptance(taskId) {
+    return this.driver.query(
+      `SELECT * FROM task_acceptance WHERE task_id = ?`,
+      [taskId]
+    );
+  }
+  /** Returns ALL task_acceptance rows regardless of task — used by full DB
+   *  exports (e.g. `ahk migrate storage`) so criteria aren't silently dropped. */
+  async getAllAcceptance() {
+    return this.driver.query(`SELECT * FROM task_acceptance ORDER BY id`);
+  }
+  async setStatus(id, status, extra) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (extra?.started_at) {
+      await this.driver.exec(
+        `UPDATE tasks SET status = ?, started_at = ?, updated_at = ? WHERE id = ?`,
+        [status, extra.started_at, now, id]
+      );
+    } else if (extra?.completed_at) {
+      await this.driver.exec(
+        `UPDATE tasks SET status = ?, completed_at = ?, updated_at = ? WHERE id = ?`,
+        [status, extra.completed_at, now, id]
+      );
+    } else {
+      await this.driver.exec(`UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?`, [status, now, id]);
+    }
+  }
+  async update(id, params) {
+    const sets = [];
+    const vals = [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (params.title !== void 0) {
+      sets.push("title = ?");
+      vals.push(params.title);
+    }
+    if (params.description !== void 0) {
+      sets.push("description = ?");
+      vals.push(params.description);
+    }
+    if (params.slug !== void 0) {
+      sets.push("slug = ?");
+      vals.push(params.slug);
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = ?");
+    vals.push(now);
+    vals.push(id);
+    await this.driver.exec(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`, vals);
+  }
+  async replaceAcceptance(taskId, criteria) {
+    await this.driver.exec(`DELETE FROM task_acceptance WHERE task_id = ?`, [taskId]);
+    for (const criterion of criteria) {
+      await this.driver.exec(
+        `INSERT INTO task_acceptance (task_id, criterion) VALUES (?, ?)`,
+        [taskId, criterion]
+      );
+    }
+  }
+  async archive(id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.driver.exec(`UPDATE tasks SET archived_at = ?, updated_at = ? WHERE id = ?`, [now, now, id]);
+  }
+  async unarchive(id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.driver.exec(`UPDATE tasks SET archived_at = NULL, updated_at = ? WHERE id = ?`, [now, id]);
+  }
+  async getArchived() {
+    return this.driver.query(
+      `SELECT * FROM tasks WHERE archived_at IS NOT NULL ORDER BY archived_at DESC`
+    );
+  }
+  async claim(id, agent, now) {
+    return this.driver.exec(
+      `UPDATE tasks SET status = 'in_progress', assigned_to = ?, started_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`,
+      [agent, now, now, id]
+    );
+  }
+  async markAcceptanceMet(criterionId) {
+    await this.driver.exec(`UPDATE task_acceptance SET met = 1 WHERE id = ?`, [criterionId]);
+  }
+  async getStatusSummary() {
+    return this.driver.query(
+      `SELECT status, COUNT(*) as total FROM tasks WHERE archived_at IS NULL GROUP BY status`
+    );
+  }
+};
+
+// src/core/db.ts
+var AUTOINCREMENT_TABLES = ["tasks", "task_acceptance", "action_sections", "action_files", "action_tools"];
+var TABLE_INSERT_ORDER = ["tasks", "task_acceptance", "actions", "action_sections", "action_files", "action_tools"];
+var TABLE_DELETE_ORDER = [...TABLE_INSERT_ORDER].reverse();
+function resolveGlobalStorageDir(config, homeDir = homedir()) {
+  return join(homeDir, ".harness", "dbs", config.storage.projectId);
+}
+var HarnessDB = class {
+  tasks;
+  actions;
+  stats;
+  driver;
+  config;
+  /** Overridable home directory, used to keep 'global' scope tests off the real $HOME. */
+  homeDir;
+  constructor(driver, config, homeDir = homedir()) {
+    this.driver = driver;
+    this.config = config;
+    this.homeDir = homeDir;
+    this.tasks = new TaskRepository(driver);
+    this.actions = new ActionRepository(driver);
+    this.stats = new StatsRepository(driver);
+  }
+  // ─── Tasks (public facade — delegates to TaskRepository) ──────────────────
+  async addTask(params) {
+    const taskId = await this.tasks.add({
+      slug: params.slug,
+      title: params.title,
+      description: params.description
+    });
+    if (params.acceptance?.length) {
+      await this.tasks.addAcceptance(taskId, params.acceptance);
+    }
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(taskId);
+  }
+  async getTasks(status, includeArchived = false) {
+    return this.tasks.getAll(status, includeArchived);
+  }
+  async getTaskById(id) {
+    return this.tasks.getById(id);
+  }
+  async getTaskBySlug(slug) {
+    return this.tasks.getBySlug(slug);
+  }
+  async getTaskAcceptance(taskId) {
+    return this.tasks.getAcceptance(taskId);
+  }
+  async updateTaskStatus(idOrSlug, status) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = typeof idOrSlug === "number" ? await this.tasks.getById(idOrSlug) : await this.tasks.getBySlug(idOrSlug);
+    if (!task) throw new Error(`Task not found: ${idOrSlug}`);
+    if (status === "in_progress" && !task.started_at) {
+      await this.tasks.setStatus(task.id, status, { started_at: now });
+    } else if (status === "done") {
+      await this.tasks.setStatus(task.id, status, { completed_at: now });
+    } else {
+      await this.tasks.setStatus(task.id, status);
+    }
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(task.id);
+  }
+  async claimTask(id, agent) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.driver.transaction(async (tx) => {
+      const txTasks = new TaskRepository(tx);
+      const changed = await txTasks.claim(id, agent, now);
+      if (!changed) return null;
+      const task = await txTasks.getById(id);
+      if (!task || task.status !== "in_progress" || task.assigned_to !== agent) return null;
+      await this.regenerateCurrentMd();
+      return task;
+    });
+  }
+  async markAcceptanceMet(criterionId) {
+    return this.tasks.markAcceptanceMet(criterionId);
+  }
+  async updateTask(id, params) {
+    await this.tasks.update(id, params);
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(id);
+  }
+  async updateTaskAcceptance(taskId, criteria) {
+    await this.tasks.replaceAcceptance(taskId, criteria);
+    await this.regenerateCurrentMd();
+  }
+  async archiveTask(id) {
+    await this.tasks.archive(id);
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(id);
+  }
+  async unarchiveTask(id) {
+    await this.tasks.unarchive(id);
+    await this.regenerateCurrentMd();
+    return await this.tasks.getById(id);
+  }
+  async getArchivedTasks() {
+    return this.tasks.getArchived();
+  }
+  async getStatusSummary() {
+    return this.tasks.getStatusSummary();
+  }
+  // ─── Actions (public facade — delegates to ActionRepository) ──────────────
+  async startAction(taskId, agent) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.actions.create(id, taskId, agent, now);
+    await this.regenerateCurrentMd();
+    return await this.actions.getById(id);
+  }
+  async writeSection(actionId, sectionType, content) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.actions.addSection(actionId, sectionType, content, now);
+    await this.regenerateCurrentMd();
+  }
+  async completeAction(actionId, summary) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.actions.complete(actionId, summary, now);
+    await this.regenerateCurrentMd();
+    return await this.actions.getById(actionId);
+  }
+  async closeOrphanedActions(taskId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.actions.closeOrphaned(taskId, now);
+  }
+  async getAction(actionId) {
+    return this.actions.getById(actionId);
+  }
+  async getActionsForTask(taskId) {
+    return this.actions.getForTask(taskId);
+  }
+  async getActionSections(actionId) {
+    return this.actions.getSections(actionId);
+  }
+  async recordFile(actionId, filePath, operation, notes) {
+    return this.actions.addFile(actionId, filePath, operation, notes ?? null);
+  }
+  async recordTool(actionId, toolName, argsJson, resultSummary) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return this.actions.addTool(actionId, toolName, argsJson ?? null, resultSummary ?? null, now);
+  }
+  async getFilesForTask(taskId) {
+    return this.actions.getFilesForTask(taskId);
+  }
+  async getTopTools(limit = 10) {
+    return this.actions.getTopTools(limit);
+  }
+  // ─── current.md fallback ──────────────────────────────────────────────────
+  async regenerateCurrentMd() {
+    if (!this.config.storage.markdownFallback.enabled) return;
+    const mdPath = this.config.storage.scope === "global" ? join(resolveGlobalStorageDir(this.config, this.homeDir), "current.md") : resolve(this.config.storage.markdownFallback.path);
+    mkdirSync(dirname(mdPath), { recursive: true });
+    const inProgress = await this.tasks.getAll("in_progress");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let md = `<!-- AUTO-GENERATED by agent-harness-kit \u2014 DO NOT EDIT MANUALLY -->
+`;
+    md += `<!-- Last updated: ${now} -->
+
+`;
+    md += `# Current Session
+
+`;
+    if (inProgress.length === 0) {
+      md += `## No tasks in progress
+
+`;
+      const pending = await this.tasks.getAll("pending");
+      if (pending.length > 0) {
+        md += `### Next pending tasks
+`;
+        for (const t of pending.slice(0, 5)) {
+          md += `- **#${t.id}** ${t.title} (\`${t.slug}\`)
+`;
+        }
+      }
+    } else {
+      for (const task of inProgress) {
+        md += `## Active Task
+`;
+        md += `- **ID:** ${task.id}
+`;
+        md += `- **Slug:** ${task.slug}
+`;
+        md += `- **Status:** ${task.status}
+`;
+        md += `- **Started:** ${task.started_at ?? "unknown"}
+
+`;
+        const taskActions = await this.actions.getForTask(task.id);
+        if (taskActions.length > 0) {
+          md += `## Actions this session
+`;
+          md += `| Agent    | Status      | Summary                          | Started     |
+`;
+          md += `|----------|-------------|----------------------------------|-------------|
+`;
+          for (const a of taskActions) {
+            const started = a.created_at.slice(11, 16);
+            const summary = (a.summary ?? "").slice(0, 34).padEnd(34);
+            md += `| ${a.agent.padEnd(8)} | ${a.status.padEnd(11)} | ${summary} | ${started}       |
+`;
+          }
+          md += `
+`;
+        }
+        const acceptance = await this.tasks.getAcceptance(task.id);
+        if (acceptance.length > 0) {
+          md += `## Acceptance Criteria
+`;
+          for (const a of acceptance) {
+            md += `- [${a.met ? "x" : " "}] ${a.criterion}
+`;
+          }
+          md += `
+`;
+        }
+      }
+    }
+    writeFileSync(mdPath, md, "utf8");
+  }
+  // ─── Raw query escape hatch ───────────────────────────────────────────────
+  async queryRaw(sql, ...params) {
+    return this.driver.query(sql, params);
+  }
+  // ─── Export helpers ───────────────────────────────────────────────────────
+  /** Full relational export of ALL 6 tables (tasks, task_acceptance, actions,
+   *  action_sections, action_files, action_tools). Extended for task #47 —
+   *  the previous version (tasks/actions/sections only) silently dropped
+   *  acceptance criteria and file/tool records on export/migrate. */
+  async exportJson() {
+    return {
+      tasks: await this.tasks.getAll(void 0, true),
+      taskAcceptance: await this.tasks.getAllAcceptance(),
+      actions: await this.actions.getAll(),
+      sections: await this.actions.getAllSections(),
+      actionFiles: await this.actions.getAllFiles(),
+      actionTools: await this.actions.getAllTools()
+    };
+  }
+  /** Row counts for all 6 tables against THIS db's driver — used to decide
+   *  whether a destination is "empty" (safe to import into directly) before
+   *  a migration. Counts are queried directly (COUNT(*)), never inferred
+   *  from storage-state.json. */
+  async getRowCounts() {
+    return getRowCounts(this.driver);
+  }
+  /** Imports a full export into THIS db's driver — see standalone
+   *  `importFullExport()` for the transactional/rollback/sequence-reset
+   *  guarantees. `dbType` must match `this.config.database.type`. */
+  async importFullExport(data, dbType, opts) {
+    return importFullExport(this.driver, data, dbType, opts);
+  }
+  async reconnect() {
+    await this.driver.reconnect();
+  }
+  async close() {
+    await this.driver.close();
+  }
+  // ─── feature_list.json sync ───────────────────────────────────────────────
+  async syncFromFeatureList(seeds) {
+    let added = 0;
+    let skipped = 0;
+    for (const t of seeds) {
+      if (await this.tasks.getBySlug(t.slug)) {
+        skipped++;
+        continue;
+      }
+      await this.addTask(t);
+      added++;
+    }
+    return { added, skipped };
+  }
+  async writeFeatureList(cwd) {
+    const allTasks = await this.tasks.getAll(void 0, true);
+    const list = await Promise.all(
+      allTasks.map(async (t) => ({
+        slug: t.slug,
+        title: t.title,
+        description: t.description ?? void 0,
+        acceptance: (await this.tasks.getAcceptance(t.id)).map((a) => a.criterion),
+        status: t.status
+      }))
+    );
+    const path = join(resolve(cwd), this.config.storage.dir, "feature_list.json");
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(list, null, 2) + "\n", "utf8");
+  }
+  // ─── storage-state.json (real storage state, for `ahk migrate storage`) ──
+  /** Writes .harness/storage-state.json, ALWAYS project-local regardless of
+   *  scope. Reflects the REAL current storage state (scope/projectId/dbType
+   *  actually in use right now), as opposed to agent-harness-kit.config.ts
+   *  which reflects the DESIRED state. Format is stable — task #47 (ahk
+   *  migrate storage) depends on it; do not change field names/shape. */
+  async writeStorageState(cwd) {
+    writeStorageStateFile(cwd, this.config.storage.dir, {
+      scope: this.config.storage.scope,
+      projectId: this.config.storage.projectId,
+      dbType: this.config.database.type,
+      migratedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+async function getRowCounts(driver) {
+  const counts = {};
+  for (const table of TABLE_INSERT_ORDER) {
+    const row = await driver.queryOne(`SELECT COUNT(*) as n FROM ${table}`);
+    counts[table] = Number(row?.n ?? 0);
+  }
+  return counts;
+}
+async function isEmptyDatabase(driver) {
+  const counts = await getRowCounts(driver);
+  return Object.values(counts).every((n) => n === 0);
+}
+async function truncateAllTables(tx) {
+  for (const table of TABLE_DELETE_ORDER) {
+    await tx.exec(`DELETE FROM ${table}`);
+  }
+}
+async function resetAutoincrementSequences(tx, dbType) {
+  if (dbType === "mysql") return;
+  for (const table of AUTOINCREMENT_TABLES) {
+    const row = await tx.queryOne(`SELECT MAX(id) as max FROM ${table}`);
+    const max = row?.max;
+    if (!max) continue;
+    if (dbType === "postgres") {
+      await tx.execRaw(`SELECT setval(pg_get_serial_sequence('${table}','id'), ${max}, true)`);
+    } else {
+      await tx.execRaw(
+        `INSERT INTO sqlite_sequence (name, seq) SELECT '${table}', ${max} WHERE NOT EXISTS (SELECT 1 FROM sqlite_sequence WHERE name = '${table}')`
+      );
+      await tx.execRaw(`UPDATE sqlite_sequence SET seq = ${max} WHERE name = '${table}'`);
+    }
+  }
+}
+async function importFullExport(destDriver, data, destDbType, opts = { truncateFirst: false }) {
+  await destDriver.transaction(async (tx) => {
+    if (opts.truncateFirst) {
+      await truncateAllTables(tx);
+    }
+    for (const task of data.tasks) {
+      await tx.exec(
+        `INSERT INTO tasks (id, slug, title, description, status, assigned_to, created_at, started_at, completed_at, archived_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          task.id,
+          task.slug,
+          task.title,
+          task.description,
+          task.status,
+          task.assigned_to,
+          task.created_at,
+          task.started_at,
+          task.completed_at,
+          task.archived_at,
+          task.updated_at
+        ]
+      );
+    }
+    for (const ta of data.taskAcceptance) {
+      await tx.exec(
+        `INSERT INTO task_acceptance (id, task_id, criterion, met) VALUES (?, ?, ?, ?)`,
+        [ta.id, ta.task_id, ta.criterion, ta.met]
+      );
+    }
+    for (const action of data.actions) {
+      await tx.exec(
+        `INSERT INTO actions (id, task_id, agent, status, created_at, completed_at, summary) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [action.id, action.task_id, action.agent, action.status, action.created_at, action.completed_at, action.summary]
+      );
+    }
+    for (const section of data.sections) {
+      await tx.exec(
+        `INSERT INTO action_sections (id, action_id, section_type, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+        [section.id, section.action_id, section.section_type, section.content, section.created_at]
+      );
+    }
+    for (const file of data.actionFiles) {
+      await tx.exec(
+        `INSERT INTO action_files (id, action_id, file_path, operation, notes) VALUES (?, ?, ?, ?, ?)`,
+        [file.id, file.action_id, file.file_path, file.operation, file.notes]
+      );
+    }
+    for (const tool of data.actionTools) {
+      await tx.exec(
+        `INSERT INTO action_tools (id, action_id, tool_name, args_json, result_summary, called_at) VALUES (?, ?, ?, ?, ?, ?)`,
+        [tool.id, tool.action_id, tool.tool_name, tool.args_json, tool.result_summary, tool.called_at]
+      );
+    }
+    await resetAutoincrementSequences(tx, destDbType);
+  });
+}
+function resolveSqlitePathForScope(scope, sqlitePath, cwd, config, homeDir) {
+  return scope === "global" ? join(resolveGlobalStorageDir(config, homeDir), "harness.db") : resolve(cwd, sqlitePath);
+}
+function writeStorageStateFile(cwd, storageDir, state) {
+  const path = join(resolve(cwd), storageDir, "storage-state.json");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function readStorageStateFile(cwd, storageDir) {
+  try {
+    const path = join(resolve(cwd), storageDir, "storage-state.json");
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function openDB(config, cwd, homeDir = homedir()) {
+  const dbConfig = config.database;
+  let driver;
+  if (dbConfig.type === "postgres") {
+    const { PostgresDriver } = await import("./postgres-IOQE32DM.js");
+    driver = new PostgresDriver(dbConfig);
+  } else if (dbConfig.type === "mysql") {
+    const { MySQLDriver } = await import("./mysql-THKQOXIS.js");
+    driver = new MySQLDriver(dbConfig);
+  } else {
+    const { SQLiteDriver } = await import("./sqlite-TR4D324R.js");
+    if (dbConfig.type !== "sqlite") {
+      throw new Error("Invalid database type");
+    }
+    let dbPath;
+    if (config.storage.scope === "global") {
+      const globalDir = resolveGlobalStorageDir(config, homeDir);
+      const existingStatePath = join(globalDir, "storage-state.json");
+      if (existsSync(existingStatePath)) {
+        try {
+          const existingState = JSON.parse(readFileSync(existingStatePath, "utf8"));
+          if (existingState.projectId !== config.storage.projectId) {
+            throw new Error(
+              `Global storage dir ${globalDir} already holds a different project (projectId: ${existingState.projectId}). Refusing to reuse it.`
+            );
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("already holds a different project")) throw err;
+        }
+      }
+      mkdirSync(globalDir, { recursive: true });
+      dbPath = join(globalDir, "harness.db");
+    } else {
+      dbPath = resolve(cwd, dbConfig.path);
+    }
+    driver = new SQLiteDriver(dbPath);
+  }
+  await driver.ensureSchema();
+  return new HarnessDB(driver, config, homeDir);
+}
+
+export {
+  resolveGlobalStorageDir,
+  HarnessDB,
+  getRowCounts,
+  isEmptyDatabase,
+  importFullExport,
+  resolveSqlitePathForScope,
+  writeStorageStateFile,
+  readStorageStateFile,
+  openDB
+};
+//# sourceMappingURL=chunk-DNFFWQWR.js.map