openmerit 0.4.1 → 0.4.2

package/dist/state/db.js

@@ -0,0 +1,260 @@
+// Local run history in SQLite (~/.openmerit/state.db), shared by the CLI and the MCP server and
+// scoped by repository. It records runs, progress, eval units, paid usage and budget approvals,
+// rankings and configuration decisions; never keys or raw dataset contents.
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { openmeritHome } from "./paths.js";
+// node:sqlite prints an ExperimentalWarning on Node 22; keep it off the terminal (and MCP clients).
+const sqlite = await (async () => {
+    const listeners = process.listeners("warning");
+    process.removeAllListeners("warning");
+    process.on("warning", warning => { if (warning.name !== "ExperimentalWarning")
+        for (const listener of listeners)
+            listener(warning); });
+    return import("node:sqlite");
+})();
+const MIGRATIONS = [
+    `CREATE TABLE repos (id TEXT PRIMARY KEY, root TEXT NOT NULL, created_at TEXT NOT NULL);
+   CREATE TABLE runs (id TEXT PRIMARY KEY, repo_id TEXT NOT NULL REFERENCES repos(id), revision TEXT, status TEXT NOT NULL, phase TEXT NOT NULL,
+     created_at TEXT NOT NULL, updated_at TEXT NOT NULL, package_version TEXT NOT NULL, catalogue_version TEXT NOT NULL, harness TEXT NOT NULL,
+     budget_usd REAL NOT NULL, state_json TEXT NOT NULL, error TEXT, lock_pid INTEGER);
+   CREATE INDEX runs_repo ON runs(repo_id, created_at);
+   CREATE TABLE events (id INTEGER PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), at TEXT NOT NULL, kind TEXT NOT NULL, message TEXT NOT NULL);
+   CREATE TABLE eval_units (id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), task TEXT NOT NULL, model TEXT NOT NULL, endpoint TEXT NOT NULL,
+     role TEXT NOT NULL, repeat INTEGER NOT NULL, status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0, result_json TEXT, error TEXT, updated_at TEXT NOT NULL);
+   CREATE TABLE usage (id INTEGER PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), unit_id TEXT NOT NULL, model TEXT NOT NULL, endpoint TEXT NOT NULL,
+     status TEXT NOT NULL, reserved_usd REAL NOT NULL, estimated_usd REAL, actual_usd REAL, latency_ms INTEGER, created_at TEXT NOT NULL, settled_at TEXT);
+   CREATE INDEX usage_run ON usage(run_id);
+   CREATE TABLE budget_events (id INTEGER PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), at TEXT NOT NULL, kind TEXT NOT NULL,
+     from_usd REAL, to_usd REAL, scope TEXT, spent_usd REAL);
+   CREATE TABLE decisions (id INTEGER PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), at TEXT NOT NULL, kind TEXT NOT NULL, decision TEXT NOT NULL, detail_json TEXT NOT NULL);`,
+];
+const now = () => new Date().toISOString();
+function alive(pid) {
+    if (!pid)
+        return false;
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export class State {
+    db;
+    path;
+    constructor(env = process.env) {
+        const home = openmeritHome(env);
+        mkdirSync(home, { recursive: true, mode: 0o700 });
+        this.path = join(home, "state.db");
+        this.db = new sqlite.DatabaseSync(this.path);
+        this.db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 10000; PRAGMA foreign_keys = ON;");
+        this.migrate();
+    }
+    /** Applies schema upgrades in order; older history stays readable. */
+    migrate() {
+        this.db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+        this.transaction(() => {
+            const row = this.db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+            const version = row ? Number(row.value) : 0;
+            for (let index = version; index < MIGRATIONS.length; index++)
+                this.db.exec(MIGRATIONS[index]);
+            this.db.prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(Math.max(version, MIGRATIONS.length)));
+        });
+    }
+    get schemaVersion() { return Number(this.db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get().value); }
+    /** BEGIN IMMEDIATE: one writer at a time across CLI and MCP processes. */
+    transaction(work) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const result = work();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    close() { this.db.close(); }
+    createRun(input) {
+        const at = now();
+        this.transaction(() => {
+            this.db.prepare("INSERT OR IGNORE INTO repos (id, root, created_at) VALUES (?, ?, ?)").run(input.repo.id, input.repo.root, at);
+            this.db.prepare(`INSERT INTO runs (id, repo_id, revision, status, phase, created_at, updated_at, package_version, catalogue_version, harness, budget_usd, state_json, lock_pid)
+        VALUES (?, ?, ?, 'running', 'scan', ?, ?, ?, ?, ?, ?, ?, NULL)`)
+                .run(input.id, input.repo.id, input.repo.revision ? `${input.repo.revision}${input.repo.dirty ? "+dirty" : ""}` : null, at, at, input.packageVersion, input.catalogueVersion, input.harness, input.budgetUsd, JSON.stringify(input.state));
+        });
+        this.event(input.id, "start", `Run started (openmerit ${input.packageVersion}, catalogue ${input.catalogueVersion}, harness ${input.harness}, budget $${input.budgetUsd.toFixed(2)})`);
+        return this.getRun(input.id);
+    }
+    getRun(id) {
+        const row = this.db.prepare("SELECT runs.*, repos.root FROM runs JOIN repos ON repos.id = runs.repo_id WHERE runs.id = ?").get(id);
+        return row ? this.toRun(row) : null;
+    }
+    listRuns(repoId, limit = 50) {
+        return this.db.prepare("SELECT runs.*, repos.root FROM runs JOIN repos ON repos.id = runs.repo_id WHERE repo_id = ? ORDER BY created_at DESC LIMIT ?").all(repoId, limit).map(row => this.toRun(row));
+    }
+    toRun(row) {
+        return {
+            id: row.id, repoId: row.repo_id, repoRoot: row.root, revision: row.revision, status: row.status, phase: row.phase,
+            createdAt: row.created_at, updatedAt: row.updated_at, packageVersion: row.package_version, catalogueVersion: row.catalogue_version,
+            harness: row.harness, budgetUsd: row.budget_usd, state: JSON.parse(row.state_json), error: row.error, lockPid: row.lock_pid,
+        };
+    }
+    updateRun(id, patch) {
+        const sets = ["updated_at = ?"];
+        const values = [now()];
+        if (patch.status) {
+            sets.push("status = ?");
+            values.push(patch.status);
+        }
+        if (patch.phase) {
+            sets.push("phase = ?");
+            values.push(patch.phase);
+        }
+        if (patch.state) {
+            sets.push("state_json = ?");
+            values.push(JSON.stringify(patch.state));
+        }
+        if (patch.error !== undefined) {
+            sets.push("error = ?");
+            values.push(patch.error);
+        }
+        if (patch.budgetUsd !== undefined) {
+            sets.push("budget_usd = ?");
+            values.push(patch.budgetUsd);
+        }
+        if (patch.harness) {
+            sets.push("harness = ?");
+            values.push(patch.harness);
+        }
+        this.db.prepare(`UPDATE runs SET ${sets.join(", ")} WHERE id = ?`).run(...values, id);
+    }
+    /** Takes the run for this process. Fails while another live process works on it. */
+    lock(id) {
+        return this.transaction(() => {
+            const row = this.db.prepare("SELECT lock_pid FROM runs WHERE id = ?").get(id);
+            if (!row)
+                throw new Error(`No run ${id}`);
+            if (row.lock_pid && row.lock_pid !== process.pid && alive(row.lock_pid))
+                return false;
+            this.db.prepare("UPDATE runs SET lock_pid = ? WHERE id = ?").run(process.pid, id);
+            return true;
+        });
+    }
+    unlock(id) { this.db.prepare("UPDATE runs SET lock_pid = NULL WHERE id = ? AND lock_pid = ?").run(id, process.pid); }
+    /**
+     * Runs whose process died mid-work become `interrupted`: running units are interrupted, and
+     * reservations of requests that never settled stay counted as in-flight spend of unknown cost.
+     */
+    reapInterrupted(repoId) {
+        return this.transaction(() => {
+            const rows = this.db.prepare("SELECT id, lock_pid FROM runs WHERE repo_id = ? AND status = 'running' AND lock_pid IS NOT NULL").all(repoId);
+            const reaped = rows.filter(row => !alive(row.lock_pid)).map(row => row.id);
+            for (const id of reaped)
+                this.interrupted(id, "The process stopped before the run finished; completed work and spend are kept.");
+            return reaped;
+        });
+    }
+    /** Marks a run interrupted (Ctrl-C, or a dead process). Unsettled reservations stay counted as in-flight spend. */
+    markInterrupted(runId, message = "Interrupted; completed work and spend are kept.") { this.transaction(() => this.interrupted(runId, message)); }
+    interrupted(id, message) {
+        this.db.prepare("UPDATE runs SET status = 'interrupted', lock_pid = NULL, updated_at = ? WHERE id = ?").run(now(), id);
+        this.db.prepare("UPDATE eval_units SET status = 'interrupted', updated_at = ? WHERE run_id = ? AND status = 'running'").run(now(), id);
+        this.db.prepare("UPDATE usage SET status = 'interrupted' WHERE run_id = ? AND status = 'reserved'").run(id);
+        this.db.prepare("INSERT INTO events (run_id, at, kind, message) VALUES (?, ?, 'interrupted', ?)").run(id, now(), message);
+    }
+    event(runId, kind, message) {
+        this.db.prepare("INSERT INTO events (run_id, at, kind, message) VALUES (?, ?, ?, ?)").run(runId, now(), kind, message);
+    }
+    events(runId) {
+        return this.db.prepare("SELECT at, kind, message FROM events WHERE run_id = ? ORDER BY id").all(runId);
+    }
+    ensureUnit(unit) {
+        this.db.prepare("INSERT OR IGNORE INTO eval_units (id, run_id, task, model, endpoint, role, repeat, status, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)")
+            .run(unit.id, unit.runId, unit.task, unit.model, unit.endpoint, unit.role, unit.repeat, now());
+        return this.units(unit.runId).find(item => item.id === unit.id);
+    }
+    units(runId) {
+        return this.db.prepare("SELECT * FROM eval_units WHERE run_id = ? ORDER BY rowid").all(runId).map(row => ({
+            id: row.id, runId: row.run_id, task: row.task, model: row.model, endpoint: row.endpoint, role: row.role,
+            repeat: row.repeat, status: row.status, attempts: row.attempts,
+            result: row.result_json ? JSON.parse(row.result_json) : null, error: row.error,
+        }));
+    }
+    setUnit(id, patch) {
+        this.db.prepare(`UPDATE eval_units SET status = ?, result_json = COALESCE(?, result_json), error = ?, attempts = attempts + ?, updated_at = ? WHERE id = ?`)
+            .run(patch.status, patch.result ? JSON.stringify(patch.result) : null, patch.error ?? null, patch.attempt ? 1 : 0, now(), id);
+    }
+    spend(runId, unitId) {
+        const rows = this.db.prepare(`SELECT status, reserved_usd, estimated_usd, actual_usd FROM usage WHERE run_id = ?${unitId ? " AND unit_id = ?" : ""}`).all(...(unitId ? [runId, unitId] : [runId]));
+        const spend = { settledUsd: 0, estimatedUsd: 0, inFlightUsd: 0, inFlight: 0, unknown: 0, requests: rows.length, totalUsd: 0 };
+        for (const row of rows) {
+            if (row.status === "reserved" || row.status === "interrupted") {
+                spend.inFlightUsd += row.reserved_usd;
+                spend.inFlight++;
+                continue;
+            }
+            if (row.actual_usd !== null)
+                spend.settledUsd += row.actual_usd;
+            else if (row.estimated_usd !== null) {
+                spend.settledUsd += row.estimated_usd;
+                spend.estimatedUsd += row.estimated_usd;
+            }
+            else {
+                spend.settledUsd += row.reserved_usd;
+                spend.unknown++;
+            }
+        }
+        spend.totalUsd = spend.settledUsd + spend.inFlightUsd;
+        return spend;
+    }
+    /**
+     * Reserves a paid request's expected cost against the run budget, atomically across processes.
+     * Refused when settled plus reserved spend plus this request would pass the run's budget.
+     */
+    reserve(input) {
+        return this.transaction(() => {
+            const budgetUsd = this.db.prepare("SELECT budget_usd FROM runs WHERE id = ?").get(input.runId).budget_usd;
+            const spend = this.spend(input.runId);
+            if (spend.totalUsd + input.expectedUsd > budgetUsd + 1e-9)
+                return { ok: false, spend, budgetUsd };
+            const result = this.db.prepare("INSERT INTO usage (run_id, unit_id, model, endpoint, status, reserved_usd, created_at) VALUES (?, ?, ?, ?, 'reserved', ?, ?)")
+                .run(input.runId, input.unitId, input.model, input.endpoint, input.expectedUsd, now());
+            return { ok: true, id: Number(result.lastInsertRowid) };
+        });
+    }
+    /** Records what a reserved request cost: provider-reported (`actualUsd`), list-price estimate, or unknown (both null). */
+    settle(id, cost) {
+        this.db.prepare("UPDATE usage SET status = ?, actual_usd = ?, estimated_usd = ?, latency_ms = ?, settled_at = ? WHERE id = ?")
+            .run(cost.failed ? "failed" : "settled", cost.actualUsd, cost.estimatedUsd, cost.latencyMs, now(), id);
+    }
+    usage(runId, unitId) {
+        const rows = this.db.prepare("SELECT status, actual_usd, estimated_usd, latency_ms FROM usage WHERE run_id = ? AND unit_id = ?").all(runId, unitId);
+        const settled = rows.filter(row => row.status === "settled");
+        return {
+            requests: settled.length, latencyMs: settled.reduce((sum, row) => sum + (row.latency_ms ?? 0), 0),
+            actualUsd: settled.reduce((sum, row) => sum + (row.actual_usd ?? 0), 0),
+            estimatedUsd: settled.reduce((sum, row) => sum + (row.actual_usd === null ? row.estimated_usd ?? 0 : 0), 0),
+            unknown: settled.filter(row => row.actual_usd === null && row.estimated_usd === null).length,
+        };
+    }
+    budgetEvent(runId, event) {
+        this.db.prepare("INSERT INTO budget_events (run_id, at, kind, from_usd, to_usd, scope, spent_usd) VALUES (?, ?, ?, ?, ?, ?, ?)")
+            .run(runId, now(), event.kind, event.fromUsd, event.toUsd ?? null, event.scope ?? null, event.spentUsd);
+    }
+    budgetEvents(runId) {
+        return this.db.prepare("SELECT at, kind, from_usd AS fromUsd, to_usd AS toUsd, scope, spent_usd AS spentUsd FROM budget_events WHERE run_id = ? ORDER BY id").all(runId);
+    }
+    decision(runId, kind, decision, detail) {
+        this.db.prepare("INSERT INTO decisions (run_id, at, kind, decision, detail_json) VALUES (?, ?, ?, ?, ?)").run(runId, now(), kind, decision, JSON.stringify(detail));
+    }
+    decisions(runId) {
+        return this.db.prepare("SELECT at, kind, decision, detail_json FROM decisions WHERE run_id = ? ORDER BY id").all(runId)
+            .map(row => ({ at: row.at, kind: row.kind, decision: row.decision, detail: JSON.parse(row.detail_json) }));
+    }
+}

