openmerit 0.1.3 → 0.1.5

package/dist/pi-trials.js

@@ -1,366 +0,0 @@
-/** Run a task through pi for each model, using pi's JSON event stream as the measurement source. */
-import { spawn, spawnSync } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, relative } from "node:path";
-import { createHash } from "node:crypto";
-import { judge, judgeWithImages } from "./judge.js";
-import { knownInvoiceScore } from "./invoice-eval.js";
-import { paths, readJson } from "./store.js";
-import { sessionFiles, sessionImages, taskInputKey } from "./task-input.js";
-import { legacyOpenRouterRoute, meritModelId, modelRoute, routeKey } from "./routes.js";
-import { directChatClient } from "./llm.js";
-function answerText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content.filter((x) => !!x && typeof x === "object" && x.type === "text")
-        .map((x) => x.text ?? "").join("\n");
-}
-/** Pi-backed harness adapter. Future harnesses can implement the same seam. */
-export class PiHarnessAdapter {
-    runTask(model, input) {
-        return executePiTask(model, input.task, input.cwd, input.images, input.files);
-    }
-}
-const defaultHarness = new PiHarnessAdapter();
-const KNOWN_TRIAL_TOOLS = new Set([
-    "read", "grep", "find", "ls", "bash", "powershell", "edit", "write",
-]);
-/**
- * Candidate runs have no tools by default. Users may explicitly opt into a
- * list, but a copied cwd is not an OS sandbox for absolute paths or network.
- */
-export function piTrialToolArgs(setting = process.env.OPENMERIT_PI_TRIAL_TOOLS) {
-    if (!setting?.trim())
-        return ["--no-tools"];
-    const requested = [...new Set(setting.split(",").map((tool) => tool.trim()).filter(Boolean))];
-    if (requested.length === 1 && requested[0] === "none")
-        return ["--no-tools"];
-    const unknown = requested.filter((tool) => !KNOWN_TRIAL_TOOLS.has(tool));
-    if (requested.length === 0 || unknown.length > 0) {
-        throw new Error(`invalid OPENMERIT_PI_TRIAL_TOOLS${unknown.length ? `: ${unknown.join(", ")}` : ""}`);
-    }
-    return ["--tools", requested.join(",")];
-}
-function fileSnapshot(root) {
-    const out = new Map();
-    function walk(dir) {
-        for (const name of readdirSync(dir)) {
-            if (name === ".git" || name === "node_modules" || name === ".openmerit")
-                continue;
-            const file = join(dir, name);
-            const rel = relative(root, file);
-            const st = statSync(file);
-            if (st.isDirectory())
-                walk(file);
-            else if (st.isFile() && st.size < 20_000_000) {
-                out.set(rel, createHash("sha1").update(readFileSync(file)).digest("hex"));
-            }
-        }
-    }
-    walk(root);
-    return out;
-}
-function isolatedWorkspace(cwd) {
-    const root = mkdtempSync(join(tmpdir(), "openmerit-pi-workspace-"));
-    cpSync(cwd, root, { recursive: true, filter: (src) => {
-            const rel = relative(cwd, src);
-            return !rel.split("/").some((part) => part === ".git" || part === "node_modules" || part === ".openmerit");
-        } });
-    return root;
-}
-/** Use model A's completed result from the active pi session when it matches this task. */
-export function recordedActiveTask(task, model, images = [], sessionFile, sessionBytes) {
-    const state = sessionFile ? null : readJson(paths.harnessState(), {});
-    const file = sessionFile ?? state?.sessionFile;
-    if (!file || !existsSync(file))
-        return null;
-    let user = null;
-    const assistants = [];
-    let toolCalls = 0;
-    let toolErrors = 0;
-    for (const line of readFileSync(file).subarray(0, sessionBytes).toString("utf8").split("\n")) {
-        if (!line.trim())
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (entry.type !== "message" || !entry.message)
-            continue;
-        if (entry.message.role === "user") {
-            user = entry.message;
-            assistants.length = 0;
-            toolCalls = 0;
-            toolErrors = 0;
-        }
-        else if (user && entry.message.role === "assistant") {
-            assistants.push(entry.message);
-            if (Array.isArray(entry.message.content))
-                toolCalls += entry.message.content.filter((part) => part?.type === "toolCall").length;
-        }
-        else if (user && entry.message.role === "toolResult" &&
-            entry.message.isError)
-            toolErrors++;
-    }
-    const userImages = user ? sessionImages(user.content) : null;
-    const files = sessionFiles(task);
-    if (!user || !userImages || taskInputKey(answerText(user.content), userImages, sessionFiles(answerText(user.content))) !==
-        taskInputKey(task, images, files))
-        return null;
-    const matching = assistants.filter((m) => typeof model === "string"
-        ? meritModelId(m.provider ?? "openrouter", m.model ?? "") === model
-        : m.provider === model.provider && m.model === model.modelId);
-    if (matching.length === 0 || matching.some((m) => m.stopReason === "error"))
-        return null;
-    const answer = matching.map((m) => answerText(m.content)).filter(Boolean).at(-1) ?? "";
-    if (!answer.trim())
-        return null;
-    const first = user.timestamp ?? 0;
-    const last = matching.at(-1)?.timestamp ?? first;
-    return {
-        answer,
-        costUsd: matching.reduce((n, m) => n + (m.usage?.cost?.total ?? 0), 0),
-        latencyMs: Math.max(0, last - first),
-        errors: 0,
-        toolCalls,
-        toolErrors,
-        changedFiles: 0,
-    };
-}
-/** Read the exact latest completed text task from the pi extension's session marker. */
-export function settledActiveTask(snapshot) {
-    const st = snapshot ?? readJson(paths.harnessState(), {});
-    if (!st.currentModel || !st.sessionFile || !st.settledTaskKey || !st.settledAt ||
-        !existsSync(st.sessionFile))
-        return null;
-    let userContent = null;
-    let usedTools = false;
-    for (const line of readFileSync(st.sessionFile).subarray(0, st.sessionBytes).toString("utf8").split("\n")) {
-        if (!line.trim())
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (entry.type !== "message" || !entry.message)
-            continue;
-        if (entry.message.role === "user") {
-            userContent = entry.message.content;
-            usedTools = false;
-        }
-        else if (userContent && entry.message.role === "toolResult")
-            usedTools = true;
-        else if (userContent && entry.message.role === "assistant" &&
-            Array.isArray(entry.message.content) && entry.message.content.some((b) => b?.type === "toolCall"))
-            usedTools = true;
-    }
-    if (!userContent)
-        return null;
-    const images = sessionImages(userContent);
-    if (!images)
-        return null;
-    const task = answerText(userContent);
-    const files = sessionFiles(task);
-    if (!task.trim() || taskInputKey(task, images, files) !== st.settledTaskKey)
-        return null;
-    const route = st.currentRoute ?? legacyOpenRouterRoute(st.currentModel);
-    const run = recordedActiveTask(task, route, images, st.sessionFile, st.sessionBytes);
-    if (!run)
-        return null;
-    const routes = st.routes?.length ? st.routes : [route];
-    return { task, images, model: st.currentModel, run, sessionFile: st.sessionFile,
-        settledAt: st.settledAt, sessionBytes: st.sessionBytes, cwd: st.cwd ?? process.cwd(), usedTools, files,
-        route, routes };
-}
-export function piExecutable() {
-    return process.env.OPENMERIT_PI_BIN?.trim() || "pi";
-}
-function compactNumber(value) {
-    const match = value.match(/^(\d+(?:\.\d+)?)([KMG])?$/i);
-    if (!match)
-        return undefined;
-    const scale = { K: 1_000, M: 1_000_000, G: 1_000_000_000 }[(match[2] ?? "").toUpperCase()] ?? 1;
-    return Math.round(Number(match[1]) * scale);
-}
-/** Read provider/model routes from pi when no live extension snapshot is available. */
-export function availablePiRoutes(snapshot) {
-    if (snapshot?.length)
-        return snapshot;
-    const result = spawnSync(piExecutable(), ["--offline", "--list-models"], { encoding: "utf8" });
-    if (result.error || result.status !== 0)
-        throw new Error("could not list models from pi");
-    const routes = [];
-    for (const line of result.stdout.split("\n").slice(1)) {
-        const [provider, id, context, maxOut, , images] = line.trim().split(/\s+/);
-        if (!provider || !id || id.startsWith("~"))
-            continue;
-        routes.push(modelRoute(provider, id, {
-            input: images === "yes" ? ["text", "image"] : ["text"],
-            contextWindow: compactNumber(context),
-            maxTokens: compactNumber(maxOut),
-        }));
-    }
-    return routes;
-}
-/** Backward-compatible logical-id view used by the standalone OpenRouter trial command. */
-export function availablePiModels() {
-    return new Set(availablePiRoutes().map((route) => route.meritId));
-}
-/** Each invocation is a fresh pi run, so model B does not inherit model A's answer. */
-export async function executePiTask(model, task, cwd = process.cwd(), images = [], files = []) {
-    const route = typeof model === "string" ? legacyOpenRouterRoute(model) : model;
-    const imageDir = images.length ? mkdtempSync(join(tmpdir(), "openmerit-pi-image-")) : null;
-    const suffix = {
-        "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp", "image/gif": "gif",
-    };
-    const imageArgs = images.map((image, i) => {
-        if (!imageDir || !suffix[image.mimeType])
-            throw new Error(`unsupported pi image: ${image.mimeType}`);
-        const file = join(imageDir, `image-${i}.${suffix[image.mimeType]}`);
-        writeFileSync(file, Buffer.from(image.data, "base64"));
-        return `@${file}`;
-    });
-    const workspace = isolatedWorkspace(cwd);
-    try {
-        const attachmentDir = join(workspace, ".openmerit-attachments");
-        mkdirSync(attachmentDir, { recursive: true });
-        const attachmentPaths = new Map();
-        const fileArgs = files.map((file, i) => {
-            const safeName = `${String(i).padStart(3, "0")}-${file.name.replace(/[^A-Za-z0-9._-]/g, "_")}`;
-            const target = join(attachmentDir, safeName);
-            cpSync(file.path, target);
-            attachmentPaths.set(file.path, target);
-            return `@${target}`;
-        });
-        const candidateTask = [...attachmentPaths.entries()].reduce((text, [source, target]) => text.split(source).join(target), task);
-        const before = fileSnapshot(workspace);
-        const traceFile = paths.trialTrace(`${routeKey(route)}:${task}:${Date.now()}`);
-        const traceLines = [];
-        const child = spawn(piExecutable(), [
-            "--provider", route.provider, "--model", route.modelId, "--mode", "json",
-            "--offline", "--no-extensions", "--approve", ...piTrialToolArgs(),
-            "--print", ...imageArgs, ...fileArgs, candidateTask,
-        ], { cwd: workspace, stdio: ["ignore", "pipe", "pipe"] });
-        let buffer = "";
-        let stderr = "";
-        let answer = "";
-        let costUsd = 0;
-        let errors = 0;
-        let sessionId;
-        let toolCalls = 0;
-        let toolErrors = 0;
-        const started = Date.now();
-        function consume(line) {
-            if (!line.trim())
-                return;
-            traceLines.push(line);
-            let event;
-            try {
-                event = JSON.parse(line);
-            }
-            catch {
-                return;
-            }
-            if (event.type === "session" && event.id)
-                sessionId = event.id;
-            const content = event.message?.content;
-            if (event.message?.role === "assistant" && Array.isArray(content))
-                toolCalls += content.filter((part) => part?.type === "toolCall").length;
-            if (event.message?.role === "toolResult" && event.message.isError)
-                toolErrors++;
-            if (event.type !== "message_end" || event.message?.role !== "assistant")
-                return;
-            answer = answerText(event.message.content) || answer;
-            costUsd += event.message.usage?.cost?.total ?? 0;
-            if (event.message.stopReason === "error")
-                errors++;
-        }
-        child.stdout.on("data", (chunk) => {
-            buffer += chunk.toString("utf8");
-            let n;
-            while ((n = buffer.indexOf("\n")) >= 0) {
-                consume(buffer.slice(0, n));
-                buffer = buffer.slice(n + 1);
-            }
-        });
-        child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
-        const exitCode = await new Promise((resolve, reject) => {
-            child.on("error", reject);
-            child.on("close", (code) => resolve(code ?? 1));
-        });
-        consume(buffer);
-        mkdirSync(dirname(traceFile), { recursive: true });
-        writeFileSync(traceFile, traceLines.join("\n") + (traceLines.length ? "\n" : ""));
-        const after = fileSnapshot(workspace);
-        let changedFiles = 0;
-        for (const [file, hash] of after)
-            if (before.get(file) !== hash)
-                changedFiles++;
-        for (const file of before.keys())
-            if (!after.has(file))
-                changedFiles++;
-        if (exitCode !== 0 || !answer.trim()) {
-            throw new Error(`pi trial ${route.meritId} via ${route.provider} failed: ${stderr.trim().slice(0, 180) || `exit ${exitCode}, empty answer`}`);
-        }
-        return { answer, costUsd, latencyMs: Date.now() - started, errors, sessionId,
-            toolCalls, toolErrors, changedFiles, traceFile };
-    }
-    finally {
-        if (imageDir)
-            rmSync(imageDir, { recursive: true, force: true });
-        rmSync(workspace, { recursive: true, force: true });
-    }
-}
-/** Quality uses the same OpenMerit judge; cost and latency come from pi itself. */
-export async function runPiTrial(key, judgeModel, task, rubric, model, entry, cwd = process.cwd(), images = [], files = [], harness = defaultHarness, client = directChatClient(key)) {
-    try {
-        const run = await harness.runTask(entry?.route ?? model, { task, cwd, images, files });
-        return await scorePiRun(key, judgeModel, task, rubric, model, entry, run, "pi_trial", images, client);
-    }
-    catch (e) {
-        const error = String(e);
-        return {
-            point: { schemaVersion: 1, model, route: entry?.route, score: 0, price: entry?.price ?? 0,
-                priceKnown: entry?.priceKnown ?? !!entry,
-                ts: new Date().toISOString(), source: "pi_trial", toolCalls: 0, toolErrors: 1,
-                changedFiles: 0, why: error.slice(0, 160) },
-            costUsd: 0, error,
-        };
-    }
-}
-export async function scorePiRun(key, judgeModel, task, rubric, model, entry, run, source, images = [], client = directChatClient(key)) {
-    let score = 0;
-    let why = "judge unavailable";
-    try {
-        const pinned = images.length ? await knownInvoiceScore(task, images, run.answer) : null;
-        const j = pinned ?? (images.length
-            ? await judgeWithImages(key, judgeModel, task, rubric, run.answer, images, client)
-            : await judge(key, judgeModel, task, rubric, run.answer, client));
-        score = Math.max(0, Math.min(1, j.score));
-        why = j.why;
-    }
-    catch (e) {
-        why = `judge error: ${String(e).slice(0, 120)}`;
-    }
-    return {
-        point: {
-            schemaVersion: 1, model, route: entry?.route, score, price: entry?.price ?? 0,
-            priceKnown: entry?.priceKnown ?? !!entry,
-            latencyMs: run.latencyMs, ts: new Date().toISOString(), source,
-            why: `${why}${run.errors ? `; pi errors: ${run.errors}` : ""}; ` +
-                `tools=${run.toolCalls}, toolErrors=${run.toolErrors}, changedFiles=${run.changedFiles}`,
-            toolCalls: run.toolCalls, toolErrors: run.toolErrors, changedFiles: run.changedFiles,
-        },
-        costUsd: run.costUsd,
-        sessionId: run.sessionId,
-    };
-}

