openmerit 0.4.1 → 0.4.2

package/dist/eval/proxy.d.ts

@@ -0,0 +1,54 @@
+import { type CatalogueModel } from "../catalogue/catalogue.js";
+import type { State } from "../state/db.js";
+export interface ProxyUnit {
+    runId: string;
+    unitId: string;
+    endpointId: string;
+    baseUrl: string;
+    apiKey: string;
+    /** The candidate (or baseline) the unit evaluates, as the endpoint names it. */
+    model: string;
+    /** Endpoint model ID → catalogue model, for every model the pool allows on this endpoint. */
+    allowed: (endpointModel: string) => CatalogueModel | null | undefined;
+}
+export interface UnitTally {
+    requests: number;
+    refused: number;
+    budgetHit: boolean;
+    poolViolations: string[];
+    upstreamErrors: number[];
+}
+/** Assumed output tokens when a request sets no maximum; reasoning models can use many. */
+export declare const DEFAULT_OUTPUT_TOKENS = 4096;
+/** Reservation for a request whose price is unknown. */
+export declare const UNKNOWN_PRICE_RESERVATION_USD = 0.05;
+export declare function expectedCost(model: CatalogueModel | null | undefined, body: Record<string, unknown>, bodyBytes: number): {
+    usd: number;
+    priced: boolean;
+};
+/** Token counts and provider cost from an OpenAI-style (or OpenRouter) response body or SSE stream. */
+export declare function readUsage(text: string): {
+    input: number;
+    output: number;
+    costUsd: number | null;
+} | null;
+/** How often a failed model call is sent again before the eval sees the failure. */
+export declare const MODEL_CALL_RETRIES = 3;
+/** Failures that may pass: timeouts, rate limits and server errors. Rejections such as 400 or 404 get the same answer again. */
+export declare const retryable: (status: number) => boolean;
+export declare class EvalProxy {
+    private server;
+    private readonly units;
+    private readonly state;
+    private readonly fetcher;
+    constructor(state: State, fetcher?: typeof fetch);
+    start(): Promise<string>;
+    stop(): Promise<void>;
+    /** A token for one eval unit; requests with it are metered against the unit's run. */
+    open(unit: ProxyUnit): {
+        token: string;
+        tally: UnitTally;
+    };
+    close(token: string): void;
+    private handle;
+}

package/dist/eval/proxy.js

