@paxnax/berliner 0.6.0 → 0.7.0

package/dist/agents/claude.js

@@ -1,6 +1,6 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import { addTokens, jsonl, num, Span, ticketUrl } from "./read.js";
+import { jsonl, num, Span, sumByModel, ticketUrl } from "./read.js";
 // Subagent transcripts sit next to the session's: <project>/<session-id>/subagents/agent-*.jsonl.
 export async function subagentFiles(transcriptPath) {
     const dir = join(transcriptPath.replace(/\.jsonl$/, ""), "subagents");
@@ -26,7 +26,9 @@ export async function readClaudeCode(transcriptPath) {
     let firstPrompt = null;
     let taskUrl = null;
     for (const file of [transcriptPath, ...(await subagentFiles(transcriptPath))]) {
+        let line = -1;
         for await (const e of jsonl(file)) {
+            line++;
             span.add(e.timestamp);
             if (file === transcriptPath) {
                 const prompt = promptText(e);
@@ -40,7 +42,10 @@ export async function readClaudeCode(transcriptPath) {
             const u = m.usage;
             // cache_creation_input_tokens counts both kinds of write; the 1-hour ones cost more.
             const writes1h = num(u.cache_creation?.ephemeral_1h_input_tokens);
-            responses.set(m.id ?? Symbol(), {
+            // The line index counts parsed lines only, which is stable as the file is only appended to.
+            const id = typeof m.id === "string" ? m.id : typeof e.uuid === "string" ? e.uuid : `${file}:${line}`;
+            responses.set(id, {
+                id,
                 model: m.model,
                 tokens: {
                     input: num(u.input_tokens),
@@ -52,14 +57,12 @@ export async function readClaudeCode(transcriptPath) {
             });
         }
     }
-    const tokensByModel = {};
-    for (const { model, tokens } of responses.values()) {
-        tokensByModel[model] = tokensByModel[model] ? addTokens(tokensByModel[model], tokens) : tokens;
-    }
+    const replies = [...responses.values()];
+    const tokensByModel = sumByModel(replies);
     // The session's model is the one that wrote the most.
     let model = null;
     for (const [id, t] of Object.entries(tokensByModel))
         if (model === null || t.output > tokensByModel[model].output)
             model = id;
-    return { model, tokensByModel, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };
+    return { model, tokensByModel, replies, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };
 }

package/dist/agents/codex.js

@@ -1,4 +1,4 @@
-import { addTokens, jsonl, num, Span, ticketUrl } from "./read.js";
+import { jsonl, num, Span, sumByModel, ticketUrl } from "./read.js";
 const zero = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cacheWrite1h: 0 };
 const tokensOf = (u) => ({
     input: Math.max(0, num(u.input_tokens) - num(u.cached_input_tokens) - num(u.cache_write_input_tokens)),
@@ -17,23 +17,22 @@ export async function readCodex(rolloutPath) {
     let latest = zero;
     let latestTotal = 0;
     let latestLast = 0;
-    const byModel = {};
     // Codex 0.148+ writes a token_usage_record per model response, before its token_count; where present they are the usage.
-    let beforeRecords = null;
-    const records = {};
-    const responses = new Set();
+    // Replies from token_count growth come first; a rollout begun on an older Codex and resumed on a newer one keeps those before its first record.
+    const counted = [];
+    let countedBeforeRecords = null;
+    const records = new Map();
     for await (const e of jsonl(rolloutPath)) {
         span.add(e.timestamp);
         const p = e.payload;
         if (e.type === "turn_context" && typeof p?.model === "string")
             model = p.model;
         if (e.type === "token_usage_record" && p?.usage) {
-            // A rollout begun on an older Codex and resumed on a newer one counts its earlier part from token_count.
-            beforeRecords ??= { ...byModel };
-            if (model && !(typeof p.response_id === "string" && responses.has(p.response_id))) {
-                responses.add(p.response_id);
-                records[model] = addTokens(records[model] ?? zero, tokensOf(p.usage));
-            }
+            countedBeforeRecords ??= counted.length;
+            const id = typeof p.response_id === "string" ? p.response_id : `tr:${e.timestamp}:${num(p.usage.total_tokens)}`;
+            // A response id repeated in the rollout counts once, whatever model is in effect.
+            if (model && !(typeof p.response_id === "string" && records.has(id)))
+                records.set(id, { id, model, tokens: tokensOf(p.usage) });
         }
         if (e.type !== "event_msg")
             continue;
@@ -57,14 +56,12 @@ export async function readCodex(rolloutPath) {
         const cur = tokensOf(u);
         // Each event's growth goes to the model it was made with, so a switch mid-session splits the usage.
         const delta = Object.fromEntries(Object.entries(cur).map(([k, v]) => [k, restart ? v : Math.max(0, v - latest[k])]));
-        if (model)
-            byModel[model] = addTokens(byModel[model] ?? zero, delta);
+        if (model && Object.values(delta).some((v) => v > 0))
+            counted.push({ id: `tc:${e.timestamp}:${total}`, model, tokens: delta });
         latestTotal = total;
         latestLast = last;
         latest = cur;
     }
-    if (beforeRecords)
-        for (const [m, t] of Object.entries(records))
-            beforeRecords[m] = addTokens(beforeRecords[m] ?? zero, t);
-    return { model, tokensByModel: beforeRecords ?? byModel, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };
+    const replies = countedBeforeRecords === null ? counted : [...counted.slice(0, countedBeforeRecords), ...records.values()];
+    return { model, tokensByModel: sumByModel(replies), replies, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };
 }

package/dist/agents/opencode.js

@@ -7,7 +7,9 @@ const iso = (ms) => {
 export function readOpenCode(json) {
     const s = (typeof json === "object" && json !== null ? json : {});
     const model = typeof s.model?.id === "string" ? s.model.id : null;
-    const t = s.tokens;
+    const own = s.own && typeof s.own.cost === "number" && Number.isFinite(s.own.cost) && s.own.tokens ? s.own : null;
+    const t = own ? own.tokens : s.tokens;
+    const cost = own ? own.cost : s.cost;
     const tokens = {
         input: num(t?.input),
         // OpenCode counts reasoning apart from output and bills it at the output price.
@@ -19,7 +21,9 @@ export function readOpenCode(json) {
     return {
         model,
         tokensByModel: model && t ? { [model]: tokens } : {},
-        costUsd: typeof s.cost === "number" && Number.isFinite(s.cost) ? s.cost : null,
+        // A session row has no per-reply records.
+        replies: [],
+        costUsd: typeof cost === "number" && Number.isFinite(cost) ? cost : null,
         startedAt: iso(s.time?.created),
         endedAt: iso(s.time?.updated),
         firstPrompt: null,

package/dist/agents/read.js

@@ -74,3 +74,9 @@ export class Span {
             this.last = ts;
     }
 }
+export function sumByModel(replies) {
+    const sums = {};
+    for (const { model, tokens } of replies)
+        sums[model] = sums[model] ? addTokens(sums[model], tokens) : tokens;
+    return sums;
+}

package/dist/args.js

@@ -5,6 +5,8 @@ const config = {
         title: { type: "string" },
         repo: { type: "string" },
         cost: { type: "string" },
+        // Set only by fromTool, from the ledger; not a documented flag.
+        "cost-status": { type: "string" },
         model: { type: "string" },
         plan: { type: "string" },
         task: { type: "string" },

package/dist/commands/body.js

@@ -18,6 +18,7 @@ export function sessionBody(values) {
         title: values.title,
         repository: values.repo,
         cost_usd: number(values, "cost"),
+        cost_status: values["cost-status"],
         model: values.model,
         plan: values.plan,
         task_id: values.task,
@@ -42,6 +43,7 @@ export async function fromTool(tool, values, env, command) {
     if (facts) {
         // Unknown without prices: left out, so a cost already saved stays (report creates a new session at 0).
         filled.cost = facts.costUsd === null ? undefined : String(facts.costUsd);
+        filled["cost-status"] = facts.costStatus ?? undefined;
         filled.model = facts.model ?? values.model;
     }
     const ignored = ["session-id", "cost", "model"].filter((f) => values[f] !== undefined && values[f] !== filled[f]);

package/dist/commands/hook.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { appendFileSync, existsSync, linkSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { findRecord, readClaudeCode, readCodex, readOpenCode, SAFE_ID } from "../agents/index.js";
@@ -7,6 +7,8 @@ import { CliError, request } from "../client.js";
 import { readConfig, stateDir } from "../config.js";
 import { viewPr } from "../gh.js";
 import { gitFacts } from "../git.js";
+import { priceSession, sessionTime } from "../ledger.js";
+import { takeLock } from "../lock.js";
 import { estimateCost, loadPrices } from "../prices.js";
 import { noteRefusal, resolveTeam, teamWarning } from "../team.js";
 import { checkTests } from "../tests/check.js";
@@ -18,7 +20,6 @@ const REPORT_EVENTS = ["Stop", "PreCompact", "SessionEnd"];
 const OPENCODE_EVENTS = ["idle", "compacting"];
 const SESSION_STARTS = ["startup", "resume", "compact", "clear"];
 const MAX_PAYLOAD = 1024 * 1024;
-const LOCK_MS = 60_000;
 const DEADLINE_MS = 15_000;
 const MAX_GH = 5;
 export function inTool(env) {
@@ -30,8 +31,8 @@ export function inTool(env) {
         return { tool: "opencode", sessionId: env.OPENCODE_SESSION_ID };
     return null;
 }
-// The session's facts from the tool's own record, with a cost estimated wherever the tool stores none; the cost stays null when
-// no prices load. Claude Code and Codex name the record in the hook payload; otherwise it is looked up. OpenCode's plugin sends
+// The session's facts from the tool's own record, with a cost priced once per reply in the ledger wherever the tool stores none.
+// The cost and its status stay null when no prices load, the ledger is busy or its backfill is unfinished. Claude Code and Codex name the record in the hook payload; otherwise it is looked up. OpenCode's plugin sends
 // the session itself too, used only without a saved record. Null without a record.
 export async function sessionFacts(tool, sessionId, env, payload = {}) {
     let facts;
@@ -53,10 +54,22 @@ export async function sessionFacts(tool, sessionId, env, payload = {}) {
     // Codex's payload names the model the session runs on now.
     if (tool === "codex" && typeof payload.model === "string" && payload.model)
         facts = { ...facts, model: payload.model };
-    if (facts.costUsd !== null)
-        return facts;
     const prices = await loadPrices(env);
-    return prices ? { ...facts, costUsd: estimateCost(facts.tokensByModel, prices).costUsd } : facts;
+    // OpenCode stays out of the ledger: its own figure, else an estimate. A 0 is a session nobody priced.
+    if (tool === "opencode") {
+        if (facts.costUsd !== null)
+            return { ...facts, costStatus: facts.costUsd > 0 ? "exact" : "unknown" };
+        if (!prices)
+            return { ...facts, costStatus: null };
+        const { costUsd, unpriced } = estimateCost(facts.tokensByModel, prices);
+        // As in the ledger: partial while some model has no price.
+        return { ...facts, costUsd, costStatus: costUsd === 0 ? "unknown" : unpriced.length ? "partial" : "exact" };
+    }
+    if (!prices || !file)
+        return { ...facts, costStatus: null };
+    // The record file's creation time, not the first entry's: the backfill orders sessions by it too.
+    const priced = await priceSession(env, { id: sessionId, startedAt: await sessionTime(file, facts.startedAt) }, facts.replies, prices);
+    return { ...facts, costUsd: priced?.costUsd ?? null, costStatus: priced?.status ?? null };
 }
 // The first prompt's first line cut to 80 characters, else the branch. The repository is the last resort: a new session needs a title.
 export function derivedTitle(firstPrompt, git) {
@@ -169,49 +182,6 @@ async function child(tool, file, env) {
         clearTimeout(timer);
     }
 }
-// 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;
-    }
-}
 // Only the fields the machine knows. The task, PRs, coverage, evidence, project, an existing title and the plan are the agent's.
 async function send(tool, file, env) {
     const payload = JSON.parse(await readFile(file, "utf8"));
@@ -249,6 +219,7 @@ async function send(tool, file, env) {
     const body = {
         // Unknown without prices: left out, so a cost already saved stays.
         cost_usd: facts.costUsd ?? undefined,
+        cost_status: facts.costStatus ?? undefined,
         model: facts.model ?? undefined,
         commits: git.commits ?? undefined,
         started_at: facts.startedAt ?? undefined,

package/dist/commands/report.js

@@ -21,6 +21,8 @@ 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"];
@@ -43,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 {
@@ -56,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,5 +1,5 @@
 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);
@@ -13,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],

package/dist/commands/sessions.js

@@ -1,14 +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/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/upgrade.js

@@ -81,7 +81,7 @@ const sameAs = (path, text) => {
 const HOOK_CHANGE = {
     "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) {

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` : "");

package/dist/upload.js

@@ -74,6 +74,7 @@ async function uploadOne(cfg, sessionId, file, budget) {
         size_bytes: size,
         sha256: hash.digest("hex"),
         caption: file.caption,
+        path_label: file.path_label,
     }, budget);
     const id = json.evidence.id;
     if (json.status === "exists")

package/opencode/berliner.js

@@ -10,7 +10,10 @@
 // - client.session.get({ path: { id } }) returns { data } with the server's Session, which holds cost, tokens and model,
 //   so the messages are not needed;
 // - subagents run in child sessions (parentID set), each with its own cost and tokens, and
-//   client.session.children({ path: { id } }) returns { data } with a session's direct children.
+//   client.session.children({ path: { id } }) returns { data } with a session's direct children;
+// - client.session.messages({ path: { id } }) returns { data }, an array of { info, parts } (sdk/js/src/gen/types.gen.ts at
+//   v1.18.30: SessionMessagesData; an assistant info has role, time.created, cost and tokens). A fork's session row counts
+//   its parent's usage too, and its copied messages keep the parent's time.created, so `own` counts only newer ones.
 import { spawn } from "node:child_process";
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -37,13 +40,50 @@ async function topLevelId(client, id) {
   return session && !session.parentID ? session.id : null;
 }
 
+const sum = (a, b) => ({
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: { read: a.tokens.cache.read + b.tokens.cache.read, write: a.tokens.cache.write + b.tokens.cache.write },
+  },
+  cost: a.cost + b.cost,
+});
+const zero = () => ({ tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, cost: 0 });
+
+// What the session itself used: its assistant messages created at or after the session was. null when they can't be listed.
+async function ownUsage(client, session) {
+  try {
+    const messages = (await within(client.session.messages({ path: { id: session.id } }), 5000))?.data;
+    if (!Array.isArray(messages)) return null;
+    let own = zero();
+    for (const { info: m } of messages) {
+      if (m?.role !== "assistant" || num(m.time?.created) < num(session.time?.created)) continue;
+      const t = m.tokens;
+      own = sum(own, {
+        tokens: {
+          input: num(t?.input),
+          output: num(t?.output),
+          reasoning: num(t?.reasoning),
+          cache: { read: num(t?.cache?.read), write: num(t?.cache?.write) },
+        },
+        cost: num(m.cost),
+      });
+    }
+    return own;
+  } catch {
+    return null;
+  }
+}
+
 // The session with its subagents' cost and tokens added in, in the shape the CLI reads. OpenCode 1.18.30 keeps them apart:
 // a session's cost and tokens grow only from its own step-finish parts (packages/core/src/session/projector.ts:310-326,
 // applyUsage on the part's own sessionID, lines 89-109), and a live run with one task-tool subagent gave the parent 0.215
 // and the child 1.05.
 async function withChildren(client, session, depth = 0) {
   const children = depth < MAX_DEPTH ? (await client.session.children({ path: { id: session.id } }))?.data : null;
-  if (!Array.isArray(children) || children.length === 0) return session;
+  const mine = await ownUsage(client, session);
+  if (!Array.isArray(children) || children.length === 0) return mine ? { ...session, own: mine } : session;
   const t = session.tokens;
   let cost = num(session.cost);
   const tokens = {
@@ -52,7 +92,9 @@ async function withChildren(client, session, depth = 0) {
     reasoning: num(t?.reasoning),
     cache: { read: num(t?.cache?.read), write: num(t?.cache?.write) },
   };
+  let own = mine;
   for (const c of await Promise.all(children.map((child) => withChildren(client, child, depth + 1)))) {
+    own = own && c.own ? sum(own, c.own) : null;
     cost += num(c.cost);
     tokens.input += num(c.tokens?.input);
     tokens.output += num(c.tokens?.output);
@@ -60,7 +102,7 @@ async function withChildren(client, session, depth = 0) {
     tokens.cache.read += num(c.tokens?.cache?.read);
     tokens.cache.write += num(c.tokens?.cache?.write);
   }
-  return { ...session, cost, tokens };
+  return { ...session, cost, tokens, ...(own && { own }) };
 }
 
 // Each save's place in the order saves started, and per session the latest one written: a save that finishes after a later

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paxnax/berliner",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Report coding-agent sessions to Berliner",
   "keywords": [
     "claude-code",

package/skill/SKILL.md

@@ -146,7 +146,7 @@ Report again with the same `--session-id` whenever something changes.
 - `--commits <n>` (outside the tools; the hooks count them): `git rev-list --count <base>..HEAD`
 - `--coverage <percent>`: from the test run's coverage summary.
 - `--pr <url>[,merge=<open|merged|closed>][,ci=<pending|running|passed|failed|none>]`: repeat per PR. URL from `gh pr view --json url`.
-- `--evidence <path>[::caption]`: repeat per screenshot or video.
+- `--evidence <path>[::caption[::happy|unhappy|edge]]`: repeat per screenshot or video; the optional last part says whether it shows the happy path, an unhappy path or an edge case. A caption can't contain `::`.
 - `--public`: with `--evidence`, also make those files viewable without sign-in. See below.
 - `--task <id>`, `--task-url <url>`: the ticket. See [Tickets](#tickets).
 - `--project <name>`: only the ticket's tracker project or a project the user named. See [Projects](#projects).