@thecolonylab/hivemind 0.1.0

package/dist/commands/remoteExecutor.js

@@ -0,0 +1,188 @@
+/**
+ * The Forager — runs on your machine, executes exactly what the Hivemind brain tells it to, one
+ * named tool call at a time. Same `execute(name, input)` shape used in-process on the server for
+ * cloud runs; the only difference is these calls arrive over a socket instead of a direct
+ * function call. `selector` args are real CSS/Playwright selector strings computed fresh by
+ * snapshot() — this class never invents, matches, or remembers anything, it just runs
+ * page.locator(selector) directly, same as any plain Playwright script.
+ */
+export class Forager {
+    page;
+    runStart;
+    pageStack = [];
+    screenshots = [];
+    constructor(page, runStart) {
+        this.page = page;
+        this.runStart = runStart;
+    }
+    getScreenshots() {
+        return this.screenshots;
+    }
+    async execute(name, input) {
+        try {
+            switch (name) {
+                case 'browser_navigate': {
+                    const pagesBefore = new Set(this.page.context().pages());
+                    await this.page.goto(input.url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+                    const newTabUrl = await this.followNewTabIfOpened(pagesBefore, true);
+                    return { ok: true, message: newTabUrl ? `Navigated — new tab opened: ${newTabUrl}` : `Navigated to ${input.url}` };
+                }
+                case 'browser_snapshot': {
+                    const data = await this.buildSnapshot();
+                    return { ok: true, message: 'Snapshot captured', data };
+                }
+                case 'browser_click': {
+                    const pagesBefore = new Set(this.page.context().pages());
+                    await this.page.locator(input.selector).first().click({ timeout: 10_000 });
+                    const newTabUrl = await this.followNewTabIfOpened(pagesBefore);
+                    return { ok: true, message: newTabUrl ? `Clicked — new tab opened: ${newTabUrl}` : `Clicked ${input.selector}` };
+                }
+                case 'browser_type': {
+                    await this.page.locator(input.selector).first().fill(input.text ?? '', { timeout: 10_000 });
+                    return { ok: true, message: `Typed into ${input.selector}` };
+                }
+                case 'browser_key_press': {
+                    await this.page.keyboard.press(input.key);
+                    return { ok: true, message: `Pressed ${input.key}` };
+                }
+                case 'browser_hover': {
+                    await this.page.locator(input.selector).first().hover({ timeout: 10_000 });
+                    return { ok: true, message: `Hovered ${input.selector}` };
+                }
+                case 'browser_select': {
+                    await this.page.locator(input.selector).first().selectOption({ label: input.option });
+                    return { ok: true, message: `Selected "${input.option}" in ${input.selector}` };
+                }
+                case 'browser_wait_for': {
+                    if (input.text) {
+                        await this.page.getByText(input.text, { exact: false }).first().waitFor({ timeout: input.timeoutMs ?? 5000 });
+                        return { ok: true, message: `Text "${input.text}" appeared` };
+                    }
+                    await this.page.waitForTimeout(input.timeoutMs ?? 1000);
+                    return { ok: true, message: 'Waited' };
+                }
+                case 'browser_get_text': {
+                    const text = input.selector
+                        ? await this.page.locator(input.selector).first().innerText().catch(() => '')
+                        : await this.page.innerText('body').catch(() => '');
+                    return { ok: true, message: 'Text retrieved', data: (text || '').slice(0, 4000) };
+                }
+                case 'browser_get_url': {
+                    return { ok: true, message: this.page.url() };
+                }
+                case 'browser_scroll': {
+                    await this.page.mouse.wheel(0, input.direction === 'up' ? -800 : 800);
+                    return { ok: true, message: `Scrolled ${input.direction}` };
+                }
+                case 'browser_screenshot': {
+                    const meta = await this.takeScreenshot(input.label);
+                    return { ok: true, message: 'Screenshot captured', data: meta };
+                }
+                default:
+                    return { ok: false, message: `Unknown tool: ${name}` };
+            }
+        }
+        catch (err) {
+            return { ok: false, message: `Error running ${name}: ${err?.message || String(err)}` };
+        }
+    }
+    async takeScreenshot(label) {
+        const buffer = await this.page.screenshot();
+        const meta = { data: buffer.toString('base64'), label, elapsedMs: Date.now() - this.runStart };
+        this.screenshots.push(meta);
+        return meta;
+    }
+    /** Computes a real, reusable CSS selector for every visible interactive element — id first,
+     *  then aria-label, then placeholder/name, then visible text. Plain deterministic string-
+     *  building (the same rules anyone writing a Playwright script by hand would use), not
+     *  matching or judgment — the string handed back is valid on its own, nothing to remember. */
+    async buildSnapshot() {
+        const url = this.page.url();
+        const title = await this.page.title().catch(() => '');
+        const lines = await this.page.evaluate(() => {
+            const out = [];
+            const seen = new Set();
+            const selectors = 'a, button, input, textarea, select, [role="button"], [role="link"], h1, h2, h3';
+            document.querySelectorAll(selectors).forEach((el) => {
+                if (seen.has(el))
+                    return;
+                seen.add(el);
+                const rect = el.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0)
+                    return;
+                const tag = el.tagName.toLowerCase();
+                const text = (el.textContent || '').trim().replace(/\s+/g, ' ').slice(0, 60);
+                const ariaLabel = el.getAttribute('aria-label') || '';
+                const placeholder = el.placeholder || '';
+                const name = el.name || '';
+                const id = el.id;
+                let selector = '';
+                if (id)
+                    selector = `#${CSS.escape(id)}`;
+                else if (ariaLabel)
+                    selector = `[aria-label="${ariaLabel}"]`;
+                else if (placeholder)
+                    selector = `[placeholder="${placeholder}"]`;
+                else if (name)
+                    selector = `${tag}[name="${name}"]`;
+                else if (text)
+                    selector = `${tag}:has-text("${text.slice(0, 40)}")`;
+                else
+                    return;
+                const label = ariaLabel || placeholder || text || name;
+                if (!label)
+                    return;
+                out.push(`${selector} — ${tag}: ${label}`);
+            });
+            return out.slice(0, 150);
+        });
+        return `URL: ${url}\nTitle: ${title}\nVisible elements (selector — description):\n${lines.join('\n')}`;
+    }
+    /** Same new-tab/popup handling proven in agents/tools/executor.ts — a click/navigate can open a
+     *  new tab; without following it, subsequent snapshots would keep describing the old, stale tab. */
+    async followNewTabIfOpened(pagesBefore, extendedWait = false) {
+        const context = this.page.context();
+        const waitMs = extendedWait ? 4000 : 600;
+        const alreadyOpen = context.pages().find((p) => !pagesBefore.has(p) && !p.isClosed());
+        if (alreadyOpen)
+            return this.switchToNewPage(alreadyOpen);
+        let capturedPage = null;
+        let resolveCapture;
+        const capturePromise = new Promise((r) => {
+            resolveCapture = r;
+        });
+        const onPage = (p) => {
+            if (!pagesBefore.has(p) && !capturedPage) {
+                capturedPage = p;
+                resolveCapture();
+            }
+        };
+        context.on('page', onPage);
+        await Promise.race([capturePromise, new Promise((r) => setTimeout(r, waitMs))]);
+        context.off('page', onPage);
+        const cp = capturedPage;
+        if (!cp || cp.isClosed())
+            return null;
+        return this.switchToNewPage(cp);
+    }
+    async switchToNewPage(newPage) {
+        const prevPage = this.page;
+        await newPage.waitForLoadState('domcontentloaded', { timeout: 10_000 }).catch(() => { });
+        this.pageStack.push(prevPage);
+        this.page = newPage;
+        newPage.on('close', () => {
+            if (this.page === newPage) {
+                const fallback = this.pageStack.pop();
+                if (fallback && !fallback.isClosed()) {
+                    this.page = fallback;
+                }
+                else {
+                    const open = this.page.context().pages().find((p) => !p.isClosed());
+                    if (open)
+                        this.page = open;
+                }
+            }
+        });
+        return newPage.url();
+    }
+}