@@ -0,0 +1,174 @@
+// The eval metering proxy: an OpenAI-compatible HTTP endpoint on 127.0.0.1 that exists only while
+// Scout runs approved evals. Each eval unit gets its own bearer token. For every request it:
+// 1. refuses models outside the repository's allowed pool for that endpoint;
+// 2. reserves the request's expected cost (prompt size + max output at list price) in SQLite and
+//    refuses it, before anything is sent, when that would pass the run's budget;
+// 3. forwards it with the endpoint's key, then settles the reservation with the provider-reported
+//    cost (OpenRouter) or a list-price estimate from the reported tokens (OpenAI-style endpoints).
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { setTimeout as sleep } from "node:timers/promises";
+import { requestPrice } from "../catalogue/catalogue.js";
+/** Assumed output tokens when a request sets no maximum; reasoning models can use many. */
+export const DEFAULT_OUTPUT_TOKENS = 4096;
+/** Reservation for a request whose price is unknown. */
+export const UNKNOWN_PRICE_RESERVATION_USD = 0.05;
+export function expectedCost(model, body, bodyBytes) {
+    const output = [body.max_completion_tokens, body.max_tokens, body.max_output_tokens].find(value => typeof value === "number" && value > 0);
+    const price = requestPrice(model ?? null, Math.ceil(bodyBytes / 3), output ?? DEFAULT_OUTPUT_TOKENS);
+    return price === null ? { usd: UNKNOWN_PRICE_RESERVATION_USD, priced: false } : { usd: price, priced: true };
+}
+/** Token counts and provider cost from an OpenAI-style (or OpenRouter) response body or SSE stream. */
+export function readUsage(text) {
+    const candidates = text.trimStart().startsWith("{") ? [text] : text.split("\n").filter(line => line.startsWith("data:")).map(line => line.slice(5).trim()).filter(line => line.startsWith("{"));
+    let found = null;
+    for (const chunk of candidates) {
+        try {
+            const value = JSON.parse(chunk);
+            const usage = value.usage ?? value.response?.usage;
+            if (!usage)
+                continue;
+            const input = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0), output = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
+            found = { input, output, costUsd: typeof usage.cost === "number" ? usage.cost : null };
+        }
+        catch { /* not JSON */ }
+    }
+    return found;
+}
+const send = (res, status, message, type) => {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: { message, type, code: status } }));
+};
+async function body(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 50_000_000)
+            throw new Error("request too large");
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+/** How often a failed model call is sent again before the eval sees the failure. */
+export const MODEL_CALL_RETRIES = 3;
+/** Failures that may pass: timeouts, rate limits and server errors. Rejections such as 400 or 404 get the same answer again. */
+export const retryable = (status) => status === 408 || status === 429 || status >= 500;
+/** Retry-After when the endpoint sends one (at most 30 s), else 2, 4 and 8 s. */
+const retryDelayMs = (retryAfter, attempt) => {
+    const seconds = Number(retryAfter);
+    return retryAfter !== null && Number.isFinite(seconds) && seconds >= 0 ? Math.min(seconds, 30) * 1000 : 2000 * 2 ** attempt;
+};
+export class EvalProxy {
+    server = null;
+    units = new Map();
+    state;
+    fetcher;
+    constructor(state, fetcher = fetch) { this.state = state; this.fetcher = fetcher; }
+    async start() {
+        this.server = createServer((req, res) => { this.handle(req, res).catch(error => { if (!res.headersSent)
+            send(res, 500, `OpenMerit proxy: ${error instanceof Error ? error.message : String(error)}`, "openmerit_proxy");
+        else
+            res.end(); }); });
+        await new Promise(resolve => this.server.listen(0, "127.0.0.1", resolve));
+        return `http://127.0.0.1:${this.server.address().port}/v1`;
+    }
+    async stop() {
+        const server = this.server;
+        this.server = null;
+        if (!server)
+            return;
+        const closed = new Promise(resolve => server.close(() => resolve()));
+        server.closeAllConnections();
+        await closed;
+    }
+    /** A token for one eval unit; requests with it are metered against the unit's run. */
+    open(unit) {
+        const token = `om-eval-${randomBytes(18).toString("hex")}`;
+        const tally = { requests: 0, refused: 0, budgetHit: false, poolViolations: [], upstreamErrors: [] };
+        this.units.set(token, { unit, tally });
+        return { token, tally };
+    }
+    close(token) { this.units.delete(token); }
+    async handle(req, res) {
+        const token = /^Bearer\s+(\S+)/i.exec(req.headers.authorization ?? "")?.[1] ?? req.headers["x-api-key"];
+        const entry = token ? this.units.get(token) : undefined;
+        if (!entry)
+            return send(res, 401, "OpenMerit proxy: unknown or closed eval token.", "openmerit_auth");
+        const { unit, tally } = entry;
+        const path = (req.url ?? "/").replace(/^\/v1/, "");
+        if (req.method === "GET" && path.startsWith("/models")) {
+            res.writeHead(200, { "content-type": "application/json" });
+            return res.end(JSON.stringify({ object: "list", data: [{ id: unit.model, object: "model" }] }));
+        }
+        if (req.method !== "POST")
+            return send(res, 405, "OpenMerit proxy: only POST model requests are forwarded.", "openmerit_method");
+        const raw = await body(req);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw.toString("utf8"));
+        }
+        catch {
+            return send(res, 400, "OpenMerit proxy: the request body is not JSON.", "openmerit_request");
+        }
+        const model = typeof parsed.model === "string" ? parsed.model : unit.model;
+        const catalogue = unit.allowed(model);
+        if (catalogue === undefined) {
+            tally.poolViolations.push(model);
+            return send(res, 403, `OpenMerit proxy: ${model} is not in this repository's allowed models for endpoint ${unit.endpointId}.`, "openmerit_pool");
+        }
+        if (parsed.stream === true)
+            parsed.stream_options = { ...parsed.stream_options, include_usage: true };
+        if (unit.baseUrl.includes("openrouter.ai"))
+            parsed.usage = { include: true };
+        const forwarded = Buffer.from(JSON.stringify(parsed));
+        const expected = expectedCost(catalogue, parsed, forwarded.length);
+        const reservation = this.state.reserve({ runId: unit.runId, unitId: unit.unitId, model, endpoint: unit.endpointId, expectedUsd: expected.usd });
+        if (!reservation.ok) {
+            tally.refused++;
+            tally.budgetHit = true;
+            return send(res, 402, `OpenMerit eval budget reached: $${reservation.spend.totalUsd.toFixed(4)} used or reserved of $${reservation.budgetUsd.toFixed(2)}; this request needs about $${expected.usd.toFixed(4)}. Paid evaluation is paused until the budget is raised.`, "openmerit_budget");
+        }
+        tally.requests++;
+        const started = Date.now();
+        const forward = () => this.fetcher(`${unit.baseUrl.replace(/\/$/, "")}${path}`, {
+            method: "POST", body: forwarded, redirect: "manual", signal: AbortSignal.timeout(600_000),
+            headers: { authorization: `Bearer ${unit.apiKey}`, "content-type": "application/json", accept: req.headers.accept ?? "application/json", ...(unit.baseUrl.includes("openrouter.ai") ? { "x-title": "OpenMerit Scout eval" } : {}) },
+        }).catch((error) => (error instanceof Error ? error : new Error(String(error))));
+        // A failed call that may pass is sent again, so the eval only sees failures that last; failed calls are not charged.
+        let upstream = await forward();
+        for (let attempt = 0; attempt < MODEL_CALL_RETRIES && (upstream instanceof Error || retryable(upstream.status)); attempt++) {
+            if (!(upstream instanceof Error))
+                await upstream.body?.cancel();
+            await sleep(retryDelayMs(upstream instanceof Error ? null : upstream.headers.get("retry-after"), attempt));
+            upstream = await forward();
+        }
+        if (upstream instanceof Error) {
+            tally.upstreamErrors.push(502);
+            this.state.settle(reservation.id, { actualUsd: 0, estimatedUsd: null, latencyMs: Date.now() - started, failed: true });
+            return send(res, 502, `OpenMerit proxy: ${unit.endpointId} did not answer (${upstream.message}).`, "openmerit_upstream");
+        }
+        res.writeHead(upstream.status, { "content-type": upstream.headers.get("content-type") ?? "application/json" });
+        let text = "";
+        const decoder = new TextDecoder();
+        const reader = upstream.body?.getReader();
+        for (;;) {
+            if (!reader)
+                break;
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            res.write(value);
+            text += decoder.decode(value, { stream: true });
+        }
+        res.end();
+        const latencyMs = Date.now() - started;
+        const usage = readUsage(text);
+        if (!upstream.ok)
+            tally.upstreamErrors.push(upstream.status);
+        if (!upstream.ok)
+            this.state.settle(reservation.id, { actualUsd: usage?.costUsd ?? 0, estimatedUsd: null, latencyMs, failed: true });
+        else
+            this.state.settle(reservation.id, { actualUsd: usage?.costUsd ?? null, estimatedUsd: usage ? requestPrice(catalogue ?? null, usage.input, usage.output) : null, latencyMs });
+    }
+}