package/dist/state/paths.d.ts

@@ -0,0 +1,12 @@
+/** OpenMerit's global directory: settings, secrets and the SQLite history. Never inside a repository. */
+export declare const openmeritHome: (env?: Record<string, string | undefined>) => string;
+export interface Repo {
+    /** Stable ID of the checkout: a hash of its real root path. */
+    id: string;
+    root: string;
+    /** Current commit, or null outside Git or before the first commit. */
+    revision: string | null;
+    dirty: boolean;
+}
+/** The repository containing `cwd`: its Git root, or `cwd` itself outside Git. */
+export declare function findRepo(cwd: string): Repo;

package/dist/state/paths.js

@@ -0,0 +1,23 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** OpenMerit's global directory: settings, secrets and the SQLite history. Never inside a repository. */
+export const openmeritHome = (env = process.env) => env.OPENMERIT_HOME ?? join(homedir(), ".openmerit");
+const git = (cwd, args) => {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+};
+/** The repository containing `cwd`: its Git root, or `cwd` itself outside Git. */
+export function findRepo(cwd) {
+    const root = realpathSync(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+    const revision = git(root, ["rev-parse", "HEAD"]);
+    // OpenMerit's own files (config, saved evals) do not make the code under test differ from the commit.
+    const status = git(root, ["status", "--porcelain", "--", ".", ":(exclude).openmerit"]);
+    return { id: createHash("sha256").update(root).digest("hex").slice(0, 16), root, revision, dirty: !!status };
+}

package/dist/update.d.ts

@@ -0,0 +1,22 @@
+export declare const packageVersion: () => string;
+export declare function newer(latest: string, current: string): boolean;
+export interface UpdateInfo {
+    current: string;
+    latest: string | null;
+    available: boolean;
+    error?: string;
+}
+/** Asks the npm registry for the latest version. Offline or slow registries are not errors. */
+export declare function checkForUpdate(env?: Record<string, string | undefined>, fetcher?: typeof fetch): Promise<UpdateInfo>;
+export declare const updateNotice: (info: UpdateInfo) => string | null;
+/**
+ * Interactive CLI flow. Returns the exit code of the updated process when it took over, or null to
+ * continue in this process on the installed version.
+ */
+export declare function offerUpdate(info: UpdateInfo, options: {
+    interactive: boolean;
+    confirm: (question: string) => Promise<boolean>;
+    log: (line: string) => void;
+    argv: string[];
+    env?: Record<string, string | undefined>;
+}): Promise<number | null>;

package/dist/update.js

@@ -0,0 +1,58 @@
+// Update check on every invocation: a newer `openmerit` on npm is offered, never installed silently.
+// Interactive: ask, install with approval, then continue on the new version (or the installed one).
+// Non-interactive or MCP: report it without prompting; MCP reports it through the client.
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+export const packageVersion = () => JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export function newer(latest, current) {
+    const parse = (value) => value.replace(/^v/, "").split("-")[0].split(".").map(part => Number(part) || 0);
+    const [a, b] = [parse(latest), parse(current)];
+    for (let index = 0; index < 3; index++)
+        if ((a[index] ?? 0) !== (b[index] ?? 0))
+            return (a[index] ?? 0) > (b[index] ?? 0);
+    return !latest.includes("-") && current.includes("-") && parse(latest).join(".") === parse(current).join(".");
+}
+/** Asks the npm registry for the latest version. Offline or slow registries are not errors. */
+export async function checkForUpdate(env = process.env, fetcher = fetch) {
+    const current = packageVersion();
+    if (env.OPENMERIT_NO_UPDATE_CHECK === "1")
+        return { current, latest: null, available: false, error: "disabled" };
+    try {
+        const registry = (env.OPENMERIT_REGISTRY ?? "https://registry.npmjs.org").replace(/\/$/, "");
+        const response = await fetcher(`${registry}/openmerit/latest`, { signal: AbortSignal.timeout(Number(env.OPENMERIT_UPDATE_TIMEOUT_MS ?? 2500)), headers: { accept: "application/json" } });
+        if (!response.ok)
+            return { current, latest: null, available: false, error: `registry HTTP ${response.status}` };
+        const latest = (await response.json()).version ?? null;
+        return { current, latest, available: !!latest && newer(latest, current) };
+    }
+    catch (error) {
+        return { current, latest: null, available: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export const updateNotice = (info) => (info.available ? `openmerit ${info.latest} is available (installed ${info.current}). Update with: npm install -g openmerit@${info.latest}` : null);
+/**
+ * Interactive CLI flow. Returns the exit code of the updated process when it took over, or null to
+ * continue in this process on the installed version.
+ */
+export async function offerUpdate(info, options) {
+    if (!info.available)
+        return null;
+    if (!options.interactive) {
+        options.log(updateNotice(info));
+        return null;
+    }
+    if (!(await options.confirm(`openmerit ${info.latest} is available (installed ${info.current}). Update now?`))) {
+        options.log(`Continuing with openmerit ${info.current}.`);
+        return null;
+    }
+    const env = options.env ?? process.env;
+    const npm = env.OPENMERIT_NPM ?? (process.platform === "win32" ? "npm.cmd" : "npm");
+    const install = spawnSync(npm, ["install", "-g", `openmerit@${info.latest}`], { stdio: ["ignore", "inherit", "inherit"], env });
+    if (install.status !== 0) {
+        options.log(`The update did not install (exit ${install.status ?? install.error?.message}); continuing with openmerit ${info.current}. Your history and settings are unchanged.`);
+        return null;
+    }
+    options.log(`Updated to openmerit ${info.latest}; continuing on it.`);
+    const rerun = spawnSync(env.OPENMERIT_BIN ?? "openmerit", options.argv, { stdio: "inherit", env: { ...env, OPENMERIT_NO_UPDATE_CHECK: "1" } });
+    return rerun.status ?? 1;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openmerit",
-  "version": "0.4.1",
-  "description": "Find the right model for your task: Scout reads your task or codebase, binary-searches benchmark-ranked models on your own labelled examples, and picks the winner from Langfuse evaluations.",
+  "version": "0.4.2",
+  "description": "Find cheaper models that perform at least as well as the ones your code uses, measured with your own evals: a local CLI and MCP server built on Pi, powered by Claude Code, Codex or an API key.",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -12,22 +12,12 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./pi": {
-      "types": "./dist/pi/extension.d.ts",
-      "default": "./dist/pi/extension.js"
-    },
     "./package.json": "./package.json"
   },
-  "pi": {
-    "extensions": [
-      "./dist/pi/extension.js"
-    ]
-  },
   "files": [
     "dist/",
     "!dist/**/*.test.*",
     "data/",
-    "examples/",
     "README.md",
     "LICENSE"
   ],
@@ -42,15 +32,20 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/rewrite-declaration-imports.ts && chmod +x dist/cli.js",
     "typecheck": "tsc -p tsconfig.json",
-    "test": "node --test \"src/**/*.test.ts\" \"test/**/*.test.ts\"",
+    "test": "node --test --test-concurrency=3 \"src/**/*.test.ts\" \"test/**/*.test.ts\"",
+    "test:fast": "node --test \"src/**/*.test.ts\" \"test/**/!(daemon).test.ts\"",
     "check": "npm run typecheck && npm test",
     "prepack": "npm run build",
-    "openmerit": "node src/cli.ts"
+    "openmerit": "node src/cli.ts",
+    "build:catalogue": "node scripts/build-catalogue.ts"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "1.5.0",
-    "@earendil-works/pi-coding-agent": "1.5.0",
-    "typebox": "1.3.27"
+    "@earendil-works/pi-ai": "1.5.2",
+    "@earendil-works/pi-coding-agent": "1.5.2",
+    "@rivet-dev/workflows": "1.1.1",
+    "jiti": "2.7.0",
+    "pi-claude-bridge": "0.12.0",
+    "rivetkit": "3.1.1"
   },
   "devDependencies": {
     "@types/node": "22.19.1",

package/dist/connectors/langfuse/otlp.d.ts

@@ -1,60 +0,0 @@
-/** Deterministic hex IDs, so a retried recording updates the same trace, spans and scores. */
-export declare const hexId: (value: string, length: 16 | 32) => string;
-type AnyValue = {
-    stringValue: string;
-} | {
-    boolValue: boolean;
-} | {
-    intValue: string;
-} | {
-    doubleValue: number;
-} | {
-    arrayValue: {
-        values: AnyValue[];
-    };
-};
-export interface Attribute {
-    key: string;
-    value: AnyValue;
-}
-export declare function attribute(key: string, value: string | number | boolean | string[]): Attribute;
-export declare const asText: (value: unknown) => string;
-export interface OtlpSpan {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    name: string;
-    kind: number;
-    startTimeUnixNano: string;
-    endTimeUnixNano: string;
-    attributes: Attribute[];
-    status: {
-        code: number;
-        message?: string;
-    };
-}
-export declare function span(input: {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    name: string;
-    startMs: number;
-    endMs: number;
-    attributes: Attribute[];
-    error?: string;
-}): OtlpSpan;
-export declare function exportRequest(spans: OtlpSpan[], version: string): {
-    resourceSpans: {
-        resource: {
-            attributes: Attribute[];
-        };
-        scopeSpans: {
-            scope: {
-                name: string;
-                version: string;
-            };
-            spans: OtlpSpan[];
-        }[];
-    }[];
-};
-export {};

package/dist/connectors/langfuse/otlp.js

@@ -1,40 +0,0 @@
-// Builds OTLP/HTTP JSON spans with Langfuse's attribute names (ingestion format v4), so a
-// recorded evaluation is a Langfuse experiment item without the deprecated dataset-run-items API.
-// https://langfuse.com/integrations/native/opentelemetry
-import { createHash } from "node:crypto";
-/** Deterministic hex IDs, so a retried recording updates the same trace, spans and scores. */
-export const hexId = (value, length) => createHash("sha256").update(value).digest("hex").slice(0, length);
-export function attribute(key, value) {
-    if (Array.isArray(value))
-        return { key, value: { arrayValue: { values: value.map((item) => ({ stringValue: item })) } } };
-    if (typeof value === "boolean")
-        return { key, value: { boolValue: value } };
-    if (typeof value === "number")
-        return { key, value: Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value } };
-    return { key, value: { stringValue: value } };
-}
-export const asText = (value) => (typeof value === "string" ? value : JSON.stringify(value) ?? "null");
-const nanos = (ms) => `${BigInt(Math.round(ms)) * 1000000n}`;
-export function span(input) {
-    return {
-        traceId: input.traceId,
-        spanId: input.spanId,
-        ...(input.parentSpanId ? { parentSpanId: input.parentSpanId } : {}),
-        name: input.name,
-        kind: 1,
-        startTimeUnixNano: nanos(input.startMs),
-        endTimeUnixNano: nanos(Math.max(input.endMs, input.startMs)),
-        attributes: input.attributes,
-        status: input.error ? { code: 2, message: input.error.slice(0, 500) } : { code: 1 },
-    };
-}
-export function exportRequest(spans, version) {
-    return {
-        resourceSpans: [
-            {
-                resource: { attributes: [attribute("service.name", "openmerit")] },
-                scopeSpans: [{ scope: { name: "openmerit-langfuse-connector", version }, spans }],
-            },
-        ],
-    };
-}

package/dist/pi/extension.d.ts

@@ -1,13 +0,0 @@
-import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
-export interface ScoutExtensionOptions {
-    /** Whether `scout_run` may spend money: true (headless `--execute`), false (plan only) or "ask" (confirm in the UI). */
-    allowSpend?: boolean | "ask";
-    /** Progress lines, for example to stderr in headless runs. */
-    log?: (line: string) => void;
-    /** The `provider/id` Scout runs on, for the judge grader. Defaults to the session's model. */
-    scoutModel?: string;
-}
-/** OpenMerit Scout inside Pi: model-recommendation tools, a `/scout` command and Scout's instructions. */
-export declare function createScoutExtension(options?: ScoutExtensionOptions): ExtensionFactory;
-declare const _default: ExtensionFactory;
-export default _default;