@mikenguyen69/harness 0.1.0-beta.1

package/dist/internal/agent/adapter/session.js

@@ -0,0 +1,63 @@
+/**
+ * session — emits `session.*` events into the record plane.
+ *
+ * The interface law (implementation plan §1): agent-harness never imports
+ * system-harness source. It appends through the `harness ledger append`
+ * subcommand so chaining and signing stay in one implementation. The binary is
+ * resolved from $HARNESS_BIN (default "harness"); the ledger dir from
+ * $HARNESS_LEDGER_DIR (default ".harness/ledger").
+ *
+ * Contract D (schema/session-event.schema.json) is the body shape.
+ */
+import { spawnSync } from "node:child_process";
+const PHASE_TYPE = {
+    started: "session.started",
+    heartbeat: "session.heartbeat",
+    gate_fired: "session.gate_fired",
+    escalated: "session.escalated",
+    ended: "session.ended",
+};
+/** The `harness ledger append` payload for a session event — pure, testable. */
+export function buildSessionEvent(phase, body, opts = {}) {
+    const system = opts.system ?? process.env.HARNESS_SYSTEM ?? body.component_id;
+    return {
+        system,
+        actor: { kind: "agent", id: body.session_id },
+        type: PHASE_TYPE[phase],
+        body: { ...body, phase },
+    };
+}
+export function emitSessionEvent(phase, body, opts = {}) {
+    const bin = opts.harnessBin ?? process.env.HARNESS_BIN ?? "harness";
+    let binArgs = [];
+    try {
+        const raw = process.env.HARNESS_BIN_ARGS;
+        if (raw)
+            binArgs = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, reason: "HARNESS_BIN_ARGS must be a JSON string array" };
+    }
+    const ledgerDir = opts.ledgerDir ?? process.env.HARNESS_LEDGER_DIR ?? ".harness/ledger";
+    const event = buildSessionEvent(phase, body, opts);
+    try {
+        const r = spawnSync(bin, [...binArgs, "ledger", "append", "--dir", ledgerDir], {
+            input: JSON.stringify(event),
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        if (r.status === 0)
+            return { ok: true };
+        const reason = `harness ledger append exited ${r.status ?? "null"}: ${(r.stderr ?? r.error?.message ?? "").trim()}`;
+        if (opts.soft ?? true)
+            return { ok: false, reason };
+        throw new Error(reason);
+    }
+    catch (e) {
+        const reason = `could not reach '${bin}': ${e.message}`;
+        if (opts.soft ?? true)
+            return { ok: false, reason };
+        throw e;
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/internal/agent/adapter/settings.js

@@ -0,0 +1,51 @@
+/**
+ * settings — the `.claude/settings.json` hooks block that wires this adapter.
+ * `agent-harness install` prints it; `harness init` writes it by invoking
+ * `adapter/install` (the hook-install path). Generated commands always call
+ * the public facade entry — never an internal binary path and never
+ * AGENT_HARNESS_BIN.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export const HOOK_COMMAND = "harness hook pre-tool-use";
+export function hooksSnippet(binCommand = HOOK_COMMAND) {
+    return {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: "Write|Edit|MultiEdit|NotebookEdit",
+                    hooks: [{ type: "command", command: binCommand }],
+                },
+            ],
+        },
+    };
+}
+function alreadyHasPublicHook(pre) {
+    const text = JSON.stringify(pre);
+    return text.includes("harness hook pre-tool-use") || text.includes("hook pre-tool-use");
+}
+/**
+ * Hook-install write path — merge PreToolUse into `<repo>/.claude/settings.json`.
+ * Idempotent. Owned by this adapter; `harness init` invokes it as a composition.
+ */
+export function installHooks(repoRoot, command = HOOK_COMMAND) {
+    const path = resolve(repoRoot, ".claude", "settings.json");
+    let settings = {};
+    if (existsSync(path)) {
+        try {
+            settings = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const hooks = (settings.hooks ??= {});
+    const pre = (hooks.PreToolUse ??= []);
+    if (!alreadyHasPublicHook(pre)) {
+        pre.push(...hooksSnippet(command).hooks.PreToolUse);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    return path;
+}
+//# sourceMappingURL=settings.js.map

package/dist/internal/agent/cli.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * agent-harness — the fleet adapter surface.
+ *
+ *   agent-harness hook pre-tool-use            PreToolUse handler (payload on stdin)
+ *   agent-harness session <phase> < body       append a session.<phase> event
+ *   agent-harness escalate --reason R --wants W raise session.escalated for the current unit
+ *   agent-harness route <unit-id> --profile p  print the resolved route as JSON (P7.0)
+ *   agent-harness install                      print the .claude/settings.json hooks block
+ *
+ * Never imports @harness/system source — it reaches the ledger through the
+ * `harness ledger append` subcommand (interface law).
+ */
+import { readFileSync } from "node:fs";
+import { loadUnitContext, runHookFromStdin } from "./adapter/hook.js";
+import { emitSessionEvent } from "./adapter/session.js";
+import { hooksSnippet } from "./adapter/settings.js";
+import { routeCommand } from "./routing/cli.js";
+const argv = process.argv.slice(2);
+const [cmd, sub] = argv;
+function flag(name) {
+    const i = argv.indexOf(`--${name}`);
+    return i >= 0 && argv[i + 1] ? argv[i + 1] : undefined;
+}
+if (cmd === "hook" && sub === "pre-tool-use") {
+    const result = runHookFromStdin(readFileSync(0, "utf8"));
+    if (result.message)
+        process.stderr.write(result.message + "\n");
+    process.exit(result.exitCode);
+}
+if (cmd === "session" && sub) {
+    const phases = [
+        "started",
+        "heartbeat",
+        "gate_fired",
+        "escalated",
+        "ended",
+    ];
+    if (!phases.includes(sub)) {
+        process.stderr.write(`unknown session phase "${sub}" (${phases.join(" | ")})\n`);
+        process.exit(2);
+    }
+    const body = JSON.parse(readFileSync(0, "utf8") || "{}");
+    const r = emitSessionEvent(sub, body, { soft: true });
+    if (!r.ok)
+        process.stderr.write(`session ${sub}: ${r.reason}\n`);
+    process.exit(r.ok ? 0 : 1);
+}
+if (cmd === "escalate") {
+    const reason = flag("reason");
+    const wants = flag("wants");
+    if (!reason || !wants) {
+        process.stderr.write('agent-harness escalate --reason "<why>" --wants "<what you need>"\n');
+        process.exit(2);
+    }
+    const ctx = loadUnitContext(flag("cwd") ?? process.cwd());
+    if (!ctx) {
+        process.stderr.write("escalate: no current-unit context (.harness/current-unit.json or HARNESS_UNIT_* env)\n");
+        process.exit(2);
+    }
+    const r = emitSessionEvent("escalated", {
+        session_id: flag("session") ?? process.env.HARNESS_SESSION_ID ?? "unknown",
+        unit_id: ctx.unit_id,
+        component_id: ctx.component_id,
+        escalation: { reason, wants },
+    }, { soft: true });
+    process.stdout.write(r.ok ? `escalated ${ctx.unit_id}\n` : `escalate: ${r.reason}\n`);
+    process.exit(r.ok ? 0 : 1);
+}
+if (cmd === "route") {
+    process.exit(routeCommand(argv.slice(1)));
+}
+if (cmd === "install") {
+    process.stdout.write(JSON.stringify(hooksSnippet(), null, 2) + "\n");
+    process.exit(0);
+}
+process.stderr.write("agent-harness <hook pre-tool-use | session <phase> | escalate | route | install>\n");
+process.exit(2);
+//# sourceMappingURL=cli.js.map

package/dist/internal/agent/evals/index.js

@@ -0,0 +1,111 @@
+/**
+ * evals — seeded-defect scoring. For a route (model[/config]) and a set of
+ * seeded-defect cases, run the route's ring-0+1 loop over each and score the
+ * catch rate. `eval.run {route, catch_rate, n}` is appended to the ledger.
+ *
+ * Below a case-count floor the score is `null` — "insufficient data", never a
+ * fake number. Ships with a synthetic case set so the runner works before a
+ * real corpus exists.
+ */
+import { spawnSync } from "node:child_process";
+export const DEFAULT_FLOOR = 5;
+/** Synthetic seeded-defect cases — a labelled fallback until the real corpus feeds this. */
+export function syntheticCases() {
+    return [
+        {
+            id: "syn-spec-1",
+            klass: "spec",
+            input: { vague: true },
+            mustCatch: true,
+        },
+        {
+            id: "syn-spec-2",
+            klass: "spec",
+            input: { vague: false },
+            mustCatch: false,
+        },
+        {
+            id: "syn-supp-1",
+            klass: "suppression",
+            input: { added: 1 },
+            mustCatch: true,
+        },
+        {
+            id: "syn-supp-2",
+            klass: "suppression",
+            input: { added: 0 },
+            mustCatch: false,
+        },
+        {
+            id: "syn-scope-1",
+            klass: "scope",
+            input: { outside: 2 },
+            mustCatch: true,
+        },
+        {
+            id: "syn-scope-2",
+            klass: "scope",
+            input: { outside: 0 },
+            mustCatch: false,
+        },
+        {
+            id: "syn-testweak-1",
+            klass: "test-weakening",
+            input: { removed: 3 },
+            mustCatch: true,
+        },
+    ];
+}
+export async function runEvals(route, cases, catcher, floor = DEFAULT_FLOOR) {
+    const perClass = {};
+    let caught = 0;
+    let mustCount = 0;
+    for (const c of cases) {
+        const hit = await catcher(c);
+        (perClass[c.klass] ??= { n: 0, caught: 0 }).n++;
+        if (c.mustCatch) {
+            mustCount++;
+            if (hit) {
+                caught++;
+                perClass[c.klass].caught++;
+            }
+        }
+    }
+    const insufficient = cases.length < floor;
+    return {
+        route,
+        n: cases.length,
+        caught,
+        missed: mustCount - caught,
+        catchRate: insufficient || mustCount === 0
+            ? null
+            : Number((caught / mustCount).toFixed(3)),
+        insufficient,
+        perClass,
+    };
+}
+/** Append `eval.run {route, catch_rate, n}` through `harness ledger append`. */
+export function emitEvalRun(result, opts = {}) {
+    const bin = opts.harnessBin ?? process.env.HARNESS_BIN ?? "harness";
+    const ledgerDir = opts.ledgerDir ?? process.env.HARNESS_LEDGER_DIR ?? ".harness/ledger";
+    const event = {
+        system: opts.system ?? process.env.HARNESS_SYSTEM ?? "fleet",
+        actor: { kind: "ci", id: "eval-job" },
+        type: "eval.run",
+        body: { route: result.route, catch_rate: result.catchRate, n: result.n },
+    };
+    try {
+        const r = spawnSync(bin, ["ledger", "append", "--dir", ledgerDir], {
+            input: JSON.stringify(event),
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        return r.status === 0
+            ? { ok: true }
+            : { ok: false, reason: (r.stderr ?? "").trim() };
+    }
+    catch (e) {
+        return { ok: false, reason: e.message };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/agent/index.js

@@ -0,0 +1,15 @@
+/**
+ * @harness/agent — the agent fleet: the Claude Code adapter (telemetry + scope
+ * enforcement, ring 0) now; evals and routing in Phase 6.
+ */
+export { checkToolCall, } from "./adapter/scope.js";
+export { emitSessionEvent, buildSessionEvent, } from "./adapter/session.js";
+export { handlePreToolUse, runHookFromStdin, loadUnitContext, } from "./adapter/hook.js";
+export { hooksSnippet } from "./adapter/settings.js";
+export { readLedger } from "./ledger-read.js";
+export { join as joinTelemetry, joinLedger, } from "./telemetry/index.js";
+export { runEvals, emitEvalRun, syntheticCases, DEFAULT_FLOOR, } from "./evals/index.js";
+export { loadRoutes, resolveRoute, effectiveMode, untilSatisfied, driftFlag, RoutesError, } from "./routing/index.js";
+export { routeCommand, resolveForCli, latestEvalScore, } from "./routing/cli.js";
+export const PRODUCT = "@harness/agent";
+//# sourceMappingURL=index.js.map

package/dist/internal/agent/ledger-read.js

@@ -0,0 +1,27 @@
+/**
+ * ledger-read — agent-harness's read-only view of the record plane.
+ *
+ * The ledger FORMAT is a published interface (implementation plan §1): JSONL
+ * segments, one event per line. agent-harness reads it here without importing
+ * @harness/system source. It never writes — appends go through
+ * `harness ledger append` (see adapter/session.ts).
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const SEGMENT_RE = /^\d{6}\.jsonl$/;
+export function readLedger(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const seg of readdirSync(dir)
+        .filter((n) => SEGMENT_RE.test(n))
+        .sort()) {
+        for (const line of readFileSync(join(dir, seg), "utf8").split("\n")) {
+            if (line.trim() === "")
+                continue;
+            out.push(JSON.parse(line));
+        }
+    }
+    return out.sort((a, b) => a.seq - b.seq);
+}
+//# sourceMappingURL=ledger-read.js.map

package/dist/internal/agent/routing/cli.js

@@ -0,0 +1,104 @@
+/**
+ * `agent-harness route` — the routing consumption CLI (P7.0).
+ *
+ *   agent-harness route <unit-id> --profile <p> [--routes <path>] [--ledger <dir>] [--json]
+ *
+ * `resolveRoute` is otherwise a source-only function, and portfolio rule 1
+ * forbids importing it across `repos/` — so this subcommand is the ONLY legal
+ * way for a sibling (orchestration-harness's loop, its M2 dispatch) to read the
+ * routing decision for a unit.
+ *
+ * Inputs:
+ *   <unit-id>    the A/B split key — the arm a unit lands on is stable per id
+ *   --profile    the unit's component profile (the orchestrator has this from
+ *                the `harness claim` briefing's "component + profile context");
+ *                `resolveRoute` matches routes by profile, so it is required
+ *   --routes     routes.toml (default: ./routes.toml, like the sibling CLIs)
+ *   --ledger     ledger dir for the latest `eval.run` score behind `until`
+ *                (default: .harness/ledger)
+ *
+ * Output (stdout, JSON): `{ runner, model, config?, mode, until? }`
+ *   runner  from the route (P7.1); "claude" when the route omits it
+ *   mode    effectiveMode — a `propose-only` route reads back `standard` once
+ *           its `until` (e.g. route-eval>=90) is met by the ledger score
+ *
+ * Exit: 0 with JSON · 1 when no route matches the profile · 2 on usage error.
+ */
+import { readLedger } from "../ledger-read.js";
+import { effectiveMode, loadRoutes, resolveRoute, RoutesError, } from "./index.js";
+function flag(args, name) {
+    const i = args.indexOf(`--${name}`);
+    return i >= 0 && args[i + 1] ? args[i + 1] : undefined;
+}
+/**
+ * The latest `eval.run` catch rate for a route, as a 0..100 score for
+ * `untilSatisfied` (the ledger stores `catch_rate` as a 0..1 fraction). `null`
+ * when there is no measurement — `effectiveMode` then keeps the tight mode.
+ */
+export function latestEvalScore(ledgerDir, route) {
+    const keys = new Set(route.config ? [route.model, `${route.model}/${route.config}`] : [route.model]);
+    let score = null;
+    for (const e of readLedger(ledgerDir)) {
+        if (e.type !== "eval.run")
+            continue;
+        const body = e.body;
+        if (typeof body.route !== "string" || !keys.has(body.route))
+            continue;
+        score = typeof body.catch_rate === "number" ? body.catch_rate * 100 : null;
+    }
+    return score;
+}
+export function resolveForCli(opts) {
+    const routes = loadRoutes(opts.routesPath);
+    const route = resolveRoute(routes, opts.profile, opts.unitId);
+    if (!route)
+        return null;
+    const score = latestEvalScore(opts.ledgerDir, route);
+    const resolved = {
+        runner: route.runner,
+        model: route.model,
+        mode: effectiveMode(route, score),
+    };
+    if (route.config !== undefined)
+        resolved.config = route.config;
+    if (route.until !== undefined)
+        resolved.until = route.until;
+    return resolved;
+}
+export function routeCommand(args) {
+    const unitId = args[0];
+    if (!unitId || unitId.startsWith("--")) {
+        process.stderr.write("agent-harness route <unit-id> --profile <p> [--routes <path>] [--ledger <dir>] [--json]\n");
+        return 2;
+    }
+    const profile = flag(args, "profile");
+    if (!profile) {
+        process.stderr.write("route: --profile <p> is required (the unit's component profile — resolveRoute matches by profile)\n");
+        return 2;
+    }
+    const routesPath = flag(args, "routes") ?? "routes.toml";
+    const ledgerDir = flag(args, "ledger") ?? ".harness/ledger";
+    let resolved;
+    try {
+        resolved = resolveForCli({ unitId, profile, routesPath, ledgerDir });
+    }
+    catch (e) {
+        if (e instanceof RoutesError) {
+            process.stderr.write(`route: ${e.message}\n`);
+            return 2;
+        }
+        const err = e;
+        if (err.code === "ENOENT") {
+            process.stderr.write(`route: routes file not found: ${routesPath}\n`);
+            return 2;
+        }
+        throw e;
+    }
+    if (!resolved) {
+        process.stderr.write(`route: no route matches profile "${profile}"\n`);
+        return 1;
+    }
+    process.stdout.write(JSON.stringify(resolved) + "\n");
+    return 0;
+}
+//# sourceMappingURL=cli.js.map

package/dist/internal/agent/routing/index.js

@@ -0,0 +1,123 @@
+/**
+ * routing — routes.toml as policy data (Contract D, schema/routes.schema.json).
+ * Maps a component profile to a model + config, an optional A/B split, and an
+ * optional `until` that relaxes a tightened mode once the eval loop measures it
+ * (D8). Also flags eval drift across a model-rev boundary.
+ *
+ * Calibration may PROPOSE route changes; it never applies them.
+ */
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { parse as parseToml } from "smol-toml";
+export class RoutesError extends Error {
+    name = "RoutesError";
+}
+export function loadRoutes(path) {
+    const raw = parseToml(readFileSync(path, "utf8"));
+    if (!Array.isArray(raw.route) || raw.route.length === 0) {
+        throw new RoutesError(`${path}: at least one [[route]] is required`);
+    }
+    const routes = raw.route.map((r, i) => {
+        const o = r;
+        if (typeof o.profile !== "string" || typeof o.model !== "string") {
+            throw new RoutesError(`route[${i}]: profile and model are required`);
+        }
+        if (o.split !== undefined &&
+            (typeof o.split !== "number" || o.split < 0 || o.split > 1)) {
+            throw new RoutesError(`route[${i}]: split must be in [0,1]`);
+        }
+        const mode = o.mode ?? "standard";
+        if (mode !== "standard" && mode !== "propose-only") {
+            throw new RoutesError(`route[${i}]: mode must be standard|propose-only`);
+        }
+        const runner = o.runner ?? "claude";
+        if (runner !== "claude" && runner !== "codex" && runner !== "cursor") {
+            throw new RoutesError(`route[${i}]: runner must be claude|codex|cursor`);
+        }
+        return {
+            profile: o.profile,
+            model: o.model,
+            runner,
+            mode,
+            ...(typeof o.config === "string" ? { config: o.config } : {}),
+            ...(typeof o.split === "number" ? { split: o.split } : {}),
+            ...(typeof o.until === "string" ? { until: o.until } : {}),
+        };
+    });
+    // resolveRoute treats a candidate with no `split` as weight 0 once ANY
+    // sibling declares one — a partial split within a profile silently strands
+    // the splitless route(s), so require all-or-nothing per profile.
+    const byProfile = new Map();
+    for (const r of routes) {
+        byProfile.set(r.profile, [...(byProfile.get(r.profile) ?? []), r]);
+    }
+    for (const [profile, group] of byProfile) {
+        if (group.length <= 1)
+            continue;
+        const withSplit = group.filter((r) => r.split !== undefined).length;
+        if (withSplit > 0 && withSplit < group.length) {
+            throw new RoutesError(`${path}: profile "${profile}" has ${group.length} routes but only ${withSplit} declare split — either all or none must (a splitless route among split siblings is unreachable)`);
+        }
+    }
+    return routes;
+}
+/**
+ * Pick the route for a profile. When >1 route shares a profile, `unitKey`
+ * deterministically selects an A/B arm by split weight (stable per unit).
+ */
+export function resolveRoute(routes, profile, unitKey = "") {
+    const candidates = routes.filter((r) => r.profile === profile);
+    if (candidates.length <= 1)
+        return candidates[0];
+    const total = candidates.reduce((s, r) => s + (r.split ?? 0), 0) || candidates.length;
+    const frac = candidates.some((r) => r.split !== undefined)
+        ? undefined
+        : 1 / candidates.length;
+    const roll = (parseInt(createHash("sha256").update(unitKey).digest("hex").slice(0, 8), 16) /
+        0xffffffff) *
+        total;
+    let acc = 0;
+    for (const r of candidates) {
+        acc += frac ?? r.split ?? 0;
+        if (roll <= acc)
+            return r;
+    }
+    return candidates.at(-1);
+}
+/** Parse an `until` like "route-eval>=90" and evaluate it against a score (0..100). */
+export function untilSatisfied(until, evalScore) {
+    if (!until)
+        return false;
+    const m = /^route-eval\s*(>=|>|==)\s*(\d+(?:\.\d+)?)$/.exec(until.trim());
+    if (!m || evalScore === null)
+        return false;
+    const n = Number(m[2]);
+    return m[1] === ">"
+        ? evalScore > n
+        : m[1] === "=="
+            ? evalScore === n
+            : evalScore >= n;
+}
+/** The effective mode: a `propose-only` route relaxes to `standard` once its `until` is met. */
+export function effectiveMode(route, evalScore) {
+    if (route.mode === "propose-only" && untilSatisfied(route.until, evalScore))
+        return "standard";
+    return route.mode;
+}
+/**
+ * Flag drift when a route's catch rate drops by more than `threshold` (fraction,
+ * e.g. 0.09 for 9 points) after a model revision.
+ */
+export function driftFlag(prev, curr, threshold = 0.09) {
+    if (prev === null || curr === null)
+        return { drifted: false, delta: null };
+    const delta = Number((curr - prev).toFixed(3));
+    return delta < -threshold
+        ? {
+            drifted: true,
+            delta,
+            reason: `catch rate fell ${Math.abs(delta * 100).toFixed(0)} points after a model rev`,
+        }
+        : { drifted: false, delta };
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/agent/telemetry/index.js

@@ -0,0 +1,97 @@
+/**
+ * telemetry — the (session ↔ envelope) join. Pure projection over the ledger:
+ * every envelope names its session; every session names its model + cost. The
+ * join gives cost per merged unit, in-loop (ring-0) catch counts, and
+ * escalation rate — per route.
+ *
+ * D2 boundary: this is READ by agent-harness only; system-harness never reads a
+ * session record to decide a merge.
+ */
+import { readLedger } from "../ledger-read.js";
+function routeKey(s) {
+    const m = s.model ?? "unknown";
+    return s.configHash ? `${m}/${s.configHash}` : m;
+}
+export function join(events) {
+    // 1. fold sessions
+    const sessions = new Map();
+    for (const e of events) {
+        if (!e.type.startsWith("session."))
+            continue;
+        const b = e.body;
+        const id = b.session_id ?? "unknown";
+        const s = sessions.get(id) ?? {
+            model: null,
+            configHash: null,
+            costUsd: 0,
+            unitId: null,
+            escalated: false,
+        };
+        if (b.model)
+            s.model = b.model;
+        if (b.config_hash)
+            s.configHash = b.config_hash;
+        if (typeof b.cost_usd === "number")
+            s.costUsd += b.cost_usd;
+        if (b.unit_id)
+            s.unitId = b.unit_id;
+        if (e.type === "session.escalated")
+            s.escalated = true;
+        sessions.set(id, s);
+    }
+    // 2. envelopes carry session_id + pre_failures; unit.merged marks a merged unit
+    const preFailuresBySession = new Map();
+    const mergedUnits = new Set();
+    for (const e of events) {
+        if (e.type === "unit.merged") {
+            const uid = e.body.unit_id;
+            if (uid)
+                mergedUnits.add(uid);
+        }
+        if (e.type !== "envelope")
+            continue;
+        const b = e.body;
+        if (!b.session_id)
+            continue;
+        const pf = (b.gates ?? []).reduce((n, g) => n + (g.pre_failures ?? 0), 0);
+        preFailuresBySession.set(b.session_id, (preFailuresBySession.get(b.session_id) ?? 0) + pf);
+    }
+    // 3. roll up per route
+    const routes = new Map();
+    for (const [id, s] of sessions) {
+        const key = routeKey(s);
+        const r = routes.get(key) ??
+            {
+                route: key,
+                sessions: 0,
+                mergedUnits: 0,
+                totalCostUsd: 0,
+                costPerMergedUnit: null,
+                ring0Catches: 0,
+                escalations: 0,
+                escalationRate: 0,
+            };
+        r.sessions++;
+        r.totalCostUsd += s.costUsd;
+        r.ring0Catches += preFailuresBySession.get(id) ?? 0;
+        if (s.escalated)
+            r.escalations++;
+        if (s.unitId && mergedUnits.has(s.unitId))
+            r.mergedUnits++;
+        routes.set(key, r);
+    }
+    for (const r of routes.values()) {
+        r.costPerMergedUnit =
+            r.mergedUnits > 0
+                ? Number((r.totalCostUsd / r.mergedUnits).toFixed(2))
+                : null;
+        r.escalationRate =
+            r.sessions > 0 ? Number((r.escalations / r.sessions).toFixed(3)) : 0;
+        r.totalCostUsd = Number(r.totalCostUsd.toFixed(2));
+    }
+    return [...routes.values()].sort((a, b) => a.route.localeCompare(b.route));
+}
+export function joinLedger(ledgerDir) {
+    return join(readLedger(ledgerDir));
+}
+//# sourceMappingURL=index.js.map