package/dist/policy.js

@@ -1,115 +0,0 @@
-/** Policy loading, validation, and the swap gate. */
-import { existsSync, readFileSync } from "node:fs";
-export const DEFAULT_POLICY = {
-    version: 1,
-    mode: "recommend",
-    auto_apply: {
-        enabled: false,
-        min_score_gain: 0.1,
-        max_price_ratio: 1.5,
-        require_frontier: true,
-    },
-    budgets: { max_usd_per_trial: 0.25, max_trials_per_day: 20, max_usd_per_day: 5.0 },
-    providers: { allow: ["*"], deny: [] },
-    watch: { catalog_interval_min: 360, traces_interval_sec: 5, trial_interval_min: 30, models_per_task: 3 },
-    fallback: { auto_update: true, min_score: 0.6, apply_on_error: true },
-    judge_model: null,
-    strategist_model: null,
-    max_usd_per_m: 20.0,
-};
-function num(v, fallback) {
-    return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
-/** Load a policy file, filling defaults for missing keys. Throws on invalid JSON. */
-export function loadPolicy(path) {
-    if (!existsSync(path))
-        return structuredClone(DEFAULT_POLICY);
-    const raw = JSON.parse(readFileSync(path, "utf8"));
-    const d = DEFAULT_POLICY;
-    return {
-        version: num(raw.version, d.version),
-        mode: raw.mode === "auto" ? "auto" : "recommend",
-        auto_apply: {
-            enabled: Boolean(raw.auto_apply?.enabled ?? d.auto_apply.enabled),
-            min_score_gain: num(raw.auto_apply?.min_score_gain, d.auto_apply.min_score_gain),
-            max_price_ratio: num(raw.auto_apply?.max_price_ratio, d.auto_apply.max_price_ratio),
-            require_frontier: Boolean(raw.auto_apply?.require_frontier ?? d.auto_apply.require_frontier),
-        },
-        budgets: {
-            max_usd_per_trial: num(raw.budgets?.max_usd_per_trial, d.budgets.max_usd_per_trial),
-            max_trials_per_day: num(raw.budgets?.max_trials_per_day, d.budgets.max_trials_per_day),
-            max_usd_per_day: num(raw.budgets?.max_usd_per_day, d.budgets.max_usd_per_day),
-        },
-        providers: {
-            allow: Array.isArray(raw.providers?.allow) ? raw.providers.allow.map(String) : d.providers.allow,
-            deny: Array.isArray(raw.providers?.deny) ? raw.providers.deny.map(String) : d.providers.deny,
-        },
-        watch: {
-            catalog_interval_min: num(raw.watch?.catalog_interval_min, d.watch.catalog_interval_min),
-            traces_interval_sec: num(raw.watch?.traces_interval_sec, d.watch.traces_interval_sec),
-            trial_interval_min: num(raw.watch?.trial_interval_min, d.watch.trial_interval_min),
-            models_per_task: num(raw.watch?.models_per_task, d.watch.models_per_task),
-        },
-        fallback: {
-            auto_update: Boolean(raw.fallback?.auto_update ?? d.fallback.auto_update),
-            min_score: num(raw.fallback?.min_score, d.fallback.min_score),
-            apply_on_error: Boolean(raw.fallback?.apply_on_error ?? d.fallback.apply_on_error),
-        },
-        judge_model: raw.judge_model ?? null,
-        strategist_model: raw.strategist_model ?? null,
-        max_usd_per_m: num(raw.max_usd_per_m, d.max_usd_per_m),
-    };
-}
-/** Match either a logical vendor/model id or its concrete route provider. */
-export function providerAllowed(policy, modelId, routeProvider) {
-    const vendor = modelId.split("/")[0];
-    const match = (pat) => pat === "*" || pat === modelId || pat === routeProvider ||
-        (pat.endsWith("/*") && (pat.slice(0, -2) === vendor || pat.slice(0, -2) === routeProvider));
-    if (policy.providers.deny.some(match))
-        return false;
-    return policy.providers.allow.some(match);
-}
-/**
- * The swap gate: decide whether a recommendation may be applied without
- * human approval. Always returns the reasons for the decision so the
- * recommendation can explain itself.
- */
-export function gate(policy, input) {
-    const reasons = [];
-    if (!input.providerOk) {
-        reasons.push("provider not allowed by policy");
-        return { autoApply: false, reasons };
-    }
-    if (input.baselineMeasured === false) {
-        reasons.push("current model has no measured baseline");
-        return { autoApply: false, reasons };
-    }
-    if (input.sessionBound === false) {
-        reasons.push("recommendation is not bound to a pi session");
-        return { autoApply: false, reasons };
-    }
-    if (input.priceKnown === false) {
-        reasons.push("candidate or current-model price is unknown");
-        return { autoApply: false, reasons };
-    }
-    if (policy.mode !== "auto" || !policy.auto_apply.enabled) {
-        reasons.push(`policy mode is "${policy.mode}" (auto_apply ${policy.auto_apply.enabled ? "enabled" : "disabled"})`);
-        return { autoApply: false, reasons };
-    }
-    let ok = true;
-    if (input.scoreGain < policy.auto_apply.min_score_gain) {
-        reasons.push(`score gain ${input.scoreGain.toFixed(3)} < min ${policy.auto_apply.min_score_gain}`);
-        ok = false;
-    }
-    if (input.priceRatio > policy.auto_apply.max_price_ratio) {
-        reasons.push(`price ratio ${input.priceRatio.toFixed(2)}x > max ${policy.auto_apply.max_price_ratio}x`);
-        ok = false;
-    }
-    if (policy.auto_apply.require_frontier && !input.onFrontier) {
-        reasons.push("candidate is not on the pareto frontier");
-        ok = false;
-    }
-    if (ok)
-        reasons.unshift("all auto-apply thresholds met");
-    return { autoApply: ok, reasons };
-}

package/dist/providers.js

@@ -1 +0,0 @@
-export {};

package/dist/recommend.js

@@ -1,76 +0,0 @@
-/** Build policy-gated recommendations from a task's frontier + the harness's current model. */
-import { createHash } from "node:crypto";
-import { paretoFrontier, pickBest, pickFallback } from "./frontier.js";
-import { gate, providerAllowed } from "./policy.js";
-import { pointKey, routeLabel } from "./routes.js";
-export function buildRecommendation(taskKey, taskLabel, currentModel, points, policy, sessionFile = null, currentRoute = currentModel ? points.find((p) => p.model === currentModel)?.route ?? null : null) {
-    const scored = points.filter((p) => p.score > 0);
-    if (scored.length === 0)
-        return null;
-    const best = pickBest(scored);
-    if (!best)
-        return null;
-    if (currentModel && best.model === currentModel &&
-        (!currentRoute || pointKey(best) === `${currentRoute.provider}:${currentRoute.modelId}`))
-        return null;
-    const current = currentModel ? scored.find((p) => currentRoute
-        ? pointKey(p) === `${currentRoute.provider}:${currentRoute.modelId}`
-        : p.model === currentModel) : undefined;
-    const scoreGain = current ? best.score - current.score : 0;
-    // pickBest may choose a cheaper or faster model at equal quality.
-    if (current && scoreGain < 0)
-        return null;
-    const priceKnown = best.priceKnown !== false && (!current || current.priceKnown !== false);
-    const priceRatio = priceKnown && current && current.price > 0 ? best.price / current.price : 1;
-    const frontierModels = paretoFrontier(scored).map(pointKey);
-    const onFrontier = frontierModels.includes(pointKey(best));
-    const fb = pickFallback(scored, best, policy.fallback.min_score);
-    const decision = gate(policy, {
-        scoreGain,
-        priceRatio,
-        priceKnown,
-        onFrontier,
-        providerOk: providerAllowed(policy, best.model, best.route?.provider),
-        baselineMeasured: !!current,
-        sessionBound: !!sessionFile,
-    });
-    const bestLabel = best.route ? routeLabel(best.route) : best.model;
-    const reason = `${bestLabel} scores ${best.score.toFixed(2)} vs ` +
-        (current ? `${current.score.toFixed(2)} for ${current.model}` : "no baseline measured") +
-        ` (${scoreGain > 0 ? `quality gain ${scoreGain.toFixed(2)}` : "equal measured quality"}), ` +
-        (best.priceKnown === false ? "with unknown price" : `at $${best.price.toFixed(2)}/M`) +
-        (current && priceKnown ? ` (${priceRatio.toFixed(2)}x current price)` : "") +
-        (best.why ? `. Judge: ${best.why}` : "");
-    return {
-        schemaVersion: 1,
-        id: createHash("sha1")
-            .update(`${taskKey}:${pointKey(best)}:${Date.now()}`)
-            .digest("hex")
-            .slice(0, 10),
-        ts: new Date().toISOString(),
-        taskKey,
-        taskLabel,
-        sessionFile,
-        currentModel,
-        currentRoute,
-        recommended: { model: best.model, route: best.route, reason },
-        fallback: fb
-            ? {
-                model: fb.model,
-                route: fb.route,
-                reason: `score ${fb.score.toFixed(2)} ` +
-                    (fb.priceKnown === false ? "with unknown price" : `at $${fb.price.toFixed(2)}/M`) +
-                    (fb.latencyMs ? `, ~${Math.round(fb.latencyMs)}ms` : ""),
-            }
-            : null,
-        evidence: {
-            scoreGain: Math.round(scoreGain * 1000) / 1000,
-            priceRatio: Math.round(priceRatio * 100) / 100,
-            priceKnown,
-            onFrontier,
-            trials: scored.length,
-        },
-        policy: decision,
-        status: "pending",
-    };
-}

package/dist/routes.js

@@ -1,59 +0,0 @@
-/** Provider-neutral model-route normalization. */
-export function meritModelId(provider, modelId) {
-    if (provider === "openrouter")
-        return modelId;
-    return modelId.startsWith(`${provider}/`) ? modelId : `${provider}/${modelId}`;
-}
-export function modelRoute(provider, modelId, details = {}) {
-    return {
-        provider,
-        modelId,
-        meritId: meritModelId(provider, modelId),
-        input: details.input ?? ["text"],
-        ...details,
-    };
-}
-export function legacyOpenRouterRoute(meritId) {
-    return modelRoute("openrouter", meritId);
-}
-export function routeKey(route) {
-    return `${route.provider}:${route.modelId}`;
-}
-export function pointKey(point) {
-    return point.route ? routeKey(point.route) : `openrouter:${point.model}`;
-}
-export function routeLabel(route) {
-    return route.provider === "openrouter" ? route.meritId : `${route.meritId} via ${route.provider}`;
-}
-export function routePrice(route) {
-    if (!route.cost || !Number.isFinite(route.cost.input) || !Number.isFinite(route.cost.output))
-        return { price: 0, known: false };
-    return { price: Math.round(((route.cost.input + route.cost.output) / 2 + Number.EPSILON) * 1e4) / 1e4,
-        known: true };
-}
-export function catalogEntryFromRoute(route) {
-    const priced = routePrice(route);
-    return {
-        id: route.meritId,
-        name: routeLabel(route),
-        ctx: route.contextWindow ?? 0,
-        pp: route.cost ? route.cost.input / 1e6 : 0,
-        pc: route.cost ? route.cost.output / 1e6 : 0,
-        price: priced.price,
-        priceKnown: priced.known,
-        inputModalities: route.input,
-        route,
-    };
-}
-export function routeCatalog(routes) {
-    const out = new Map();
-    for (const route of routes)
-        out.set(routeKey(route), catalogEntryFromRoute(route));
-    return out;
-}
-/** Preserve the route while enriching an OpenRouter entry with its live catalog metadata. */
-export function enrichRouteEntry(entry, live) {
-    if (!live)
-        return entry;
-    return { ...live, route: entry.route, id: entry.id, name: entry.name, priceKnown: true };
-}