openmerit 0.1.2 → 0.1.3

package/README.md

@@ -54,13 +54,14 @@ package into pi, then initialize its policy and state:
 ```bash
 pi install npm:openmerit
 npx --yes openmerit init
+npx --yes openmerit verify
 pi list
 ```
 
 `pi install` makes the extension and its trial engine available to pi. The
 one-off `npx` command creates `~/.openmerit/policy.json`; install OpenMerit
 globally with `npm install --global openmerit` only if you also want persistent
-shell access to `openmerit status`, `doctor`, `frontier`, or the optional watcher. Install
+shell access to `openmerit status`, `doctor`, `verify`, `frontier`, or the optional watcher. Install
 the extension from only one source—remove any older copied `openmerit.ts` first
 so pi does not load it twice.
 
@@ -120,8 +121,9 @@ Keep that checkout available because pi loads a local package from its path.
 3. Verify the extension appears in `pi list`. The instruction file
    [`instructions/OPENMERIT.md`](instructions/OPENMERIT.md) can be added to a
    pi project's AGENTS.md for agent context, but the extension does
-   not require it. Run `npx openmerit doctor` after starting Pi once to inspect
-   the eligible route snapshot and configuration without printing secrets.
+   not require it. Run `npx openmerit verify` for a provider-free core self-test,
+   then `npx openmerit doctor` after starting Pi once to inspect the eligible
+   route snapshot and configuration without printing secrets.
 
 4. Start pi in one terminal with any configured model. For example:
 
@@ -179,8 +181,13 @@ schema, so its published scores are not directly comparable to these pi runs.
 
 ### Inspect or troubleshoot a run
 
-`npx openmerit doctor` checks Pi, policy, eligible routes, and optional
-OpenRouter enrichment. `npx openmerit status` shows the latest pi model and pending recommendations;
+`npx openmerit doctor` checks Pi, policy, eligible routes and prices, saved
+session state, duplicate package sources, append-only files, and optional
+OpenRouter enrichment. Add `--json` for a sanitized diagnostic report suitable
+for a bug report; it contains no credentials, prompts, or trace contents.
+`npx openmerit verify` runs an offline self-test of atomic state, JSONL recovery,
+route preservation, policy evidence, and neutral events without contacting a
+provider. `npx openmerit status` shows the latest pi model and pending recommendations;
 `npx openmerit frontier` shows measured quality, blended price, latency, and
 the chosen frontier per task. `/openmerit` inside pi shows the current model,
 fallback, the model currently being compared, completed models with quality,
@@ -203,10 +210,21 @@ Closing or switching the session cancels the active job.
 Candidate runs use the same text and uploaded image bytes, but they do not
 replay earlier answers or file changes. An exact task in another session
 (including identical image bytes) appears as **advice**, not a pending swap;
-the new session still gets its own comparison. The optional `trial` command
-remains for controlled text-task runs from a task JSON file; that legacy
-standalone command is still OpenRouter-specific in 0.1.2. The automatic Pi
-session path is provider-neutral.
+the new session still gets its own comparison.
+
+The optional `trial` command runs controlled text-task comparisons through the
+same exact Pi provider routes and credential store as the automatic session
+path:
+
+```bash
+npx openmerit trial examples/task.example.json --rounds 3
+```
+
+`initial_model` is the stable `vendor/model` identity. When Pi exposes that
+model through more than one provider, set `initial_route` to
+`provider:model-id` (for example `openai:gpt-4o-mini` or
+`openrouter:openai/gpt-4o-mini`). Judge and strategist calls also run through
+Pi. An OpenRouter key only adds optional catalog and public-benchmark metadata.
 
 ## Alpha boundaries
 
@@ -251,6 +269,10 @@ session path is provider-neutral.
   configuration). A provider registered only at runtime by another extension
   is visible in the route snapshot but cannot yet be executed by the isolated
   subprocess.
+- JSON state snapshots are replaced atomically. Append-only readers skip and
+  report malformed or interrupted lines while retaining later valid records.
+  A job owned by a crashed process is reclaimable instead of remaining stuck
+  in `running`; completed jobs remain final.
 
 ## State layout (`~/.openmerit/`)
 

package/dist/cli.js

@@ -1,36 +1,18 @@
 #!/usr/bin/env node
-/** openmerit CLI: init / watch / trial / frontier / recommend / status / doctor. */
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+/** openmerit CLI: init / watch / trial / frontier / recommend / status / doctor / verify. */
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadPolicy } from "./policy.js";
 import { loadKey } from "./llm.js";
-import { fetchCatalog } from "./catalog.js";
 import { paretoFrontier, pickBest, pickFallback } from "./frontier.js";
-import { buildRecommendation } from "./recommend.js";
-import { appendJsonl, paths, readJson, readJsonl, taskKey } from "./store.js";
+import { paths, readJson, readJsonl } from "./store.js";
 import { autoTaskTick, recommendTick, runDaemon, tickOnce } from "./daemon.js";
-import { budgetOk, recordTrialSpend } from "./trials.js";
-import { availablePiModels, availablePiRoutes, piExecutable, recordedActiveTask, runPiTrial, scorePiRun, settledActiveTask } from "./pi-trials.js";
-import { pickNext, STRAT_PREFS } from "./strategist.js";
-import { JUDGE_PREFS } from "./judge.js";
-import { openRouterBenchmarkCandidates, relevantBenchmarks } from "./benchmarks.js";
+import { settledActiveTask } from "./pi-trials.js";
 import { modelRoute, routeLabel } from "./routes.js";
-import { spawnSync } from "node:child_process";
+import { runStandaloneTrial } from "./standalone.js";
+import { collectDoctorReport, renderDiagnosticReport, runOfflineVerify } from "./diagnostics.js";
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
-function resolvePref(cat, prefs, label) {
-    for (const p of prefs)
-        if (p && cat.has(p))
-            return p;
-    for (const p of prefs) {
-        if (!p)
-            continue;
-        for (const id of [...cat.keys()].sort())
-            if (id.includes(p))
-                return id;
-    }
-    throw new Error(`could not resolve ${label} model`);
-}
 function cmdInit() {
     const policyPath = paths.policy();
     mkdirSync(dirname(policyPath), { recursive: true });
@@ -55,129 +37,16 @@ function optionalOpenRouterKey() {
         return null;
     }
 }
