openmerit 0.1.3 → 0.1.5

package/dist/standalone.js

@@ -1,220 +0,0 @@
-/** 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,89 +0,0 @@
-/** State directory layout + JSONL persistence. All state lives under OPENMERIT_HOME (default ~/.openmerit). */
-import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-export function stateDir() {
-    const dir = process.env.OPENMERIT_HOME ?? join(homedir(), ".openmerit");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    return dir;
-}
-export const paths = {
-    policy: () => join(stateDir(), "policy.json"),
-    trials: () => join(stateDir(), "trials.jsonl"),
-    recommendations: () => join(stateDir(), "recommendations.jsonl"),
-    catalogSnapshot: () => join(stateDir(), "catalog", "snapshot.json"),
-    candidates: () => join(stateDir(), "catalog", "candidates.json"),
-    benchmarksDigest: () => join(stateDir(), "benchmarks", "digest.json"),
-    traceCursor: () => join(stateDir(), "traces", "cursor.json"),
-    observations: () => join(stateDir(), "traces", "observations.jsonl"),
-    events: () => join(stateDir(), "events.jsonl"),
-    harnessState: () => join(stateDir(), "harness-state.json"),
-    ledger: () => join(stateDir(), "ledger.json"),
-    watchProcessed: () => join(stateDir(), "watch", "processed.json"),
-    sessionJob: (marker) => join(stateDir(), "watch", "jobs", sha1(marker) + ".json"),
-    trialTrace: (id) => join(stateDir(), "traces", "trials", `${sha1(id)}.jsonl`),
-    envFile: () => join(stateDir(), ".env"),
-};
-export function sha1(text) {
-    return createHash("sha1").update(text).digest("hex").slice(0, 12);
-}
-/** Stable task key from a task statement. */
-export function taskKey(taskText) {
-    const normalized = taskText.toLowerCase().replace(/\s+/g, " ").trim();
-    return sha1(normalized);
-}
-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 { 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) {
-    return readJsonReport(file, fallback).value;
-}
-export function writeJson(file, obj) {
-    mkdirSync(join(file, ".."), { recursive: true });
-    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

@@ -1,68 +0,0 @@
-/** Strategist: pick the next untried model to trial, benchmark-aware. */
-import { directChatClient } from "./llm.js";
-import { parseObj } from "./judge.js";
-import { routeKey, routeLabel } from "./routes.js";
-export const STRAT_PREFS = [
-    "anthropic/claude-3.7-sonnet",
-    "anthropic/claude-3.5-sonnet",
-    "openai/gpt-4o",
-];
-const STRAT_PROMPT = `We are finding the best configured model route for a task via iterative trials.
-TASK: {task}
-RUBRIC: {rubric}
-RELEVANT PUBLIC BENCHMARKS FOR THIS TASK: {benchmarks}
-RESULTS SO FAR (model=score): {results}
-Pick ONE untried model from the catalog below that is likely to do well on this
-task, based on the benchmarks relevant to it. Balance quality against price so
-a pareto frontier emerges.
-Return ONLY json: {{"next_model": "<route id>", "why": "<one line>"}}
-ROUTES (route id | logical model | blended $/1M tokens | ctx):
-{catalog}`;
-/** 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 &&
-        !tried.has(entryKey(c)) &&
-        c.ctx >= 4096 &&
-        !failedVendors.has(c.route?.provider ?? c.id.split("/")[0]);
-    // Benchmark-shortlisted models get priority in the listing.
-    const pool = [...cat.values()].filter(ok);
-    if (pool.length === 0)
-        return null;
-    const priority = new Set(extraCandidates ?? []);
-    pool.sort((a, b) => {
-        const pa = priority.has(a.id) ? 0 : 1;
-        const pb = priority.has(b.id) ? 0 : 1;
-        return pa - pb || (a.priceKnown === false ? 1 : 0) - (b.priceKnown === false ? 1 : 0) || a.price - b.price;
-    });
-    const lines = pool
-        .map((c) => `${entryKey(c)} | ${c.route ? routeLabel(c.route) : c.id} | ` +
-        `${c.priceKnown === false ? "unknown" : c.price.toFixed(2)} | ${c.ctx}${priority.has(c.id) ? " | BENCHMARK" : ""}`)
-        .join("\n");
-    const res = results
-        .map((r) => `${r.model}=${r.score.toFixed(2)}`)
-        .join("  ") || "none yet";
-    const { content } = await client.chat(stratModel, STRAT_PROMPT.replace("{task}", task)
-        .replace("{rubric}", rubric)
-        .replace("{benchmarks}", benchmarks.join(", "))
-        .replace("{results}", res)
-        .replace("{catalog}", lines), 1024, 0.2);
-    let pick = null;
-    let why = "unparseable strategist output";
-    try {
-        const obj = parseObj(content);
-        pick = typeof obj.next_model === "string" ? obj.next_model : null;
-        why = String(obj.why ?? "");
-    }
-    catch {
-        /* fall through to cheap pick */
-    }
-    if (pick) {
-        const entry = cat.get(pick) ?? [...cat.values()].find((candidate) => candidate.id === pick);
-        if (entry && ok(entry))
-            return { model: entry.id, route: entry.route, why };
-    }
-    const cheapest = pool[0];
-    return { model: cheapest.id, route: cheapest.route,
-        why: `fallback pick: cheapest untried (strategist pick ${pick ?? "none"} unusable)` };
-}

package/dist/task-input.js