package/dist/commands/report.js

@@ -0,0 +1,44 @@
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { exec } from 'node:child_process';
+function serverUrl() {
+    return process.env.HIVEMIND_SERVER_URL || 'https://app.thecolonylab.com';
+}
+function open(url) {
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${opener} "${url}"`);
+}
+export async function reportCommand() {
+    const pointerPath = join(process.cwd(), '.hive', 'last-run.json');
+    try {
+        const pointer = JSON.parse(await readFile(pointerPath, 'utf-8'));
+        console.log(`Opening ${pointer.reportUrl}`);
+        open(pointer.reportUrl);
+    }
+    catch {
+        console.log('No runs yet in this project. Run `hivemind run <file>` first.');
+    }
+}
+export async function historyCommand(opts) {
+    const url = `${serverUrl()}/api/runs`;
+    const res = await fetch(url).catch(() => null);
+    if (!res || !res.ok) {
+        console.error(`Could not reach hivemind server at ${serverUrl()}. Is it running? (hivemind-server)`);
+        process.exitCode = 2;
+        return;
+    }
+    const history = (await res.json());
+    if (opts.json) {
+        console.log(JSON.stringify(history, null, 2));
+        return;
+    }
+    console.log(`Server-wide run history from ${serverUrl()} (not scoped to this project yet):`);
+    if (history.length === 0) {
+        console.log('No runs yet.');
+        return;
+    }
+    for (const entry of history) {
+        const status = entry.status === 'passed' ? 'PASS' : entry.status.toUpperCase();
+        console.log(`${status.padEnd(6)} ${entry.timestamp}  ${entry.name}`);
+    }
+}

package/dist/commands/run.js

@@ -0,0 +1,171 @@
+import { join } from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { loadTestFile } from '../testFile/parse.js';
+import { findTestFiles } from '../testFile/discover.js';
+import { resolveSteps } from '../testFile/resolve.js';
+import { loadConfig, resolveUrl, resolveCredential } from '../config.js';
+import { runOnServer } from '../serverClient.js';
+import { runTestLocally, isLocalUrl } from './runLocal.js';
+import { printResult, printSummary } from '../report/terminal.js';
+import { renderRunPrComment } from '../report/prComment.js';
+import { getChangedFiles, affectedTags, filterByTags } from '../testFile/select.js';
+/** Runs `items` through `worker` with at most `limit` in flight at once. Not fixed batching —
+ *  each slot immediately pulls the next item as soon as it's free, so a fast test doesn't sit
+ *  waiting on a slow one in the same "batch". */
+async function runPool(items, limit, worker) {
+    let next = 0;
+    async function runSlot() {
+        while (next < items.length) {
+            const i = next++;
+            await worker(items[i], i);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runSlot));
+}
+async function readLocalMemory(cwd) {
+    try {
+        return await readFile(join(cwd, '.hive', 'memory.md'), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+async function writeLocalMemory(cwd, content) {
+    const path = join(cwd, '.hive', 'memory.md');
+    await mkdir(join(cwd, '.hive'), { recursive: true });
+    await writeFile(path, content, 'utf-8');
+}
+export async function runCommand(target, opts) {
+    const cwd = process.cwd();
+    const config = await loadConfig(cwd);
+    let files = await findTestFiles(target);
+    if (files.length === 0) {
+        console.error(`No test files found at ${target}`);
+        process.exitCode = 2;
+        return;
+    }
+    let loadedTests = await Promise.all(files.map(async (file) => ({ file, test: await loadTestFile(file) })));
+    if (opts.changed) {
+        const base = typeof opts.changed === 'string' ? opts.changed : 'main';
+        const changedFiles = getChangedFiles(cwd, base);
+        const tags = affectedTags(changedFiles, config);
+        const selected = filterByTags(loadedTests, tags);
+        console.log(`--changed ${base}: ${changedFiles.length} file(s) changed, tags [${[...tags].join(', ') || 'none'}], ${selected.length}/${loadedTests.length} test(s) selected`);
+        loadedTests = selected;
+        files = loadedTests.map((t) => t.file);
+    }
+    if (files.length === 0) {
+        console.log('No tests match — nothing to run.');
+        process.exitCode = 0;
+        return;
+    }
+    const serverUrl = process.env.HIVEMIND_SERVER_URL || 'https://app.thecolonylab.com';
+    const memoryContext = await readLocalMemory(cwd);
+    const results = new Array(loadedTests.length);
+    const testsRoot = join(cwd, 'hive', 'tests');
+    const concurrency = Math.max(1, parseInt(opts.concurrency ?? '1', 10) || 1);
+    if (concurrency > 1 && !opts.json) {
+        console.log(`🐝 Swarm mode — running up to ${concurrency} test(s) at once...`);
+    }
+    await runPool(loadedTests, concurrency, async ({ test }, index) => {
+        let url, credential, resolvedSteps;
+        try {
+            url = resolveUrl(config, test.url, opts.url, opts.env);
+            credential = resolveCredential(config, test.login);
+            resolvedSteps = await resolveSteps(test, testsRoot);
+            if (test.before.length) {
+                console.log(`  before: ${test.before.map((b) => b.name).join(', ')} → ${resolvedSteps.length} total steps`);
+            }
+        }
+        catch (err) {
+            console.error(`✗ ${test.name}: ${err.message}`);
+            results[index] = {
+                name: test.name,
+                result: { status: 'error', verdict: err.message, steps: [], toolLog: [], screenshots: [], durationMs: 0 },
+            };
+            return;
+        }
+        // Local mode is opt-in ONLY (--local) — never auto-detected. Cloud mode needs nothing extra
+        // installed on this machine; local mode needs real Playwright browser binaries present, so
+        // silently guessing local would risk a confusing failure on what looked like normal usage.
+        // If a local/private URL is targeted without --local, fail fast with a clear reason instead
+        // of letting the cloud server attempt (and fail) to reach it.
+        if (!opts.local && isLocalUrl(url)) {
+            const message = `"${url}" looks like a local/private URL — the cloud server can't reach it. Add --local to run the browser on this machine instead.`;
+            console.error(`✗ ${test.name}: ${message}`);
+            results[index] = {
+                name: test.name,
+                result: { status: 'error', verdict: message, steps: [], toolLog: [], screenshots: [], durationMs: 0 },
+            };
+            return;
+        }
+        const runLocally = !!opts.local;
+        try {
+            if (runLocally) {
+                // Browser runs right here — the only thing this needs from the cloud is decisions,
+                // via RemoteLLMClient. No memory folding in local mode yet (v1 scope) — memoryContext
+                // is still read for context, just not written back.
+                console.log(`  🐝 Forager active — browser on this machine, Hivemind brain via ${serverUrl}`);
+                const { result, reportPath } = await runTestLocally({
+                    cwd,
+                    serverUrl,
+                    name: test.name,
+                    url,
+                    steps: resolvedSteps,
+                    memoryContext,
+                    credential,
+                    headed: opts.headed,
+                });
+                await writeFile(join(cwd, '.hive', 'last-run.json'), JSON.stringify({ reportUrl: reportPath, name: test.name }, null, 2)).catch(() => { });
+                results[index] = { name: test.name, result, reportUrl: reportPath };
+                if (!opts.json) {
+                    printResult(test.name, result);
+                    console.log(`  report: ${reportPath}`);
+                }
+            }
+            else {
+                const { result, updatedMemory, reportUrl: reportPath } = await runOnServer({
+                    name: test.name,
+                    url,
+                    steps: resolvedSteps,
+                    memoryContext,
+                    credential,
+                });
+                const reportUrl = `${serverUrl}${reportPath}`;
+                await writeLocalMemory(cwd, updatedMemory).catch(() => { });
+                await writeFile(join(cwd, '.hive', 'last-run.json'), JSON.stringify({ reportUrl, name: test.name }, null, 2)).catch(() => { });
+                results[index] = { name: test.name, result, reportUrl };
+                if (!opts.json) {
+                    printResult(test.name, result);
+                    console.log(`  report: ${reportUrl}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`✗ ${test.name}: ${err.message}`);
+            results[index] = {
+                name: test.name,
+                result: { status: 'error', verdict: err.message, steps: [], toolLog: [], screenshots: [], durationMs: 0 },
+            };
+        }
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(results.map((r) => ({
+            name: r.name,
+            status: r.result.status,
+            verdict: r.result.verdict,
+            durationMs: r.result.durationMs,
+            steps: r.result.steps,
+            reportUrl: r.reportUrl,
+        })), null, 2));
+    }
+    else if (results.length > 1) {
+        printSummary(results);
+    }
+    if (opts.prComment) {
+        await writeFile(opts.prComment, renderRunPrComment(results), 'utf-8');
+        if (!opts.json)
+            console.log(`\nPR comment written to ${opts.prComment}`);
+    }
+    process.exitCode = results.some((r) => r.result.status !== 'passed') ? 1 : 0;
+}

package/dist/commands/runLocal.js

@@ -0,0 +1,99 @@
+import WebSocket from 'ws';
+import { openSession } from '../browser/session.js';
+import { Forager } from './remoteExecutor.js';
+import { createArtifactDir, writeRunArtifacts, artifactDirFor } from '../report/artifacts.js';
+import { readApiKey } from '../credentials.js';
+/** Recognizes localhost / private-network URLs — the browser MUST run locally for these, since
+ *  no cloud server can reach them. Also usable via an explicit --local flag for anything else
+ *  (VPN-only staging, etc.) that a cloud server can't reach either. */
+export function isLocalUrl(url) {
+    let hostname;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        return false;
+    }
+    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1')
+        return true;
+    if (hostname.endsWith('.local'))
+        return true;
+    if (/^10\./.test(hostname))
+        return true;
+    if (/^192\.168\./.test(hostname))
+        return true;
+    if (/^172\.(1[6-9]|2\d|3[0-1])\./.test(hostname))
+        return true;
+    return false;
+}
+/**
+ * Local execution mode: the browser runs right here (so it can reach localhost/private
+ * networks), but every decision — what to click, what it means, whether the test passed — is
+ * made entirely by the server, exactly like a cloud run. This machine just executes the one
+ * instruction it's given each time and reports back; it never decides anything itself.
+ */
+export async function runTestLocally(opts) {
+    const { runId } = await createArtifactDir(opts.cwd, opts.name);
+    const session = await openSession({ headed: opts.headed });
+    const executor = new Forager(session.page, Date.now());
+    let closed = false;
+    try {
+        const wsUrl = opts.serverUrl.replace(/^http/, 'ws') + '/ws/local-run';
+        const apiKey = await readApiKey();
+        const result = await new Promise((resolve, reject) => {
+            const headers = { 'User-Agent': 'Hivemind-Forager/0.1.0' };
+            if (apiKey)
+                headers.Authorization = `Bearer ${apiKey}`;
+            const socket = new WebSocket(wsUrl, { headers });
+            socket.on('open', () => {
+                socket.send(JSON.stringify({
+                    type: 'start',
+                    name: opts.name,
+                    url: opts.url,
+                    steps: opts.steps,
+                    memoryContext: opts.memoryContext,
+                    credential: opts.credential,
+                }));
+            });
+            socket.on('message', async (raw) => {
+                let msg;
+                try {
+                    msg = JSON.parse(raw.toString());
+                }
+                catch {
+                    return;
+                }
+                if (msg.type === 'call') {
+                    const toolResult = await executor.execute(msg.name, msg.input);
+                    socket.send(JSON.stringify({ type: 'result', callId: msg.callId, ...toolResult }));
+                    return;
+                }
+                if (msg.type === 'finish') {
+                    resolve(msg.result);
+                    socket.close();
+                    return;
+                }
+                if (msg.type === 'error') {
+                    reject(new Error(msg.message));
+                    socket.close();
+                }
+            });
+            socket.on('error', (err) => reject(err));
+            socket.on('close', (code) => {
+                if (code !== 1000 && code !== 1005)
+                    reject(new Error(`Connection to hivemind server closed unexpectedly (code ${code})`));
+            });
+        });
+        // result.screenshots already carries the actual base64 image bytes this executor captured —
+        // the server only relayed them back in the finish message, it never had its own copies.
+        await session.close();
+        closed = true;
+        await writeRunArtifacts(opts.cwd, runId, opts.name, result);
+        const reportPath = `${artifactDirFor(opts.cwd, runId)}/report.html`;
+        return { result, reportPath };
+    }
+    finally {
+        if (!closed)
+            await session.close();
+    }
+}

package/dist/config.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function loadConfig(cwd) {
+    try {
+        const raw = await readFile(join(cwd, 'hivemind.config.json'), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/** Resolves a test's `Login: <label>` against hivemind.config.json's accounts. Password comes
+ *  from the env var named in passwordEnv — never stored in the config file or the test file. */
+export function resolveCredential(config, label) {
+    if (!label)
+        return undefined;
+    const account = config.accounts?.[label];
+    if (!account) {
+        throw new Error(`Test references Login: ${label}, but no account with that label is configured in hivemind.config.json's "accounts".`);
+    }
+    const password = process.env[account.passwordEnv];
+    if (!password) {
+        throw new Error(`Account "${label}" needs environment variable ${account.passwordEnv} to be set (referenced by hivemind.config.json), but it's not.`);
+    }
+    return { label, username: account.username, password };
+}
+export function resolveUrl(config, testUrl, cliUrl, env) {
+    if (cliUrl)
+        return cliUrl;
+    if (env && config.environments?.[env])
+        return config.environments[env];
+    if (testUrl)
+        return testUrl;
+    if (config.environments?.default)
+        return config.environments.default;
+    throw new Error('No URL resolved. Pass --url, set URL: in the test file, or set environments.default in hivemind.config.json');
+}

package/dist/credentials.js

@@ -0,0 +1,24 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/** Where `hivemind login <key>` stores the API key — global to this machine, not per-project,
+ *  since the same person usually runs hivemind against many different repos. */
+function credentialsPath() {
+    return join(homedir(), '.hivemind', 'credentials.json');
+}
+export async function readApiKey() {
+    if (process.env.HIVEMIND_API_KEY)
+        return process.env.HIVEMIND_API_KEY;
+    try {
+        const raw = await readFile(credentialsPath(), 'utf-8');
+        return JSON.parse(raw).apiKey;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeApiKey(key) {
+    const path = credentialsPath();
+    await mkdir(join(homedir(), '.hivemind'), { recursive: true });
+    await writeFile(path, JSON.stringify({ apiKey: key }, null, 2), 'utf-8');
+}

package/dist/report/artifacts.js

@@ -0,0 +1,48 @@
+import { mkdir, writeFile, readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { renderHtmlReport } from './html.js';
+import { slugify } from '../testFile/write.js';
+function timestampDir() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+export function artifactDirFor(cwd, runId) {
+    return join(cwd, 'artifacts', runId);
+}
+/** Creates the artifact directory for a run BEFORE it starts, so ToolExecutor can write screenshots into it. */
+export async function createArtifactDir(cwd, testName) {
+    const runId = `${timestampDir()}-${slugify(testName)}`;
+    const artifactDir = artifactDirFor(cwd, runId);
+    await mkdir(artifactDir, { recursive: true });
+    return { runId, artifactDir };
+}
+/** Writes report.html + history record for a completed run into its (already-created) artifact dir. */
+export async function writeRunArtifacts(cwd, runId, testName, result) {
+    const artifactDir = artifactDirFor(cwd, runId);
+    const html = renderHtmlReport(testName, result);
+    await writeFile(join(artifactDir, 'report.html'), html, 'utf-8');
+    const historyDir = join(cwd, '.hive', 'history');
+    await mkdir(historyDir, { recursive: true });
+    const entry = {
+        name: testName,
+        status: result.status,
+        verdict: result.verdict,
+        timestamp: new Date().toISOString(),
+        runId,
+        durationMs: result.durationMs,
+    };
+    await writeFile(join(historyDir, `${runId}.json`), JSON.stringify(entry, null, 2), 'utf-8');
+    return artifactDir;
+}
+export async function readHistory(cwd) {
+    const historyDir = join(cwd, '.hive', 'history');
+    try {
+        const files = await readdir(historyDir);
+        const entries = await Promise.all(files
+            .filter((f) => f.endsWith('.json'))
+            .map(async (f) => JSON.parse(await readFile(join(historyDir, f), 'utf-8'))));
+        return entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    }
+    catch {
+        return [];
+    }
+}