-function cmdDoctor() {
-    const executable = piExecutable();
-    const version = spawnSync(executable, ["--version"], { encoding: "utf8" });
-    const state = readJson(paths.harnessState(), {});
-    console.log(`pi executable : ${executable}`);
-    console.log(`pi detected   : ${version.status === 0 ? `yes (${version.stdout.trim()})` : "no"}`);
-    try {
-        const policy = loadPolicy(paths.policy());
-        console.log(`policy        : valid (v${policy.version}, ${policy.mode})`);
-    }
-    catch (error) {
-        console.log(`policy        : invalid (${error.message})`);
-    }
-    let routes = state.routes ?? [];
-    const hasLiveSnapshot = routes.length > 0;
-    if (routes.length === 0 && version.status === 0) {
-        try {
-            routes = availablePiRoutes();
-        }
-        catch { /* reported below */ }
-    }
-    console.log(`eligible routes: ${routes.length}`);
-    for (const route of routes.slice(0, 8))
-        console.log(`  - ${routeLabel(route)}${route.cost ? "" : " (price unknown)"}`);
-    if (routes.length > 8)
-        console.log(`  … ${routes.length - 8} more`);
-    console.log(`active route  : ${state.currentRoute ? routeLabel(state.currentRoute) : "not reported; start pi once"}`);
-    const pricedRoutes = routes.filter((route) => !!route.cost).length;
-    console.log(`alternates    : ${hasLiveSnapshot
-        ? pricedRoutes >= 2 ? "ready" : "need at least two priced eligible pi routes"
-        : "start Pi once to capture route prices and capabilities"}`);
-    console.log(`OpenRouter enrichment: ${optionalOpenRouterKey() ? "available" : "not configured (optional)"}`);
+function printReport(report, json) {
+    console.log(json ? JSON.stringify(report, null, 2) : renderDiagnosticReport(report));
+    if (!report.ok)
+        process.exitCode = 1;
 }
-async function cmdTrial(taskFile, rounds) {
-    const cfg = JSON.parse(readFileSync(taskFile, "utf8"));
-    const policy = loadPolicy(paths.policy());
-    const key = loadKey();
-    console.log("fetching OpenRouter catalog...");
-    const cat = await fetchCatalog(key);
-    const piModels = availablePiModels();
-    for (const id of [...cat.keys()])
-        if (!piModels.has(id))
-            cat.delete(id);
-    if (!cat.has(cfg.initial_model))
-        throw new Error(`initial_model ${cfg.initial_model} is unavailable in pi's OpenRouter registry`);
-    console.log(`catalog: ${cat.size} models selectable in pi`);
-    const judge = resolvePref(cat, [cfg.judge_model ?? policy.judge_model, ...JUDGE_PREFS], "judge");
-    const strat = resolvePref(cat, [cfg.strategist_model ?? policy.strategist_model, ...STRAT_PREFS], "strategist");
-    const { category, benchmarks } = relevantBenchmarks(cfg.task);
-    let benchmarkCandidates = [];
-    try {
-        benchmarkCandidates = await openRouterBenchmarkCandidates(key, category, cat);
-    }
-    catch (e) {
-        console.log(`OpenRouter benchmark shortlist unavailable: ${e.message}`);
-    }
-    console.log(`judge: ${judge} | strategist: ${strat} | benchmarks: ${benchmarks.join(", ")}`);
-    console.log(`OpenRouter benchmark candidates: ${benchmarkCandidates.slice(0, 5).join(", ") || "none"}`);
-    const tKey = taskKey(cfg.task);
-    const maxPrice = cfg.max_usd_per_m ?? policy.max_usd_per_m;
-    const tried = new Set();
-    const results = [];
-    const failedVendors = new Set();
-    for (let i = 0; i < rounds; i++) {
-        const budget = budgetOk(policy);
-        if (!budget.ok) {
-            console.log(`budget: ${budget.reason}; stopping`);
-            break;
-        }
-        let model;
-        let why;
-        if (i === 0) {
-            model = cfg.initial_model;
-            why = "initial model";
-        }
-        else {
-            const pick = await pickNext(key, strat, cfg.task, cfg.eval, benchmarks, results, cat, tried, maxPrice, failedVendors, benchmarkCandidates);
-            if (!pick)
-                break;
-            model = pick.model;
-            why = pick.why;
-        }
-        if (tried.has(model))
-            break;
-        console.log(`[round ${i + 1}/${rounds}] ${model} (${why}) ...`);
-        const observed = i === 0 ? recordedActiveTask(cfg.task, model) : null;
-        if (i === 0)
-            console.log(observed ? "    using model A's active pi session trace" : "    active trace unavailable; running model A in a fresh pi session");
-        const { point, costUsd, error, sessionId } = observed
-            ? await scorePiRun(key, judge, cfg.task, cfg.eval, model, cat.get(model), observed, "trace")
-            : await runPiTrial(key, judge, cfg.task, cfg.eval, model, cat.get(model));
-        tried.add(model);
-        results.push(point);
-        recordTrialSpend(costUsd);
-        appendJsonl(paths.trials(), { ...point, taskKey: tKey });
-        if (sessionId)
-            console.log(`    pi trace session: ${sessionId}`);
-        if (error) {
-            failedVendors.add(model.split("/")[0]);
-            console.log(`    FAILED: ${error.slice(0, 160)}`);
-        }
-        else {
-            console.log(`    score=${point.score.toFixed(2)}  $/M=${point.price}  est_cost=$${costUsd.toFixed(4)}  ${(point.why ?? "").slice(0, 110)}`);
-        }
-    }
-    const pts = results.filter((p) => p.score > 0);
-    if (pts.length === 0) {
-        console.log("no trials completed");
-        process.exit(1);
-    }
-    const chain = paretoFrontier(pts);
-    const best = pickBest(pts);
-    const fb = pickFallback(pts, best, policy.fallback.min_score);
-    console.log("\n=== pareto frontier (nondominated: score up, price down, latency down) ===");
-    for (const p of chain)
-        console.log(`  ${p.model.padEnd(44)} score=${p.score.toFixed(2)}  $${p.price.toFixed(2)}/M`);
-    console.log(`\nBEST FIT : ${best.model}  (score ${best.score.toFixed(2)}, $${best.price.toFixed(2)}/M)`);
-    console.log(fb ? `FALLBACK : ${fb.model}  (score ${fb.score.toFixed(2)}, $${fb.price.toFixed(2)}/M)` : "FALLBACK : n/a");
-    const rec = buildRecommendation(tKey, cfg.task.slice(0, 120), cfg.initial_model, pts, policy);
-    if (rec) {
-        appendJsonl(paths.recommendations(), rec);
-        console.log(`\nrecommendation -> ${paths.recommendations()} (auto=${rec.policy.autoApply})`);
-    }
+function cmdDoctor(json) {
+    printReport(collectDoctorReport(), json);
+}
+function cmdVerify(json) {
+    printReport(runOfflineVerify(), json);
 }
 function loadFrontiers() {
     const trials = readJsonl(paths.trials());
@@ -243,12 +112,12 @@ function cmdStatus() {
 }
 async function main() {
     const [cmd, ...args] = process.argv.slice(2);
-    const policy = loadPolicy(paths.policy());
     switch (cmd) {
         case "init":
             cmdInit();
             break;
         case "session-trial": {
+            const policy = loadPolicy(paths.policy());
             const [sessionFile, settledAt, currentModel, settledTaskKey, cwd, bytesText, provider, providerModelId] = args;
             if (!sessionFile || !settledAt || !currentModel || !settledTaskKey || !cwd || !bytesText)
                 throw new Error("usage: openmerit session-trial <session-file> <settled-at> <model> <task-key> <cwd> <session-bytes>");
@@ -269,29 +138,32 @@ async function main() {
         }
         case "watch":
             if (args.includes("--once"))
-                await tickOnce(policy);
+                await tickOnce(loadPolicy(paths.policy()));
             else
-                await runDaemon(policy);
+                await runDaemon(loadPolicy(paths.policy()));
             break;
         case "trial": {
             const file = args[0];
             if (!file)
                 throw new Error("usage: openmerit trial <task.json> [--rounds N]");
             const rIdx = args.indexOf("--rounds");
-            await cmdTrial(file, rIdx >= 0 ? Number(args[rIdx + 1]) : 5);
+            await runStandaloneTrial(file, rIdx >= 0 ? Number(args[rIdx + 1]) : 5);
             break;
         }
         case "frontier":
             cmdFrontier(args[0]);
             break;
         case "recommend":
-            recommendTick(policy);
+            recommendTick(loadPolicy(paths.policy()));
             break;
         case "status":
             cmdStatus();
             break;
         case "doctor":
-            cmdDoctor();
+            cmdDoctor(args.includes("--json"));
+            break;
+        case "verify":
+            cmdVerify(args.includes("--json"));
             break;
         default:
             console.log(`openmerit — external model-merit harness
@@ -304,7 +176,8 @@ usage: openmerit <command>
   frontier [taskKey]   print pareto frontier(s)
   recommend            emit recommendations now
   status               harness model, queued models, pending recommendations
-  doctor               verify pi, policy, routes, and optional enrichment`);
+  doctor [--json]      diagnose pi, policy, routes, state, and installation
+  verify [--json]      run an offline, provider-free core self-test`);
             if (cmd && cmd !== "help" && cmd !== "--help")
                 process.exitCode = 1;
     }

package/dist/daemon.js

@@ -42,6 +42,28 @@ function resolveRoutePref(cat, prefs, label, requireImages = false) {
         return fallback;
     throw new Error(`could not resolve ${label} route from Pi's eligible models`);
 }
+function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Completed jobs stay final; live owners retain their claim; abandoned claims can retry. */
+export function taskJobIsClaimed(prior, marker, now = Date.now()) {
+    if (!prior || prior.marker !== marker || prior.status === "failed")
+        return false;
+    if (prior.status !== "running")
+        return true;
+    if (prior.ownerPid !== undefined)
+        return processIsAlive(prior.ownerPid);
+    const updated = Date.parse(prior.updatedAt);
+    return Number.isFinite(updated) && now - updated < 15 * 60_000;
+}
 function emitTrialProgress(progress) {
     console.log(`[openmerit/progress] ${JSON.stringify(progress)}`);
 }
@@ -158,12 +180,13 @@ export async function autoTaskTick(key, policy, settledTask) {
         : `${task.sessionFile}:${task.sessionBytes ?? task.settledAt}`;
     const processedPath = settledTask === undefined ? paths.watchProcessed() : paths.sessionJob(marker);
     const prior = readJson(processedPath, null);
-    if (prior?.marker === marker && prior.status !== "failed")
+    if (taskJobIsClaimed(prior, marker))
         return null;
     if (!budgetOk(policy).ok)
         return null;
     // Claim the settled turn before provider calls so the next poll cannot duplicate it.
-    writeJson(processedPath, { marker, status: "running", updatedAt: new Date().toISOString() });
+    writeJson(processedPath, { marker, status: "running", ownerPid: process.pid,
+        updatedAt: new Date().toISOString() });
     try {
         let cat = routeCatalog(task.routes);
         if (!cat.has(routeKey(task.route)))
@@ -258,12 +281,12 @@ export async function autoTaskTick(key, policy, settledTask) {
         else
             console.log(`[openmerit] task ${tKey}: active model remains best`);
         writeJson(processedPath, { marker, status: rec ? "complete" : "no_swap",
-            updatedAt: new Date().toISOString() });
+            ownerPid: process.pid, updatedAt: new Date().toISOString() });
         return rec;
     }
     catch (error) {
         writeJson(processedPath, { marker, status: "failed",
-            updatedAt: new Date().toISOString() });
+            ownerPid: process.pid, updatedAt: new Date().toISOString() });
         throw error;
     }
 }

package/dist/diagnostics.js

@@ -0,0 +1,194 @@
+/** Read-only diagnostics plus a provider-free self-test for first-run support. */
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { LocalJsonlEventSink, meritEvent } from "./integrations.js";
+import { piExecutable, availablePiRoutes } from "./pi-trials.js";
+import { DEFAULT_POLICY, loadPolicy, providerAllowed } from "./policy.js";
+import { buildRecommendation } from "./recommend.js";
+import { modelRoute, routeCatalog, routeKey, routeLabel } from "./routes.js";
+import { appendJsonl, paths, readJsonReport, readJsonlReport, writeJson, } from "./store.js";
+function check(id, status, message, details) {
+    return { id, status, message, ...(details?.length ? { details } : {}) };
+}
+function packageSources(output) {
+    return [...new Set(output.split("\n").filter((line) => /^ {2}\S/.test(line)).map((line) => line.trim())
+            .filter((line) => /openmerit/i.test(line) && /^(npm:|git:|https?:|\.?\.?\/|\/)/.test(line)))];
+}
+function safePackageSource(source) {
+    if (source.startsWith("npm:/"))
+        return `npm:local/${basename(source)}`;
+    if (source.startsWith("/"))
+        return `local:${basename(source)}`;
+    return source;
+}
+/** No credentials, prompts, or trace contents are included in this report. */
+export function collectDoctorReport() {
+    const checks = [];
+    const executable = piExecutable();
+    const versionResult = spawnSync(executable, ["--version"], { encoding: "utf8" });
+    const piVersion = versionResult.status === 0 ? versionResult.stdout.trim() : null;
+    checks.push(piVersion
+        ? check("pi", "pass", `Pi detected (${piVersion})`)
+        : check("pi", "fail", "Pi is not executable"));
+    try {
+        const policy = loadPolicy(paths.policy());
+        checks.push(check("policy", "pass", `Policy is valid (v${policy.version}, ${policy.mode})`));
+    }
+    catch (error) {
+        checks.push(check("policy", "fail", `Policy is invalid: ${error.message}`));
+    }
+    const stateRead = readJsonReport(paths.harnessState(), {});
+    checks.push(!stateRead.valid
+        ? check("harness-state", "fail", "harness-state.json is malformed; start Pi to replace it atomically")
+        : stateRead.exists
+            ? check("harness-state", "pass", "Pi extension state snapshot is readable")
+            : check("harness-state", "warn", "No Pi extension state yet; start Pi once with OpenMerit installed"));
+    let routes = stateRead.value.routes ?? [];
+    const liveSnapshot = routes.length > 0;
+    if (!routes.length && piVersion) {
+        try {
+            routes = availablePiRoutes();
+        }
+        catch { /* the check below explains it */ }
+    }
+    let policy = DEFAULT_POLICY;
+    try {
+        policy = loadPolicy(paths.policy());
+    }
+    catch { /* already reported */ }
+    routes = routes.filter((route) => providerAllowed(policy, route.meritId, route.provider));
+    const priced = routes.filter((route) => !!route.cost);
+    checks.push(routes.length >= 2
+        ? check("routes", "pass", `${routes.length} Pi model routes are visible`, routes.slice(0, 8).map((route) => `${routeLabel(route)}${route.cost ? "" : " (price unknown)"}`))
+        : check("routes", "fail", `Only ${routes.length} policy-eligible Pi route${routes.length === 1 ? " is" : "s are"} visible; at least two are required`));
+    checks.push(liveSnapshot
+        ? priced.length >= 2
+            ? check("pricing", "pass", `${priced.length} eligible routes expose pricing`)
+            : check("pricing", "warn", "Fewer than two eligible routes expose pricing; unknown-price routes cannot auto-apply")
+        : check("pricing", "warn", "Route prices are unavailable until the extension reports a live Pi snapshot"));
+    const session = stateRead.value.sessionFile;
+    checks.push(!session
+        ? check("session", "warn", "No active saved Pi session is reported yet")
+        : existsSync(session)
+            ? check("session", "pass", "The reported Pi session file is readable")
+            : check("session", "warn", "The reported Pi session file no longer exists"));
+    if (piVersion) {
+        const listed = spawnSync(executable, ["list"], { encoding: "utf8" });
+        const sources = listed.status === 0 ? packageSources(listed.stdout) : [];
+        const safeSources = sources.map(safePackageSource);
+        checks.push(sources.length > 1
+            ? check("installation", "fail", "OpenMerit is installed from multiple Pi package sources", safeSources)
+            : sources.length === 1
+                ? check("installation", "pass", `One Pi package source is installed`, safeSources)
+                : check("installation", "warn", "OpenMerit is not listed as an installed Pi package; use `pi install npm:openmerit`"));
+    }
+    const jsonlFiles = [
+        ["recommendations.jsonl", paths.recommendations()],
+        ["trials.jsonl", paths.trials()],
+        ["traces/observations.jsonl", paths.observations()],
+        ["events.jsonl", paths.events()],
+    ];
+    const malformed = jsonlFiles.flatMap(([label, file]) => {
+        const invalid = readJsonlReport(file).invalidLines;
+        return invalid.length ? [`${label}: lines ${invalid.join(", ")}`] : [];
+    });
+    checks.push(malformed.length
+        ? check("jsonl", "warn", "Malformed JSONL lines were skipped; valid later records remain readable", malformed)
+        : check("jsonl", "pass", "Append-only JSONL state is readable"));
+    const ledger = readJsonReport(paths.ledger(), { date: "", trials: 0, usd: 0 });
+    checks.push(ledger.valid
+        ? check("ledger", "pass", "Trial-spend ledger is readable")
+        : check("ledger", "fail", "Trial-spend ledger is malformed; spending remains disabled until repaired"));
+    let openRouter = false;
+    try {
+        const env = process.env.OPENROUTER_API_KEY;
+        if (env?.trim())
+            openRouter = true;
+        else if (existsSync(paths.envFile()))
+            openRouter = /^\s*OPENROUTER_API_KEY\s*=\s*\S+/m
+                .test(readFileSync(paths.envFile(), "utf8"));
+    }
+    catch { /* optional */ }
+    checks.push(check("openrouter-enrichment", "pass", openRouter ? "Optional OpenRouter enrichment is configured" : "Optional OpenRouter enrichment is not configured"));
+    const activeRoute = stateRead.value.currentRoute ? routeLabel(stateRead.value.currentRoute) : null;
+    return {
+        schemaVersion: 1,
+        ok: !checks.some((item) => item.status === "fail"),
+        checks,
+        summary: { piVersion, routeCount: routes.length, pricedRouteCount: priced.length, activeRoute },
+    };
+}
+export function renderDiagnosticReport(report) {
+    const icon = { pass: "PASS", warn: "WARN", fail: "FAIL" };
+    return report.checks.flatMap((item) => [
+        `${icon[item.status].padEnd(4)} ${item.id.padEnd(22)} ${item.message}`,
+        ...(item.details ?? []).map((detail) => `       - ${detail}`),
+    ]).join("\n");
+}
+/** Exercise core state, routing, recommendation, and event paths without provider calls. */
+export function runOfflineVerify() {
+    const previousHome = process.env.OPENMERIT_HOME;
+    const root = mkdtempSync(join(tmpdir(), "openmerit-verify-"));
+    const checks = [];
+    try {
+        process.env.OPENMERIT_HOME = root;
+        const active = modelRoute("native", "model-a", {
+            input: ["text"], cost: { input: 1, output: 2 }, contextWindow: 8192, maxTokens: 4096,
+        });
+        const candidate = modelRoute("local", "model-b", {
+            input: ["text"], cost: { input: 0.2, output: 0.4 }, contextWindow: 8192, maxTokens: 4096,
+        });
+        writeJson(paths.harnessState(), { schemaVersion: 1, currentRoute: active, routes: [active, candidate] });
+        const state = readJsonReport(paths.harnessState(), {});
+        checks.push(state.valid && state.value.routes?.length === 2
+            ? check("atomic-json", "pass", "Atomic JSON state round-trip passed")
+            : check("atomic-json", "fail", "Atomic JSON state round-trip failed"));
+        const entries = routeCatalog([active, candidate]);
+        const point = (route, score) => {
+            const entry = entries.get(routeKey(route));
+            return { schemaVersion: 1, model: route.meritId, route, score, price: entry.price,
+                priceKnown: entry.priceKnown, ts: new Date().toISOString(), source: "pi_trial" };
+        };
+        const recommendation = buildRecommendation("verify-task", "offline verification", active.meritId, [point(active, 0.6), point(candidate, 0.9)], DEFAULT_POLICY, "/verify/session.jsonl", active);
+        checks.push(recommendation?.recommended.route?.provider === "local" &&
+            recommendation.policy.reasons.length > 0
+            ? check("provider-neutral", "pass", "Exact provider routes and policy reasons survive recommendation")
+            : check("provider-neutral", "fail", "Provider route or policy evidence was lost"));
+        if (recommendation)
+            appendJsonl(paths.recommendations(), recommendation);
+        appendJsonl(paths.recommendations(), { schemaVersion: 0, id: "legacy", status: "dismissed" });
+        appendFileSync(paths.recommendations(), "{interrupted");
+        const history = readJsonlReport(paths.recommendations());
+        checks.push(history.records.length === 2 && history.invalidLines.length === 1
+            ? check("jsonl-recovery", "pass", "Valid records survive legacy and interrupted JSONL lines")
+            : check("jsonl-recovery", "fail", "JSONL recovery did not preserve valid history"));
+        const sink = new LocalJsonlEventSink();
+        if (recommendation)
+            sink.emit(meritEvent("recommendation.created", recommendation));
+        const events = readJsonlReport(paths.events());
+        checks.push(events.records.length === 1
+            ? check("events", "pass", "Versioned neutral event sink round-trip passed")
+            : check("events", "fail", "Neutral event sink round-trip failed"));
+        checks.push(loadPolicy(paths.policy()).mode === "recommend"
+            ? check("compatibility", "pass", "Missing 0.1.x policy fields normalize to safe defaults")
+            : check("compatibility", "fail", "Policy defaults are unsafe"));
+    }
+    catch (error) {
+        checks.push(check("verify", "fail", error.message));
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env.OPENMERIT_HOME;
+        else
+            process.env.OPENMERIT_HOME = previousHome;
+        rmSync(root, { recursive: true, force: true });
+    }
+    return {
+        schemaVersion: 1,
+        ok: !checks.some((item) => item.status === "fail"),
+        checks,
+        summary: { piVersion: null, routeCount: 2, pricedRouteCount: 2, activeRoute: "native/model-a via native" },
+    };
+}

package/dist/pi-trials.js

@@ -113,7 +113,9 @@ export function recordedActiveTask(task, model, images = [], sessionFile, sessio
     if (!user || !userImages || taskInputKey(answerText(user.content), userImages, sessionFiles(answerText(user.content))) !==
         taskInputKey(task, images, files))
         return null;
-    const matching = assistants.filter((m) => meritModelId(m.provider ?? "openrouter", m.model ?? "") === model);
+    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) ?? "";
@@ -170,10 +172,10 @@ export function settledActiveTask(snapshot) {
     const files = sessionFiles(task);
     if (!task.trim() || taskInputKey(task, images, files) !== st.settledTaskKey)
         return null;
-    const run = recordedActiveTask(task, st.currentModel, images, st.sessionFile, st.sessionBytes);
+    const route = st.currentRoute ?? legacyOpenRouterRoute(st.currentModel);
+    const run = recordedActiveTask(task, route, images, st.sessionFile, st.sessionBytes);
     if (!run)
         return null;
-    const route = st.currentRoute ?? legacyOpenRouterRoute(st.currentModel);
     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,
@@ -182,6 +184,13 @@ export function settledActiveTask(snapshot) {
 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)
@@ -191,10 +200,14 @@ export function availablePiRoutes(snapshot) {
         throw new Error("could not list models from pi");
     const routes = [];
     for (const line of result.stdout.split("\n").slice(1)) {
-        const [provider, id, , , , images] = line.trim().split(/\s+/);
+        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"] }));
+        routes.push(modelRoute(provider, id, {
+            input: images === "yes" ? ["text", "image"] : ["text"],
+            contextWindow: compactNumber(context),
+            maxTokens: compactNumber(maxOut),
+        }));
     }
     return routes;
 }

package/dist/standalone.js

@@ -0,0 +1,220 @@
+/** Provider-neutral standalone task trials executed through Pi routes. */
+import { readFileSync } from "node:fs";
+import { openRouterBenchmarkCandidates, relevantBenchmarks } from "./benchmarks.js";
+import { fetchCatalog, saveSnapshot } from "./catalog.js";
+import { paretoFrontier, pickBest, pickFallback } from "./frontier.js";
+import { JUDGE_PREFS } from "./judge.js";
+import { loadKey, PiCliChatClient } from "./llm.js";
+import { availablePiRoutes, recordedActiveTask, runPiTrial, scorePiRun } from "./pi-trials.js";
+import { loadPolicy, providerAllowed } from "./policy.js";
+import { buildRecommendation } from "./recommend.js";
+import { enrichRouteEntry, routeCatalog, routeKey, routeLabel } from "./routes.js";
+import { appendJsonl, paths, readJson, taskKey } from "./store.js";
+import { pickNext, STRAT_PREFS } from "./strategist.js";
+import { budgetOk, recordMeritSpend, recordTrialSpend, trialBudgetOk } from "./trials.js";
+function optionalOpenRouterKey() {
+    try {
+        return loadKey();
+    }
+    catch {
+        return null;
+    }
+}
+function configuredRoutes() {
+    const state = readJson(paths.harnessState(), {});
+    let routes = state.routes?.length ? state.routes : availablePiRoutes();
+    if (state.currentRoute && !routes.some((route) => routeKey(route) === routeKey(state.currentRoute)))
+        routes = [state.currentRoute, ...routes];
+    const unique = new Map(routes.map((route) => [routeKey(route), route]));
+    return { routes: [...unique.values()], currentRoute: state.currentRoute ?? null };
+}
+function selectorKey(selector) {
+    if (!selector)
+        return null;
+    if (typeof selector === "string")
+        return selector;
+    const modelId = selector.modelId ?? selector.model_id;
+    return selector.provider && modelId ? `${selector.provider}:${modelId}` : null;
+}
+function matchingEntries(cat, selector) {
+    const exact = cat.get(selector);
+    if (exact)
+        return [exact];
+    return [...cat.values()].filter((entry) => entry.id === selector || entry.route?.meritId === selector ||
+        (entry.route && `${entry.route.provider}/${entry.route.modelId}` === selector));
+}
+function resolveInitial(cat, cfg, currentRoute) {
+    const exactKey = selectorKey(cfg.initial_route);
+    if (cfg.initial_route && !exactKey)
+        throw new Error("initial_route must include provider and modelId");
+    if (exactKey) {
+        const exact = cat.get(exactKey);
+        if (!exact)
+            throw new Error(`initial route ${exactKey} is not eligible in Pi`);
+        if (cfg.initial_model !== exact.id && cfg.initial_model !== exactKey)
+            throw new Error(`initial_route ${exactKey} resolves to ${exact.id}, not initial_model ${cfg.initial_model}`);
+        return exact;
+    }
+    const matches = matchingEntries(cat, cfg.initial_model);
+    if (matches.length === 0)
+        throw new Error(`initial_model ${cfg.initial_model} is not eligible in Pi`);
+    if (matches.length === 1)
+        return matches[0];
+    if (currentRoute) {
+        const current = matches.find((entry) => entry.route && routeKey(entry.route) === routeKey(currentRoute));
+        if (current)
+            return current;
+    }
+    throw new Error(`initial_model ${cfg.initial_model} has multiple Pi routes; set initial_route to one of: ` +
+        matches.map((entry) => routeKey(entry.route)).join(", "));
+}
+function resolveMeritRoute(cat, prefs, label) {
+    for (const pref of prefs) {
+        if (!pref)
+            continue;
+        const matches = matchingEntries(cat, pref);
+        if (matches.length)
+            return matches.sort((a, b) => (a.priceKnown === false ? 1 : 0) - (b.priceKnown === false ? 1 : 0) || a.price - b.price)[0];
+    }
+    for (const pref of prefs) {
+        if (!pref)
+            continue;
+        const fuzzy = [...cat.values()].find((entry) => entry.id.includes(pref));
+        if (fuzzy)
+            return fuzzy;
+    }
+    const fallback = [...cat.values()].sort((a, b) => (a.priceKnown === false ? 1 : 0) - (b.priceKnown === false ? 1 : 0) || a.price - b.price)[0];
+    if (fallback)
+        return fallback;
+    throw new Error(`could not resolve ${label} route from Pi's eligible models`);
+}
+async function buildCatalog(routes, key) {
+    let cat = routeCatalog(routes);
+    if (!key)
+        return cat;
+    try {
+        const live = await fetchCatalog(key);
+        saveSnapshot(live);
+        cat = new Map([...cat].map(([id, entry]) => [id,
+            entry.route?.provider === "openrouter" ? enrichRouteEntry(entry, live.get(entry.id)) : entry]));
+    }
+    catch (error) {
+        console.log(`OpenRouter enrichment unavailable: ${error.message}`);
+    }
+    return cat;
+}
+export async function runStandaloneTrial(taskFile, rounds) {
+    const cfg = JSON.parse(readFileSync(taskFile, "utf8"));
+    if (!cfg.task?.trim() || !cfg.eval?.trim() || !cfg.initial_model?.trim())
+        throw new Error("task JSON requires task, eval, and initial_model");
+    if (!Number.isInteger(rounds) || rounds < 1)
+        throw new Error("--rounds must be a positive integer");
+    const policy = loadPolicy(paths.policy());
+    const key = optionalOpenRouterKey();
+    const { routes, currentRoute } = configuredRoutes();
+    let cat = await buildCatalog(routes, key);
+    for (const [id, entry] of [...cat]) {
+        if (!entry.route || !providerAllowed(policy, entry.id, entry.route.provider) ||
+            (entry.priceKnown !== false && entry.price > (cfg.max_usd_per_m ?? policy.max_usd_per_m)))
+            cat.delete(id);
+    }
+    if (cat.size === 0)
+        throw new Error("Pi exposes no model routes allowed by the current policy");
+    const initial = resolveInitial(cat, cfg, currentRoute);
+    const judge = resolveMeritRoute(cat, [cfg.judge_model, policy.judge_model, ...JUDGE_PREFS, initial.id], "judge");
+    const strategist = resolveMeritRoute(cat, [cfg.strategist_model, policy.strategist_model, ...STRAT_PREFS, initial.id], "strategist");
+    const client = new PiCliChatClient(undefined, recordMeritSpend);
+    const { category, benchmarks } = relevantBenchmarks(cfg.task);
+    let benchmarkCandidates = [];
+    if (key) {
+        try {
+            benchmarkCandidates = await openRouterBenchmarkCandidates(key, category, new Map([...cat.values()].map((entry) => [entry.id, entry])));
+        }
+        catch (error) {
+            console.log(`OpenRouter benchmark shortlist unavailable: ${error.message}`);
+        }
+    }
+    console.log(`routes: ${cat.size} eligible in Pi${key ? " (OpenRouter enrichment enabled)" : ""}`);
+    console.log(`initial: ${routeLabel(initial.route)} | judge: ${routeLabel(judge.route)} | ` +
+        `strategist: ${routeLabel(strategist.route)} | benchmarks: ${benchmarks.join(", ")}`);
+    const tKey = taskKey(cfg.task);
+    const tried = new Set();
+    const results = [];
+    const failedProviders = new Set();
+    for (let i = 0; i < rounds; i++) {
+        const daily = budgetOk(policy);
+        if (!daily.ok) {
+            console.log(`budget: ${daily.reason}; stopping`);
+            break;
+        }
+        let entry;
+        let why;
+        if (i === 0) {
+            entry = initial;
+            why = "initial route";
+        }
+        else {
+            const pick = await pickNext(key ?? "", strategist.route, cfg.task, cfg.eval, benchmarks, results, cat, tried, cfg.max_usd_per_m ?? policy.max_usd_per_m, failedProviders, benchmarkCandidates, client);
+            if (!pick)
+                break;
+            entry = pick.route ? cat.get(routeKey(pick.route)) : cat.get(pick.model);
+            why = pick.why;
+        }
+        const route = entry.route;
+        const keyForRoute = routeKey(route);
+        if (tried.has(keyForRoute))
+            break;
+        if (i > 0) {
+            const admission = trialBudgetOk(policy, entry, cfg.task.length);
+            if (!admission.ok) {
+                tried.add(keyForRoute);
+                console.log(`[round ${i + 1}/${rounds}] ${routeLabel(route)} skipped: ${admission.reason}`);
+                continue;
+            }
+        }
+        console.log(`[round ${i + 1}/${rounds}] ${routeLabel(route)} (${why}) ...`);
+        const observed = i === 0 ? recordedActiveTask(cfg.task, route) : null;
+        if (i === 0)
+            console.log(observed
+                ? "    using the exact provider route from Pi's active session trace"
+                : "    active trace unavailable; running the initial route in a fresh Pi session");
+        const outcome = observed
+            ? await scorePiRun(key ?? "", judge.route, cfg.task, cfg.eval, entry.id, entry, observed, "trace", [], client)
+            : await runPiTrial(key ?? "", judge.route, cfg.task, cfg.eval, entry.id, entry, cfg.cwd ?? process.cwd(), [], [], undefined, client);
+        tried.add(keyForRoute);
+        results.push(outcome.point);
+        // Reusing the active Pi answer is observation, not a new candidate call.
+        if (!observed)
+            recordTrialSpend(outcome.costUsd);
+        appendJsonl(paths.trials(), { ...outcome.point, taskKey: tKey });
+        if (outcome.sessionId)
+            console.log(`    pi trace session: ${outcome.sessionId}`);
+        if (outcome.error) {
+            failedProviders.add(route.provider);
+            console.log(`    FAILED: ${outcome.error.slice(0, 160)}`);
+        }
+        else {
+            const price = outcome.point.priceKnown === false ? "price unknown" : `$${outcome.point.price}/M`;
+            console.log(`    score=${outcome.point.score.toFixed(2)}  ${price}  ` +
+                `run=$${outcome.costUsd.toFixed(4)}  ${(outcome.point.why ?? "").slice(0, 100)}`);
+        }
+    }
+    const scored = results.filter((point) => point.score > 0);
+    if (scored.length === 0)
+        throw new Error("no trials completed");
+    const frontier = paretoFrontier(scored);
+    const best = pickBest(scored);
+    const fallback = pickFallback(scored, best, policy.fallback.min_score);
+    console.log("\n=== pareto frontier (quality up, price and latency down) ===");
+    for (const point of frontier)
+        console.log(`  ${(point.route ? routeLabel(point.route) : point.model).padEnd(52)} ` +
+            `score=${point.score.toFixed(2)}  ${point.priceKnown === false ? "price unknown" : `$${point.price.toFixed(2)}/M`}`);
+    console.log(`\nBEST FIT : ${best.route ? routeLabel(best.route) : best.model}`);
+    console.log(fallback ? `FALLBACK : ${fallback.route ? routeLabel(fallback.route) : fallback.model}` : "FALLBACK : n/a");
+    const recommendation = buildRecommendation(tKey, cfg.task.slice(0, 120), initial.id, results, policy, null, initial.route);
+    if (recommendation) {
+        appendJsonl(paths.recommendations(), recommendation);
+        console.log(`\nrecommendation -> ${paths.recommendations()} (auto=${recommendation.policy.autoApply})`);
+    }
+    return { points: results, recommendation };
+}

package/dist/store.js

@@ -1,6 +1,6 @@
 /** State directory layout + JSONL persistence. All state lives under OPENMERIT_HOME (default ~/.openmerit). */
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 export function stateDir() {
@@ -38,20 +38,52 @@ export function appendJsonl(file, obj) {
     mkdirSync(join(file, ".."), { recursive: true });
     appendFileSync(file, JSON.stringify(obj) + "\n");
 }
+/**
+ * Read append-only state without letting one interrupted or malformed line
+ * hide the remaining history. Diagnostics can surface invalid line numbers.
+ */
+export function readJsonlReport(file) {
+    if (!existsSync(file))
+        return { records: [], invalidLines: [] };
+    const records = [];
+    const invalidLines = [];
+    for (const [index, line] of readFileSync(file, "utf8").split("\n").entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            records.push(JSON.parse(line));
+        }
+        catch {
+            invalidLines.push(index + 1);
+        }
+    }
+    return { records, invalidLines };
+}
 export function readJsonl(file) {
+    return readJsonlReport(file).records;
+}
+export function readJsonReport(file, fallback) {
     if (!existsSync(file))
-        return [];
-    return readFileSync(file, "utf8")
-        .split("\n")
-        .filter((l) => l.trim())
-        .map((l) => JSON.parse(l));
+        return { value: fallback, exists: false, valid: true };
+    try {
+        return { value: JSON.parse(readFileSync(file, "utf8")), exists: true, valid: true };
+    }
+    catch (error) {
+        return { value: fallback, exists: true, valid: false, error: error.message };
+    }
 }
 export function readJson(file, fallback) {
-    if (!existsSync(file))
-        return fallback;
-    return JSON.parse(readFileSync(file, "utf8"));
+    return readJsonReport(file, fallback).value;
 }
 export function writeJson(file, obj) {
     mkdirSync(join(file, ".."), { recursive: true });
-    writeFileSync(file, JSON.stringify(obj, null, 2) + "\n");
+    const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        writeFileSync(temp, JSON.stringify(obj, null, 2) + "\n");
+        renameSync(temp, file);
+    }
+    finally {
+        if (existsSync(temp))
+            rmSync(temp, { force: true });
+    }
 }

package/dist/strategist.js

@@ -21,7 +21,7 @@ ROUTES (route id | logical model | blended $/1M tokens | ctx):
 /** Pick the next model to trial, or null when the catalog is exhausted. */
 export async function pickNext(key, stratModel, task, rubric, benchmarks, results, cat, tried, maxPrice, failedVendors, extraCandidates, client = directChatClient(key)) {
     const entryKey = (c) => c.route ? routeKey(c.route) : c.id;
-    const ok = (c) => (c.priceKnown === false || c.price <= maxPrice) &&
+    const ok = (c) => c.priceKnown !== false && c.price <= maxPrice &&
         !tried.has(entryKey(c)) &&
         c.ctx >= 4096 &&
         !failedVendors.has(c.route?.provider ?? c.id.split("/")[0]);

package/dist/trials.js

@@ -1,12 +1,15 @@
 /** Shadow trials: run candidate models against observed/declared tasks on the background track. */
 import { directChatClient } from "./llm.js";
 import { judge, parseObj } from "./judge.js";
-import { paths, readJson, writeJson } from "./store.js";
+import { paths, readJsonReport, writeJson } from "./store.js";
 function today() {
     return new Date().toISOString().slice(0, 10);
 }
 export function budgetOk(policy) {
-    const ledger = readJson(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    const report = readJsonReport(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    if (!report.valid)
+        return { ok: false, reason: "trial ledger is malformed; run `openmerit doctor`" };
+    const ledger = report.value;
     if (ledger.date !== today())
         return { ok: true }; // new day resets
     if (ledger.trials >= policy.budgets.max_trials_per_day)
@@ -31,7 +34,10 @@ export function trialBudgetOk(policy, entry, inputChars) {
     return { ok: true, estimatedUsd };
 }
 export function recordTrialSpend(usd) {
-    let ledger = readJson(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    const report = readJsonReport(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    if (!report.valid)
+        throw new Error("trial ledger is malformed; refusing to reset spend");
+    let ledger = report.value;
     if (ledger.date !== today())
         ledger = { date: today(), trials: 0, usd: 0 };
     ledger.trials += 1;
@@ -42,7 +48,10 @@ export function recordTrialSpend(usd) {
 export function recordMeritSpend(usd) {
     if (!(usd > 0))
         return;
-    let ledger = readJson(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    const report = readJsonReport(paths.ledger(), { date: today(), trials: 0, usd: 0 });
+    if (!report.valid)
+        throw new Error("trial ledger is malformed; refusing to reset spend");
+    let ledger = report.value;
     if (ledger.date !== today())
         ledger = { date: today(), trials: 0, usd: 0 };
     ledger.usd = Math.round((ledger.usd + usd) * 1e6) / 1e6;

package/examples/task.example.json

@@ -2,5 +2,6 @@
   "task": "Write a Python function `def word_ladder(begin, end, words)` that returns the SHORTEST transformation sequence from `begin` to `end`, where consecutive words differ by exactly one character and every intermediate word must be in `words`. Return [] if no path exists. If begin == end return [begin]. All words are the same length, lowercase a-z. Output only runnable code, no explanation.",
   "eval": "Score 1.0 requires ALL of: (a) algorithm guaranteed to find a shortest path (BFS or equivalent, NOT DFS/greedy); (b) returned path starts with begin and ends with end with all intermediates in words; (c) returns [] when impossible; (d) begin==end returns [begin]; (e) begin need not be in words; (f) syntactically valid, runnable Python, no external imports, function named word_ladder; (g) output contains only code. Deduct ~0.2 per missing criterion; non-shortest-path algorithms score at most 0.5.",
   "initial_model": "openai/gpt-4o-mini",
+  "initial_route": "openai:gpt-4o-mini",
   "max_usd_per_m": 20
 }

package/extension/openmerit.ts

@@ -17,7 +17,9 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import {
+  appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { createHash } from "node:crypto";
@@ -84,7 +86,12 @@ function trialBudget(): { summary: string; reason: string | null } {
   const today = new Date().toISOString().slice(0, 10);
   let ledger: { date?: string; trials?: number; usd?: number } = {};
   try { ledger = JSON.parse(readFileSync(LEDGER_FILE, "utf8")) as typeof ledger; }
-  catch { /* no trial spend yet */ }
+  catch {
+    if (existsSync(LEDGER_FILE)) return {
+      summary: "ledger unreadable",
+      reason: "trial ledger is malformed; run `openmerit doctor` before spending",
+    };
+  }
   const trials = ledger.date === today ? ledger.trials ?? 0 : 0;
   const usd = ledger.date === today ? ledger.usd ?? 0 : 0;
   const reason = trials >= limit ? `daily trial cap reached (${limit})`
@@ -107,10 +114,12 @@ function latestSessionJob(sessionFile: string | undefined): string | null {
 }
 
 function loadPolicy(): ExtensionPolicy {
+  if (!existsSync(POLICY_FILE)) return {};
   try {
     return JSON.parse(readFileSync(POLICY_FILE, "utf8")) as ExtensionPolicy;
   } catch {
-    return {};
+    return { mode: "recommend", fallback: { apply_on_error: false },
+      budgets: { max_trials_per_day: 0, max_usd_per_day: 0 } };
   }
 }
 
@@ -173,7 +182,17 @@ function appendJsonl(file: string, obj: unknown): void {
 function latestRecommendations(): Recommendation[] {
   const byId = new Map<string, Recommendation>();
   for (const r of readJsonl<Recommendation>(RECS_FILE)) byId.set(r.id, r);
-  return [...byId.values()];
+  let malformed = false;
+  if (existsSync(RECS_FILE)) {
+    for (const line of readFileSync(RECS_FILE, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try { JSON.parse(line); } catch { malformed = true; break; }
+    }
+  }
+  return [...byId.values()].map((rec) => malformed && rec.status === "pending" && rec.policy.autoApply
+    ? { ...rec, policy: { autoApply: false,
+        reasons: [...rec.policy.reasons, "recommendation history contains a malformed line; manual review required"] } }
+    : rec);
 }
 
 function taskKey(text: string): string {
@@ -305,6 +324,16 @@ function eligibleRoutes(ctx: ExtensionContext): ModelRoute[] {
   return [...byRoute.values()];
 }
 
+function writeState(value: unknown): void {
+  const temp = `${STATE_FILE}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(temp, JSON.stringify(value) + "\n");
+    renameSync(temp, STATE_FILE);
+  } finally {
+    if (existsSync(temp)) rmSync(temp, { force: true });
+  }
+}
+
 function reportHarnessState(ctx: ExtensionContext, settled = false): void {
   try {
     mkdirSync(HOME, { recursive: true });
@@ -317,9 +346,7 @@ function reportHarnessState(ctx: ExtensionContext, settled = false): void {
     const sessionFile = ctx.sessionManager.getSessionFile() ?? null;
     const settledAt = settled ? new Date().toISOString()
       : prior.sessionFile === sessionFile ? prior.settledAt ?? null : null;
-    writeFileSync(
-      STATE_FILE,
-      JSON.stringify({
+    writeState({
         schemaVersion: 1,
         currentModel: model,
         currentRoute,
@@ -331,8 +358,7 @@ function reportHarnessState(ctx: ExtensionContext, settled = false): void {
         settledAt,
         cwd: ctx.cwd,
         updatedAt: new Date().toISOString(),
-      }) + "\n",
-    );
+      });
   } catch {
     /* never break the host session over reporting */
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmerit",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Find better models for each pi task by comparing quality, cost, and latency.",
   "type": "module",
   "keywords": [