@paxnax/berliner 0.5.3 → 0.7.0

package/dist/commands/report.js

@@ -1,10 +1,12 @@
 import { CliError } from "../client.js";
 import { print, warn } from "../output.js";
 import { uploadEvidence } from "../upload.js";
-import { fromTool, patchFirst, projectHint, saveSession, sessionBody } from "./body.js";
+import { announceRefusal, resolveTeam } from "../team.js";
+import { fromTool, patchFirst, projectHint, saveSession, sessionBody, warnTeam } from "./body.js";
 import { inTool } from "./hook.js";
 const required = ["session-id", "title", "repo", "cost", "model", "plan"];
 export async function report(cfg, values, positionals, env) {
+    await announceRefusal(env);
     // Usually an unquoted value with spaces, e.g. --title Fix the bug.
     if (positionals.length)
         throw new CliError(`unexpected argument "${positionals[0]}"; quote values that contain spaces`, "usage");
@@ -19,16 +21,20 @@ export async function report(cfg, values, positionals, env) {
         throw new CliError(`missing required flag(s): ${missing.map((f) => `--${f}`).join(", ")}`, "usage");
     if (values.public && !values.evidence?.length)
         throw new CliError("--public needs --evidence", "usage");
+    // Parsed before anything is saved, so a bad label saves nothing.
+    const evidence = (values.evidence ?? []).map(parseEvidence);
+    const team = await resolveTeam(values, process.cwd(), env);
     const body = { ...sessionBody(values), plan: cfg.plan ?? values.plan };
     const id = values["session-id"];
     const path = `/v1/sessions/${encodeURIComponent(id)}`;
     // Inside a tool a report without --title is usually a follow-up: the derived title is only for a new session. A report
     // without a cost must not replace the saved one either.
     const { json: saved, dropped } = await (tool && (!titled || body.cost_usd === undefined)
-        ? patchFirst(cfg, path, body, titled, values.plan)
-        : saveSession(cfg, "PUT", path, body, values.plan));
+        ? patchFirst(cfg, path, body, titled, values.plan, team)
+        : saveSession(cfg, "PUT", path, { ...body, team: team ?? undefined }, values.plan));
     const json = dropped.length ? { ...saved, dropped } : saved;
     const { created, session } = json;
+    warnTeam(session, team);
     const text = `Saved session ${session.id} (${created ? "created" : "updated"}). ${session.pr_count} PR(s) linked.${projectHint(session)}`;
     const json_ = values.json === true;
     // Human mode prints the session line before uploads start; --json waits so stdout is one document.
@@ -39,7 +45,7 @@ export async function report(cfg, values, positionals, env) {
             print({ data: json, text }, true);
         return;
     }
-    const result = await uploadEvidence(cfg, id, values.evidence.map(parseEvidence), undefined, values.public === true);
+    const result = await uploadEvidence(cfg, id, evidence, undefined, values.public === true);
     if (json_)
         print({ data: { ...json, evidence: result }, text }, true);
     else {
@@ -52,8 +58,17 @@ export async function report(cfg, values, positionals, env) {
     if (values.strict && result.skipped.length)
         process.exitCode = 1;
 }
-// <path>[::<caption>]
+// <path>[::<caption>[::happy|unhappy|edge]]
 function parseEvidence(spec) {
     const i = spec.indexOf("::");
-    return i < 0 ? { path: spec } : { path: spec.slice(0, i), caption: spec.slice(i + 2) || undefined };
+    if (i < 0)
+        return { path: spec };
+    const rest = spec.slice(i + 2);
+    const j = rest.lastIndexOf("::");
+    if (j < 0)
+        return { path: spec.slice(0, i), caption: rest || undefined };
+    const label = rest.slice(j + 2);
+    if (!["happy", "unhappy", "edge"].includes(label))
+        throw new CliError(`Evidence label must be happy, unhappy or edge: "${label}"`, "usage");
+    return { path: spec.slice(0, i), caption: rest.slice(0, j) || undefined, path_label: label };
 }

package/dist/commands/session.js

@@ -1,6 +1,8 @@
 import { absolute, CliError, request } from "../client.js";
-import { mergeLabel, print } from "../output.js";
+import { costLabel, mergeLabel, print } from "../output.js";
+import { announceRefusal } from "../team.js";
 export async function session(cfg, values, positionals) {
+    await announceRefusal(process.env);
     if (positionals.length !== 1)
         throw new CliError("usage: berliner session <session-id> [--json]", "usage");
     const { json } = await request(cfg, "GET", `/v1/sessions/${encodeURIComponent(positionals[0])}`);
@@ -11,7 +13,7 @@ export async function session(cfg, values, positionals) {
         ["Repository", s.repository],
         ["Task", [s.task_id, s.task_url].filter(Boolean).join(" ")],
         ["Project", s.project],
-        ["Estimated cost", `$${s.cost_usd.toFixed(2)}`],
+        ["Estimated cost", costLabel(s.cost_usd, s.cost_status)],
         ["Model", s.model],
         ["Plan", s.plan],
         ["Started", s.started_at],
@@ -19,6 +21,7 @@ export async function session(cfg, values, positionals) {
         ["Duration (s)", s.duration_seconds],
         ["Commits", s.commits],
         ["Coverage", s.coverage],
+        ["Tests", s.tests && `${s.tests.check}${s.tests.command ? ` (${s.tests.command})` : ""}${s.tests.by_ci ? " via CI" : ""}`],
         ["CI", s.ci],
         ["Merge", mergeLabel(s)],
     ];

package/dist/commands/sessions.js

@@ -1,12 +1,13 @@
 import { request } from "../client.js";
-import { mergeLabel, print } from "../output.js";
+import { costLabel, mergeLabel, print } from "../output.js";
+import { announceRefusal } from "../team.js";
 import { filterQuery } from "./query.js";
-const usd = (n) => `$${n.toFixed(2)}`;
 export async function sessions(cfg, values) {
+    await announceRefusal(process.env);
     const { json } = await request(cfg, "GET", `/v1/sessions${filterQuery(values, { limit: values.limit })}`);
     const rows = [["TASK", "TITLE", "REPO", "COST (est.)", "PRS", "CI", "MERGE"]];
     for (const s of json.sessions)
-        rows.push([s.task_id ?? s.id, s.title, s.repository, usd(s.cost_usd), String(s.pr_count), s.ci, mergeLabel(s)]);
+        rows.push([s.task_id ?? s.id, s.title, s.repository, costLabel(s.cost_usd, s.cost_status), String(s.pr_count), s.ci, mergeLabel(s)]);
     const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
     const lines = rows.map((r) => r
         .map((c, i) => c.padEnd(widths[i]))

package/dist/commands/setup.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { CliError, request } from "../client.js";
+import { askNudge } from "./nudge.js";
 import { configPath, DEFAULT_URL, readConfig, readConfigFile, saveConfig } from "../config.js";
 import { machineName, openBrowser, startConnect, waitForApproval } from "../setup/connect.js";
 import { describeClaudeHooks, describeCodexHooks, describeOpenCodePlugin, hookPath, installClaudeHooks, installCodexHooks, installOpenCodePlugin, } from "../setup/hooks.js";
@@ -90,6 +91,7 @@ export async function setup(env, values) {
             throw new CliError("There is no terminal to ask on. Run setup again with --yes to continue without asking.", "usage");
         if (!(await confirm(process.stdin, process.stdout)))
             throw new CliError("Cancelled. Nothing was changed.", "usage");
+        await askNudge(env);
         console.log();
     }
     if (!login) {
@@ -109,7 +111,8 @@ export async function setup(env, values) {
             throw new CliError("The request expired. Run setup again.", "http");
         const me = await request({ url, token: req.token }, "GET", "/v1/me");
         console.log(`✓ Approved by ${me.json.github_login}`);
-        const file = saveConfig(env, url === DEFAULT_URL ? { token: req.token } : { token: req.token, url });
+        const { team, nudge } = readConfigFile(env) ?? {};
+        const file = saveConfig(env, { token: req.token, url: url === DEFAULT_URL ? undefined : url, team, nudge });
         console.log(`✓ Saved token "${name}" to ${tilde(file)}`);
     }
     let installFailed = false;

package/dist/commands/summary.js

@@ -1,14 +1,15 @@
 import { request } from "../client.js";
-import { print, subscriptionLabel } from "../output.js";
+import { print, subscriptionLabel, totalLabel, unpricedNote } from "../output.js";
 import { filterQuery } from "./query.js";
 export async function summary(cfg, values) {
     const { json } = await request(cfg, "GET", `/v1/summary${filterQuery(values)}`);
     const s = json.summary;
+    const unpriced = s.unpriced_sessions ?? 0;
     const text = [
-        `Estimated spend: $${s.spend_usd.toFixed(2)}`,
+        `Spend: ${totalLabel(s.spend_usd, unpriced)}${unpricedNote(unpriced)}`,
         `Sessions: ${s.sessions}`,
         `PRs merged: ${s.prs_merged} of ${s.prs_opened} opened`,
-        `Cost per merged PR: ${s.cost_per_merged_pr === null ? "n/a" : `$${s.cost_per_merged_pr.toFixed(2)}`}`,
+        `Cost per merged PR: ${s.cost_per_merged_pr === null ? "n/a" : totalLabel(s.cost_per_merged_pr, unpriced)}`,
         `Commits: ${s.commits}`,
         ...subscriptionLines(json.subscriptions),
     ].join("\n");
@@ -18,8 +19,8 @@ export async function summary(cfg, values) {
 function subscriptionLines(c) {
     if (!c)
         return [];
-    const lines = c.rows.map((r) => `${subscriptionLabel(r)}: $${r.spend_usd.toFixed(2)} used of $${r.prorated_usd.toFixed(2)} paid (${r.multiple.toFixed(1)}×), ${r.sessions} session(s)`);
+    const lines = c.rows.map((r) => `${subscriptionLabel(r)}: ${totalLabel(r.spend_usd, r.unpriced_sessions ?? 0)} used of $${r.prorated_usd.toFixed(2)} paid (${r.multiple.toFixed(1)}×), ${r.sessions} session(s)`);
     if (c.unmatched.sessions > 0)
-        lines.push(`On no listed plan: $${c.unmatched.spend_usd.toFixed(2)}, ${c.unmatched.sessions} session(s)`);
+        lines.push(`On no listed plan: ${totalLabel(c.unmatched.spend_usd, c.unmatched.unpriced_sessions ?? 0)}, ${c.unmatched.sessions} session(s)`);
     return lines;
 }

package/dist/commands/team.js

@@ -0,0 +1,21 @@
+import { CliError } from "../client.js";
+import { readConfigFile, saveConfig } from "../config.js";
+import { print } from "../output.js";
+import { resolveTeamSource, UUID } from "../team.js";
+const FROM = { flag: "--team", repo: ".berliner.json", env: "BERLINER_TEAM", config: "the global config", none: "" };
+// The team for this directory: shown without an argument, saved in the global config with a uuid, removed with --none.
+export async function team(env, values, positionals) {
+    if (positionals.length > 1 || (positionals.length && values.none))
+        throw new CliError("usage: berliner team [<uuid> | --none] [--json]", "usage");
+    if (positionals.length || values.none) {
+        const id = positionals[0];
+        if (id !== undefined && !UUID.test(id))
+            throw new CliError(`"${id}" is not a team id (a uuid)`, "usage");
+        const file = readConfigFile(env) ?? {};
+        saveConfig(env, { ...file, team: id });
+        return print({ data: { team: id ?? null }, text: id ? `Saved team ${id} in your global config.` : "Removed the team from your global config." }, values.json === true);
+    }
+    const resolved = await resolveTeamSource(values, process.cwd(), env);
+    const text = resolved.team ? `Team ${resolved.team} (from ${FROM[resolved.source]})` : "No team: sessions go on your own plan.";
+    print({ data: resolved, text }, values.json === true);
+}

package/dist/commands/update.js

@@ -1,8 +1,10 @@
 import { CliError } from "../client.js";
 import { print } from "../output.js";
-import { fromTool, patchFirst, projectHint, saveSession, sessionBody } from "./body.js";
+import { announceRefusal, resolveTeam } from "../team.js";
+import { fromTool, patchFirst, projectHint, saveSession, sessionBody, warnTeam } from "./body.js";
 import { inTool } from "./hook.js";
 export async function update(cfg, values, positionals, env) {
+    await announceRefusal(env);
     const tool = inTool(env);
     // Inside a tool the session id is the tool's, so a positional one is ignored like --session-id.
     if (positionals.length !== 1 && !(tool && positionals.length === 0)) {
@@ -18,8 +20,10 @@ export async function update(cfg, values, positionals, env) {
     const id = tool ? tool.sessionId : positionals[0];
     // A plan is only sent when --plan is passed, so an update never changes it unasked; BERLINER_PLAN then replaces it.
     const body = { ...sessionBody(values), plan: values.plan === undefined ? undefined : (cfg.plan ?? values.plan) };
+    const team = await resolveTeam(values, process.cwd(), env);
     const path = `/v1/sessions/${encodeURIComponent(id)}`;
-    const { json: saved, dropped } = await (tool ? patchFirst(cfg, path, body, titled, values.plan) : saveSession(cfg, "PATCH", path, body, values.plan));
+    const { json: saved, dropped } = await (tool ? patchFirst(cfg, path, body, titled, values.plan, team) : saveSession(cfg, "PATCH", path, body, values.plan));
     const json = dropped.length ? { ...saved, dropped } : saved;
+    warnTeam(json.session, team);
     print({ data: json, text: `Updated session ${json.session.id}. ${json.session.pr_count} PR(s) linked.${projectHint(json.session)}` }, values.json === true);
 }

package/dist/commands/upgrade.js

@@ -6,6 +6,7 @@ import { gunzipSync } from "node:zlib";
 import { CliError } from "../client.js";
 import { hookPath, updatedHooks } from "../setup/hooks.js";
 import { detectTools, skillTargets } from "../setup/targets.js";
+import { askNudge } from "./nudge.js";
 import { confirm, installCommand, showPlan, tilde } from "./setup.js";
 const registryOf = (env) => (env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
 async function latestVersion(env) {
@@ -78,9 +79,9 @@ const sameAs = (path, text) => {
 };
 // What a hook gains from this release, for the plan.
 const HOOK_CHANGE = {
-    "claude-code": "the reminder also runs on startup and resume",
+    "claude-code": "Stop hook no longer async, so Berliner can ask the agent to run the tests",
     codex: "the reminder also runs on startup and resume",
-    opencode: "the new reminder, and totals saved in order",
+    opencode: "the new reminder, totals saved in order, and a fork counts only its own messages",
 };
 // The command, the skill, and Berliner hooks already installed: the token and config are setup's, as is adding a hook.
 export async function upgrade(env, values) {
@@ -137,6 +138,7 @@ export async function upgrade(env, values) {
         // Without an install, the skill is all Continue covered.
         if (installing && stale.length && !(await confirm(process.stdin, process.stdout, "Upgrade the skill too? [Y/n] ")))
             stale = [];
+        await askNudge(env);
         console.log();
     }
     if (installing) {

package/dist/config.js

@@ -7,14 +7,29 @@ export function configPath(env) {
 }
 export const stateDir = (env) => join(env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "berliner");
 export const cacheDir = (env) => join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "berliner");
+function readNudge(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const { off_all, off, asked } = raw;
+    return {
+        ...(asked === true && { asked: true }),
+        ...(off_all === true && { off_all: true }),
+        ...(Array.isArray(off) && { off: off.filter((r) => typeof r === "string") }),
+    };
+}
 // A missing or unreadable file is the same as no file: the environment may still hold the token.
 export function readConfigFile(env) {
     try {
         const parsed = JSON.parse(readFileSync(configPath(env), "utf8"));
         if (typeof parsed !== "object" || parsed === null)
             return null;
-        const { token, url } = parsed;
-        return { token: typeof token === "string" ? token : undefined, url: typeof url === "string" ? url : undefined };
+        const { token, url, team, nudge } = parsed;
+        return {
+            token: typeof token === "string" ? token : undefined,
+            url: typeof url === "string" ? url : undefined,
+            team: typeof team === "string" ? team : undefined,
+            nudge: readNudge(nudge),
+        };
     }
     catch {
         return null;

package/dist/gh.js

@@ -5,8 +5,8 @@ const MERGE = { OPEN: "open", MERGED: "merged", CLOSED: "closed" };
 // CheckRun conclusions and StatusContext states.
 const FAILED = ["FAILURE", "ERROR", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"];
 const PENDING = ["PENDING", "EXPECTED"];
-// `gh pr view --json state,statusCheckRollup` as Berliner's merge and CI states. statusCheckRollup mixes CheckRuns (status,
-// conclusion; conclusion is "" until completed) and commit StatusContexts (state).
+// `gh pr view --json state,statusCheckRollup,headRefOid` as Berliner's merge and CI states and the head commit they belong to.
+// statusCheckRollup mixes CheckRuns (status, conclusion; conclusion is "" until completed) and commit StatusContexts (state).
 export function prState(view) {
     const merge_state = MERGE[String(view.state)];
     if (!merge_state)
@@ -19,10 +19,12 @@ export function prState(view) {
             : checks.length
                 ? "passed"
                 : "none";
-    return { merge_state, ci_state };
+    // Anything else the server would refuse, losing the states with it.
+    const head_sha = typeof view.headRefOid === "string" && /^[0-9a-f]{40}$/.test(view.headRefOid) ? view.headRefOid : null;
+    return { merge_state, ci_state, head_sha };
 }
 // The machine's gh, found on PATH; it rejects when gh is missing (code ENOENT), fails or takes over 5 seconds.
 export async function viewPr(url) {
-    const { stdout } = await run("gh", ["pr", "view", url, "--json", "state,statusCheckRollup"], { timeout: 5000 });
+    const { stdout } = await run("gh", ["pr", "view", url, "--json", "state,statusCheckRollup,headRefOid"], { timeout: 5000 });
     return prState(JSON.parse(stdout));
 }

package/dist/index.js

@@ -6,12 +6,14 @@ import { CliError } from "./client.js";
 import { del } from "./commands/delete.js";
 import { evidence } from "./commands/evidence.js";
 import { hook } from "./commands/hook.js";
+import { nudge } from "./commands/nudge.js";
 import { project, projects } from "./commands/projects.js";
 import { report } from "./commands/report.js";
 import { session } from "./commands/session.js";
 import { sessions } from "./commands/sessions.js";
 import { setup } from "./commands/setup.js";
 import { skill } from "./commands/skill.js";
+import { team } from "./commands/team.js";
 import { summary } from "./commands/summary.js";
 import { update } from "./commands/update.js";
 import { upgrade } from "./commands/upgrade.js";
@@ -33,6 +35,11 @@ Commands:
   projects              the project names in use, then each repository's default [--json]
   project [<name>]      show or save this repository's default project; --none saves "no project"
                         [--none --repo <owner/name> --json]
+  team [<uuid>]         show or save the team new sessions are reported to; --none clears it
+                        a team can also come from --team <uuid> / --no-team, .berliner.json {"team": "<uuid>"}, BERLINER_TEAM
+                        [--none --json]
+  nudge [on|off]        show or set whether Berliner asks agents to run the tests before they hand work back, for this repository
+                        [--all for every repository]
   delete <session-id>   [--evidence <id>] [--yes]
   evidence public <id>  let anyone with the link view one file; prints its URL and Markdown [--json]
   evidence private <id> make it viewable only by you again [--json]
@@ -40,7 +47,7 @@ Commands:
   skill                 print the bundled SKILL.md
   hook <tool>           run by the hooks of claude-code, codex or opencode; reads the payload on stdin
 
-Environment: BERLINER_TOKEN, BERLINER_URL, BERLINER_PLAN (replaces --plan)`;
+Environment: BERLINER_TOKEN, BERLINER_URL, BERLINER_PLAN (replaces --plan), BERLINER_TEAM`;
 const args = parse(process.argv.slice(2));
 // Reporting must never fail the agent's own pipeline unless it asks to (anti-goal 1).
 const softFail = (args.command === "report" || args.command === "update") && !args.values.strict;
@@ -53,6 +60,8 @@ const handled = new Set([
     "summary",
     "projects",
     "project",
+    "team",
+    "nudge",
     "delete",
     "evidence",
     "skill",
@@ -84,6 +93,10 @@ try {
         await projects(cfg(), args.values);
     else if (args.command === "project")
         await project(cfg(), args.values, args.positionals);
+    else if (args.command === "team")
+        await team(process.env, args.values, args.positionals);
+    else if (args.command === "nudge")
+        await nudge(process.env, args.values, args.positionals);
     else if (args.command === "delete")
         await del(cfg(), args.values, args.positionals);
     else if (args.command === "evidence")

package/dist/ledger.js

@@ -0,0 +1,202 @@
+import { readFileSync, rmSync } from "node:fs";
+import { appendFile, mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { readClaudeCode, readCodex } from "./agents/index.js";
+import { stateDir } from "./config.js";
+import { takeLock } from "./lock.js";
+import { estimateCost } from "./prices.js";
+import { claudeDir, codexDir } from "./setup/targets.js";
+// For the lock wait and the backfill together.
+const BUDGET_MS = 3_000;
+const PRUNE_BYTES = 20 * 1024 * 1024;
+const KEEP_MS = 60 * 24 * 60 * 60 * 1000;
+const ROLLOUT = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/;
+// In stateDir, not cacheDir: a cache is safe to delete, and losing this reprices every reply.
+const paths = (env) => {
+    const dir = stateDir(env);
+    return { dir, ledger: join(dir, "replies.jsonl"), lock: join(dir, "replies.lock"), progress: join(dir, "replies-backfill.json") };
+};
+const entries = (dir, recursive = false) => readdir(dir, { recursive }).catch(() => []);
+const toText = (lines) => lines.map((l) => `${JSON.stringify(l)}\n`).join("");
+// Each batch starts on a line of its own, so a line cut off by a crash can't swallow the batch's first line; empty lines are skipped.
+const append = (file, lines) => appendFile(file, `\n${toText(lines)}`);
+// The earliest-started session owns a reply; a null start sorts last and a tie goes to the smaller id, so the owner is the
+// same whatever order sessions report in. Starts are UTC ISO strings, which sort as text.
+const before = (a, b) => (a.t === b.t ? a.s < b.s : b.t === null || (a.t !== null && a.t < b.t));
+async function withLock(env, deadline, run) {
+    const { dir, lock } = paths(env);
+    await mkdir(dir, { recursive: true });
+    while (!takeLock(lock)) {
+        if (Date.now() >= deadline)
+            return null;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    // The hook child's deadline ends it with process.exit, which skips the finally below; only a lock this process wrote is removed.
+    const onExit = () => {
+        try {
+            if (readFileSync(lock, "utf8") === String(process.pid))
+                rmSync(lock, { force: true });
+        }
+        catch { }
+    };
+    process.on("exit", onExit);
+    try {
+        return await run();
+    }
+    finally {
+        process.off("exit", onExit);
+        rmSync(lock, { force: true });
+    }
+}
+// A missing ledger is an empty one; any other read error is thrown, since treating it as empty would reprice every reply.
+async function readText(file) {
+    return readFile(file, "utf8").catch((err) => {
+        if (err.code === "ENOENT")
+            return "";
+        throw err;
+    });
+}
+// A line cut off by a crash, or otherwise unparseable, is skipped.
+function parse(text) {
+    const lines = [];
+    for (const raw of text.split("\n")) {
+        try {
+            const l = JSON.parse(raw);
+            if (typeof l?.r !== "string" || typeof l.s !== "string")
+                continue;
+            lines.push({ r: l.r, s: l.s, t: typeof l.t === "string" ? l.t : null, c: typeof l.c === "number" ? l.c : null });
+        }
+        catch { }
+    }
+    return lines;
+}
+function priceOf(reply, prices) {
+    if (!prices)
+        return null;
+    const { costUsd, unpriced } = estimateCost({ [reply.model]: reply.tokens }, prices);
+    return unpriced.length ? null : Math.round(costUsd * 1e6);
+}
+// A session's place in the owner order is when its record file was made: a fork's copied entries keep their parent's timestamps,
+// its file does not. startedAt stands in where the file system keeps no creation time.
+export async function sessionTime(file, startedAt) {
+    const birth = (await stat(file).catch(() => null))?.birthtimeMs ?? 0;
+    return birth > 0 ? new Date(birth).toISOString() : startedAt;
+}
+// Every local Claude Code and Codex transcript, with the session id its file name gives.
+async function transcripts(env) {
+    const found = [];
+    const projects = join(claudeDir(env), "projects");
+    for (const project of await entries(projects)) {
+        for (const name of await entries(join(projects, project))) {
+            if (name.endsWith(".jsonl"))
+                found.push({ file: join(projects, project, name), id: name.slice(0, -".jsonl".length), read: readClaudeCode });
+        }
+    }
+    const sessions = join(codexDir(env), "sessions");
+    for (const f of await entries(sessions, true)) {
+        const id = ROLLOUT.exec(basename(f))?.[1];
+        if (id)
+            found.push({ file: join(sessions, f), id, read: readCodex });
+    }
+    return found;
+}
+// Run under the lock. Claims are written unpriced, so a reply's price is still set by the first report that owns it.
+async function claimTranscripts(env, deadline) {
+    const { ledger, progress } = paths(env);
+    let saved = {};
+    try {
+        saved = JSON.parse(await readFile(progress, "utf8")) ?? {};
+    }
+    catch { }
+    if (saved.complete === true)
+        return true;
+    const done = new Set(Array.isArray(saved.done) ? saved.done.filter((f) => typeof f === "string") : []);
+    const lines = [];
+    let complete = true;
+    for (const { file, id, read } of await transcripts(env)) {
+        if (done.has(file))
+            continue;
+        if (Date.now() >= deadline) {
+            complete = false;
+            break;
+        }
+        // A file removed or unreadable since the listing has nothing left to claim.
+        const facts = await read(file).catch(() => null);
+        const t = facts && (await sessionTime(file, facts.startedAt));
+        for (const r of facts?.replies ?? [])
+            lines.push({ r: r.id, s: id, t, c: null });
+        done.add(file);
+    }
+    if (lines.length)
+        await append(ledger, lines);
+    await writeFile(progress, JSON.stringify({ done: [...done], complete }));
+    return complete;
+}
+// Returns true once every local transcript has been claimed, false when the deadline or the lock stops it first.
+export async function backfill(env, deadline) {
+    return (await withLock(env, deadline, () => claimTranscripts(env, deadline))) ?? false;
+}
+// The cost of the replies this session owns. Null when the lock and the backfill don't both finish within 3 seconds.
+export async function priceSession(env, session, replies, prices) {
+    const deadline = Date.now() + BUDGET_MS;
+    return withLock(env, deadline, async () => {
+        // Until every transcript is claimed, a fork reported first would own the replies it copied from a parent not yet claimed.
+        if (!(await claimTranscripts(env, deadline)))
+            return null;
+        const { ledger } = paths(env);
+        // shortcut: the whole ledger is read on each report, not only the new replies; upgrade to an index if it slows the hook.
+        const text = await readText(ledger);
+        let lines = parse(text);
+        // shortcut: past 20 MB, sessions created over 60 days ago are dropped, as Claude Code deletes transcripts after 30; one still
+        // resumed after that has its replies priced again. Upgrade to a last-seen time per session if that happens in practice.
+        if (Buffer.byteLength(text) > PRUNE_BYTES) {
+            const cutoff = new Date(Date.now() - KEEP_MS).toISOString();
+            const kept = lines.filter((l) => l.t === null || l.t >= cutoff);
+            // Nothing old to drop: a rewrite would cost every report a 20 MB write for nothing.
+            if (kept.length < lines.length) {
+                lines = kept;
+                await writeFile(`${ledger}.${process.pid}`, toText(lines));
+                await rename(`${ledger}.${process.pid}`, ledger);
+            }
+        }
+        const wanted = new Map(replies.map((r) => [r.id, r]));
+        const known = new Map();
+        for (const l of lines) {
+            if (!wanted.has(l.r))
+                continue;
+            const k = known.get(l.r);
+            if (!k)
+                known.set(l.r, { owner: l, price: l.c, mine: l.s === session.id });
+            else {
+                if (before(l, k.owner))
+                    k.owner = l;
+                k.price ??= l.c;
+                k.mine ||= l.s === session.id;
+            }
+        }
+        const add = [];
+        let micros = 0;
+        let owned = 0;
+        let priced = 0;
+        for (const reply of wanted.values()) {
+            const k = known.get(reply.id);
+            const claim = { r: reply.id, s: session.id, t: session.startedAt, c: null };
+            const owner = k && !before(claim, k.owner) ? k.owner : claim;
+            let price = k?.price ?? null;
+            if (owner.s === session.id && price === null)
+                price = claim.c = priceOf(reply, prices);
+            if (!k?.mine || claim.c !== null)
+                add.push(claim);
+            if (owner.s !== session.id)
+                continue;
+            owned++;
+            if (price !== null) {
+                priced++;
+                micros += price;
+            }
+        }
+        if (add.length)
+            await append(ledger, add);
+        return { costUsd: micros / 1e6, status: owned && priced === owned ? "exact" : priced ? "partial" : "unknown" };
+    });
+}

package/dist/lock.js

@@ -0,0 +1,45 @@
+import { linkSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+const LOCK_MS = 60_000;
+// A lock younger than a minute belongs to a running child. An older one was left by a child that died: it is moved aside and
+// removed only if it is the very lock that was checked, so of two children that find it stale only one gets it.
+export function takeLock(lock) {
+    if (createLock(lock))
+        return true;
+    const seen = statSync(lock, { throwIfNoEntry: false });
+    // Gone since: its child just unlocked, so it is free, not stale.
+    if (!seen)
+        return createLock(lock);
+    if (Date.now() - seen.mtimeMs < LOCK_MS)
+        return false;
+    const aside = `${lock}.${process.pid}`;
+    try {
+        renameSync(lock, aside);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        throw err;
+    }
+    if (statSync(aside).ino !== seen.ino) {
+        // shortcut: a third child can lock in the moment before this lock is put back; that needs a dead child and three at once.
+        try {
+            linkSync(aside, lock);
+        }
+        catch { }
+        rmSync(aside, { force: true });
+        return false;
+    }
+    rmSync(aside, { force: true });
+    return createLock(lock);
+}
+function createLock(lock) {
+    try {
+        writeFileSync(lock, String(process.pid), { flag: "wx" });
+        return true;
+    }
+    catch (err) {
+        if (err.code === "EEXIST")
+            return false;
+        throw err;
+    }
+}

package/dist/output.js

@@ -30,3 +30,8 @@ const PLAN = {
     api: "API",
 };
 export const subscriptionLabel = (s) => `${VENDOR[s.vendor] ?? s.vendor} ${PLAN[s.plan] ?? s.plan}`;
+// A session's cost in its three forms: every model priced, some priced (a floor), none priced.
+export const costLabel = (usd, status) => status === "unknown" ? "Unknown" : `${status === "partial" ? "≥ " : ""}$${usd.toFixed(2)}`;
+// A total of sessions, a floor whenever some of them are not fully priced. The count is for the line that names it.
+export const totalLabel = (usd, unpriced) => `${unpriced > 0 ? "≥ " : ""}$${usd.toFixed(2)} est.`;
+export const unpricedNote = (unpriced) => (unpriced > 0 ? ` · ${unpriced} ${unpriced === 1 ? "session" : "sessions"} not fully priced` : "");