package/dist/eval/runner.d.ts

@@ -0,0 +1,29 @@
+export interface EvalCommand {
+    command: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface EvalOutcome {
+    ok: boolean;
+    exitCode: number;
+    durationMs: number;
+    /** Per-item results the eval reported itself, or null when it reported none. */
+    items: {
+        id: string;
+        pass: boolean;
+    }[] | null;
+    /** Last lines of output, redacted, kept only when the eval failed. */
+    log?: string;
+    error?: string;
+}
+export declare function runEval(spec: EvalCommand, input: {
+    root: string;
+    model: string;
+    baseUrl: string;
+    token: string;
+    items: readonly string[] | null;
+    experiment: string;
+    env?: Record<string, string | undefined>;
+    signal?: AbortSignal;
+}): Promise<EvalOutcome>;

package/dist/eval/runner.js

@@ -0,0 +1,80 @@
+// Runs one eval unit: the task's existing eval command for one model and item set, routed through
+// the metering proxy. The eval contract (README "Eval contract"):
+// - OpenMerit sets OPENMERIT_MODEL (the model as the endpoint names it), OPENMERIT_BASE_URL and
+//   OPENMERIT_API_KEY (the proxy), the same values as OPENAI_BASE_URL and OPENAI_API_KEY,
+//   OPENMERIT_ITEMS (comma-separated dataset item IDs; empty for every item), OPENMERIT_EXPERIMENT
+//   (the experiment name to record under) and OPENMERIT_RESULT (a file path). `{{model}}`,
+//   `{{items}}` and `{{experiment}}` in the command or in `env` values become the same values.
+// - Per-item results come from the Langfuse experiment the eval records (read back by the caller),
+//   or from {"items": [{"id", "pass"}]} written to $OPENMERIT_RESULT or printed as stdout's last JSON line.
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { redact } from "../scout/scan.js";
+function lastJson(stdout) {
+    for (const line of stdout.trim().split("\n").reverse()) {
+        const text = line.trim();
+        if (!text.startsWith("{"))
+            continue;
+        try {
+            const value = JSON.parse(text);
+            if (value && typeof value === "object" && !Array.isArray(value))
+                return value;
+        }
+        catch { /* keep looking */ }
+    }
+    return null;
+}
+function reportedItems(result) {
+    if (!result || !Array.isArray(result.items))
+        return null;
+    const items = result.items.flatMap(raw => {
+        const item = raw;
+        const pass = typeof item.pass === "boolean" ? item.pass : item.passed;
+        return (typeof item.id === "string" || typeof item.id === "number") && typeof pass === "boolean" ? [{ id: String(item.id), pass }] : [];
+    });
+    return items.length ? items : null;
+}
+export async function runEval(spec, input) {
+    const dir = mkdtempSync(join(tmpdir(), "openmerit-eval-"));
+    const resultPath = join(dir, "result.json");
+    const items = (input.items ?? []).join(",");
+    const fill = (text) => text.replaceAll("{{model}}", input.model).replaceAll("{{items}}", items).replaceAll("{{experiment}}", input.experiment);
+    const base = input.env ?? process.env;
+    // Model calls go through the proxy with its one-unit token, never with the endpoint's own key.
+    // Other credentials (the app's Langfuse keys, for example) stay, so the eval records as it always does.
+    const env = Object.fromEntries(Object.entries(base).filter(([key]) => !/^(OPENAI|OPENROUTER)_API_KEY$/.test(key)));
+    Object.assign(env, {
+        OPENMERIT_MODEL: input.model, OPENMERIT_BASE_URL: input.baseUrl, OPENMERIT_API_KEY: input.token, OPENMERIT_RESULT: resultPath,
+        OPENMERIT_ITEMS: items, OPENMERIT_EXPERIMENT: input.experiment, OPENAI_BASE_URL: input.baseUrl, OPENAI_API_KEY: input.token,
+    }, Object.fromEntries(Object.entries(spec.env ?? {}).map(([key, value]) => [key, fill(value)])));
+    const started = Date.now();
+    try {
+        const { code, stdout, stderr } = await new Promise((done, fail) => {
+            const child = spawn("sh", ["-c", fill(spec.command)], { cwd: resolve(input.root, spec.cwd ?? "."), env, stdio: ["ignore", "pipe", "pipe"], ...(input.signal ? { signal: input.signal } : {}) });
+            let out = "", err = "";
+            const timer = setTimeout(() => child.kill("SIGTERM"), spec.timeoutMs ?? 1_800_000);
+            child.stdout.on("data", chunk => { out += chunk; if (out.length > 2_000_000)
+                out = out.slice(-1_000_000); });
+            child.stderr.on("data", chunk => { err += chunk; if (err.length > 200_000)
+                err = err.slice(-100_000); });
+            child.on("error", fail);
+            child.on("close", status => { clearTimeout(timer); done({ code: status ?? 1, stdout: out, stderr: err }); });
+        });
+        let result = null;
+        try {
+            result = JSON.parse(readFileSync(resultPath, "utf8"));
+        }
+        catch {
+            result = lastJson(stdout);
+        }
+        const outcome = { exitCode: code, durationMs: Date.now() - started, items: reportedItems(result) };
+        if (code !== 0)
+            return { ok: false, ...outcome, log: redact(`${stderr}\n${stdout}`.trim().split("\n").slice(-12).join("\n")).slice(-2000), error: `eval exited with ${code}` };
+        return { ok: true, ...outcome };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/dist/harness/claude-bridge.d.ts

@@ -0,0 +1,21 @@
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+type ProviderConfigInput = Parameters<ModelRuntime["registerProvider"]>[1];
+type Handler = (event: unknown, ctx: unknown) => unknown;
+export interface ClaudeBridge {
+    provider: ProviderConfigInput;
+    handlers: Map<string, Handler[]>;
+}
+export declare const CLAUDE_BRIDGE_PROVIDER = "claude-bridge";
+export declare const DEFAULT_CLAUDE_MODEL = "claude-sonnet-5-5";
+/** Loads the bridge once per process. Its config and log live in pi's agent directory (PI_CODING_AGENT_DIR). */
+export declare function loadClaudeBridge(): Promise<ClaudeBridge>;
+/** Runs `request` as one bridge session in `cwd`, so Claude Code starts there and accepts `systemPrompt`. */
+export declare function inBridgeSession<T>(bridge: ClaudeBridge, input: {
+    sessionId: string;
+    cwd: string;
+    systemPrompt: string;
+    tools: string[];
+}, request: () => Promise<T>): Promise<T>;
+/** The Claude Code executable for login checks: the one the Claude Agent SDK bundles, which the bridge runs. */
+export declare function claudeBinary(env?: Record<string, string | undefined>): string;
+export {};

package/dist/harness/claude-bridge.js

@@ -0,0 +1,65 @@
+// Claude Code through pi-claude-bridge (https://pi.dev/packages/pi-claude-bridge): a pi extension that
+// drives Claude Code with the Claude Agent SDK and the machine's Claude Code login. OpenMerit runs it
+// outside a pi coding-agent session, so this module gives it the two extension calls it uses
+// (registerProvider, on) and fires the session events the bridge relies on around each request:
+// session_start names the request's working directory, before_agent_start records its system prompt
+// (the bridge refuses a prompt it has not seen), and session_shutdown closes its Claude Code query.
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createJiti } from "jiti";
+export const CLAUDE_BRIDGE_PROVIDER = "claude-bridge";
+export const DEFAULT_CLAUDE_MODEL = "claude-sonnet-5-5";
+let loaded;
+/** Loads the bridge once per process. Its config and log live in pi's agent directory (PI_CODING_AGENT_DIR). */
+export function loadClaudeBridge() {
+    return loaded ??= (async () => {
+        const handlers = new Map();
+        let provider;
+        const shim = {
+            registerProvider: (id, config) => { if (id === CLAUDE_BRIDGE_PROVIDER)
+                provider = config; },
+            on: (event, handler) => { handlers.set(event, [...(handlers.get(event) ?? []), handler]); },
+        };
+        // The bridge ships TypeScript, which Node does not strip under node_modules; pi loads extensions with jiti too.
+        const module = await createJiti(import.meta.url).import("pi-claude-bridge/src/index.ts");
+        module.default(shim);
+        if (!provider)
+            throw new Error("pi-claude-bridge did not register its provider");
+        return { provider, handlers };
+    })().catch(error => { loaded = undefined; throw error; });
+}
+/** Runs `request` as one bridge session in `cwd`, so Claude Code starts there and accepts `systemPrompt`. */
+export async function inBridgeSession(bridge, input, request) {
+    const ctx = { cwd: input.cwd, ui: undefined, sessionManager: { getSessionId: () => input.sessionId }, modelRegistry: { getProvider: () => bridge.provider }, getSystemPrompt: () => input.systemPrompt };
+    const fire = async (name, event) => { for (const handler of bridge.handlers.get(name) ?? [])
+        await handler(event, ctx); };
+    await fire("session_start", { type: "session_start", reason: "startup" });
+    try {
+        await fire("before_agent_start", { type: "before_agent_start", systemPrompt: input.systemPrompt, systemPromptOptions: { customPrompt: input.systemPrompt, contextFiles: [], skills: [], selectedTools: input.tools } });
+        return await request();
+    }
+    finally {
+        await fire("session_shutdown", { type: "session_shutdown" });
+    }
+}
+/** The Claude Code executable for login checks: the one the Claude Agent SDK bundles, which the bridge runs. */
+export function claudeBinary(env = process.env) {
+    if (env.OPENMERIT_CLAUDE_BIN)
+        return env.OPENMERIT_CLAUDE_BIN;
+    try {
+        const fromBridge = createRequire(createRequire(import.meta.url).resolve("pi-claude-bridge/package.json"));
+        // The SDK's exports do not include its package.json, so resolve its entry point.
+        const fromSdk = createRequire(fromBridge.resolve("@anthropic-ai/claude-agent-sdk"));
+        for (const variant of ["", "-musl"]) {
+            try {
+                const path = join(dirname(fromSdk.resolve(`@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}${variant}/package.json`)), process.platform === "win32" ? "claude.exe" : "claude");
+                if (existsSync(path))
+                    return path;
+            }
+            catch { /* not installed for this libc */ }
+        }
+    }
+    catch { /* fall back to PATH */ }
+    return "claude";
+}

package/dist/harness/harness.d.ts

@@ -0,0 +1,60 @@
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { type HarnessSettings } from "../state/config.js";
+type Env = Record<string, string | undefined>;
+/** Pi's provider for ChatGPT Plus/Pro sign-ins, which serves Codex models. */
+export declare const CODEX_PROVIDER = "openai-codex";
+/** Used only when saved settings name no model; `openmerit connect codex` saves the best one the plan accepts. */
+export declare const DEFAULT_CODEX_MODEL = "gpt-5.6-terra";
+export interface HarnessUsage {
+    calls: number;
+    costUsd: number;
+    unknownCost: number;
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface JsonRequest {
+    system: string;
+    prompt: string;
+    /** JSON Schema of the reply; the reply is parsed and must be an object. */
+    schema: Record<string, unknown>;
+    /** Let the harness read (never write) files under `cwd` with pi's read-only tools. */
+    cwd?: string;
+    signal?: AbortSignal;
+}
+export interface Harness {
+    readonly kind: HarnessSettings["kind"];
+    /** The settings it runs on, as history names them. */
+    readonly label: string;
+    readonly usage: HarnessUsage;
+    json<T>(request: JsonRequest): Promise<T>;
+}
+/** Pi's model runtime on OpenMerit's agent directory, ~/.openmerit/agent: auth.json (the ChatGPT sign-in), models.json and the bridge's config. */
+export declare function harnessRuntime(env?: Env): Promise<ModelRuntime>;
+/** The first JSON object in a reply, with code fences removed. With `required`, the object must have those keys. */
+export declare function parseJsonObject(reply: string, required?: string[]): Record<string, unknown>;
+/** Builds the harness from saved settings. Fails clearly, without falling back, when it cannot. */
+export declare function createHarness(settings: HarnessSettings, env?: Env): Promise<Harness>;
+/** One round trip that proves the configured connection powers the harness. */
+export declare function verifyHarness(harness: Harness, cwd: string): Promise<{
+    ok: true;
+    detail: string;
+} | {
+    ok: false;
+    detail: string;
+}>;
+/** Runs the Claude Code executable the bridge uses, such as `auth status` or `auth login`. */
+export declare function runClaude(args: string[], options?: {
+    env?: Env;
+    interactive?: boolean;
+    signal?: AbortSignal;
+}): Promise<{
+    code: number;
+    stdout: string;
+}>;
+/** Whether Claude Code reports a login (its own status command), and whether OpenMerit has a ChatGPT sign-in. */
+export declare function detectAgents(env?: Env): Promise<{
+    kind: "claude-code" | "codex";
+    loggedIn: boolean;
+    detail: string;
+}[]>;
+export {};