@@ -1,54 +0,0 @@
-/** A pi text task may carry images embedded in its saved session message. */
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { basename } from "node:path";
-import { taskKey } from "./store.js";
-/** Recover files Pi expanded into a task message (for example @invoice.pdf). */
-export function sessionFiles(text) {
-    const files = [];
-    const seen = new Set();
-    const re = /<file\s+name=["']([^"']+)["'][^>]*>/g;
-    for (const match of text.matchAll(re)) {
-        const file = match[1];
-        if (!file || seen.has(file) || !existsSync(file))
-            continue;
-        try {
-            const stat = statSync(file);
-            if (!stat.isFile() || stat.size > 100_000_000)
-                continue;
-            files.push({ path: file, name: basename(file), size: stat.size,
-                sha256: createHash("sha256").update(readFileSync(file)).digest("hex") });
-            seen.add(file);
-        }
-        catch { /* inaccessible attachment */ }
-    }
-    return files;
-}
-const SUPPORTED = new Set(["image/jpeg", "image/png", "image/webp", "image/gif"]);
-export function sessionImages(content) {
-    if (!Array.isArray(content))
-        return [];
-    const images = [];
-    for (const part of content) {
-        if (!part || typeof part !== "object")
-            return null;
-        if (part.type === "text")
-            continue;
-        if (part.type !== "image" || typeof part.data !== "string" ||
-            typeof part.mimeType !== "string" || !SUPPORTED.has(part.mimeType) ||
-            !/^[A-Za-z0-9+/]+={0,2}$/.test(part.data))
-            return null;
-        images.push({ type: "image", data: part.data, mimeType: part.mimeType });
-    }
-    return images;
-}
-/** Text-only keys remain compatible; image bytes distinguish same-prompt documents. */
-export function taskInputKey(text, images, files = []) {
-    if (images.length === 0 && files.length === 0)
-        return taskKey(text);
-    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
-    const hashes = images.map((image) => `${image.mimeType}:` +
-        createHash("sha256").update(Buffer.from(image.data, "base64")).digest("hex"));
-    const fileHashes = files.map((file) => `${file.name}:${file.sha256}`).join(",");
-    return taskKey(`${normalized}\nimages:${hashes.join(",")}\nfiles:${fileHashes}`);
-}

package/dist/traces.js

@@ -1,127 +0,0 @@
-/**
- * Trace ingestion: read pi session files (JSONL entry trees) and extract
- * per-task observations (model, cost, tokens, latency, errors). Incremental
- * via a per-file byte-offset cursor, so the background track never re-reads.
- */
-import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { paths, readJson, taskKey, writeJson } from "./store.js";
-import { meritModelId, modelRoute } from "./routes.js";
-export function defaultSessionsDir() {
-    return join(homedir(), ".pi", "agent", "sessions");
-}
-function listSessionFiles(dir) {
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const p = join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...listSessionFiles(p));
-        else if (entry.name.endsWith(".jsonl"))
-            out.push(p);
-    }
-    return out;
-}
-function textOf(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((b) => (b && typeof b === "object" && b.type === "text"
-            ? String(b.text ?? "")
-            : ""))
-            .filter(Boolean)
-            .join(" ");
-    }
-    return "";
-}
-/** Extract observations from the entries of one session file. */
-export function observationsFromEntries(entries, sessionFile) {
-    const obs = [];
-    let current = null;
-    for (const e of entries) {
-        if (e.type !== "message" || !e.message)
-            continue;
-        const m = e.message;
-        if (m.role === "user") {
-            if (current)
-                obs.push(current);
-            const text = textOf(m.content);
-            if (!text.trim()) {
-                current = null;
-                continue;
-            }
-            current = {
-                schemaVersion: 1,
-                taskKey: taskKey(text),
-                taskLabel: text.replace(/\s+/g, " ").trim().slice(0, 120),
-                model: null,
-                costUsd: 0,
-                tokens: 0,
-                latencyMs: null,
-                errors: 0,
-                ts: e.timestamp ?? new Date().toISOString(),
-                sessionFile,
-            };
-            continue;
-        }
-        if (!current)
-            continue;
-        if (m.role === "assistant") {
-            if (!current.model && m.provider && m.model) {
-                current.model = meritModelId(m.provider, m.model);
-                current.route = modelRoute(m.provider, m.model);
-            }
-            current.costUsd += m.usage?.cost?.total ?? 0;
-            current.tokens += m.usage?.totalTokens ?? 0;
-            if (m.stopReason === "error")
-                current.errors += 1;
-            if (typeof m.timestamp === "number") {
-                const start = Date.parse(current.ts);
-                if (!Number.isNaN(start))
-                    current.latencyMs = Math.max(0, m.timestamp - start);
-            }
-        }
-        else if (m.role === "toolResult") {
-            const tr = m;
-            if (tr.isError)
-                current.errors += 1;
-        }
-    }
-    if (current)
-        obs.push(current);
-    return obs;
-}
-/** Read new bytes of every session file since the last run; returns fresh observations. */
-export function ingestNewTraces(sessionsDir = defaultSessionsDir()) {
-    const cursor = readJson(paths.traceCursor(), { offsets: {} });
-    const fresh = [];
-    for (const file of listSessionFiles(sessionsDir)) {
-        const size = statSync(file).size;
-        const from = cursor.offsets[file] ?? 0;
-        if (size <= from)
-            continue;
-        const buf = readFileSync(file);
-        const chunk = buf.subarray(from).toString("utf8");
-        // Drop a trailing partial line; it will be re-read next tick.
-        const lastNl = chunk.lastIndexOf("\n");
-        const complete = lastNl >= 0 ? chunk.slice(0, lastNl + 1) : "";
-        const entries = [];
-        for (const line of complete.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                entries.push(JSON.parse(line));
-            }
-            catch {
-                /* skip corrupt line */
-            }
-        }
-        fresh.push(...observationsFromEntries(entries, file));
-        cursor.offsets[file] = from + Buffer.byteLength(complete);
-    }
-    writeJson(paths.traceCursor(), cursor);
-    return fresh;
-}