@paxnax/berliner 0.6.0 → 0.8.0

package/README.md

@@ -21,7 +21,7 @@ With Bun, run `bunx --bun @paxnax/berliner@latest setup`. To install only the co
    npx @paxnax/berliner@latest setup
    ```
 
-   It shows what it will do and asks once, then opens your browser so you can approve the connection. After you approve, it saves the token, installs the CLI globally, and installs the agent skill and a reporting hook for each of Claude Code, Codex and OpenCode that it finds. `--yes` skips the question, `--no-install` skips the global install, and `--no-browser` only prints the URL (over SSH, for example). Run `berliner upgrade` to update the CLI, the skill and any Berliner hook an older setup installed to the latest release: it shows its plan and asks first, and a second question (or `--no-skill`) keeps your skill as it is.
+   It shows what it will do and asks once, then opens your browser so you can approve the connection. After you approve, it saves the token, installs the CLI globally, and installs the agent skill and a reporting hook for each of Claude Code, Codex and OpenCode that it finds. `--yes` skips the question, `--no-install` skips the global install, and `--no-browser` only prints the URL (over SSH, for example). Run `berliner upgrade` to update the CLI, the skill and any Berliner hook an older setup installed to the latest release: it shows its plan and asks first, and a second question (or `--no-skill`) keeps your skill as it is. Once a day, the first `berliner` command or agent session start checks for a newer release and says so.
 
 3. From then on, the hooks report each session's cost, model, repository, commits and start and end times after every reply. They also fill in a ticket from a Linear or Jira URL in your prompts while the session has none, and refresh up to 5 open pull requests the Berliner GitHub App doesn't track with your `gh` (skipped when `gh` is missing or signed out). When a session starts, the hook reminds your agent to name the session and report its ticket. Your agent adds the title, ticket, pull requests, coverage and evidence with `berliner report` and `berliner update`, as the skill tells it to. Codex runs a new hook only once you trust it: open `codex` once in a terminal and trust the Berliner hook.
 4. On **Settings**, list the subscriptions you pay for. Overview then compares each one with the sessions that ran on it.
@@ -121,7 +121,7 @@ Other commands:
 - `berliner delete <session-id>`: delete a session, or one item with `--evidence <id>`. Asks to confirm unless `--yes`.
 - `berliner evidence public <id>`: let anyone with the link view one file, and print its public URL and Markdown line. `berliner evidence private <id>` makes it private again. `berliner session` shows the ids, and the URL of each public file.
 - `berliner skill`: print the agent skill (`SKILL.md`) to install in your agent.
-- `berliner upgrade [--yes] [--no-skill]`: install the latest CLI and skill. It shows its plan (the versions, the exact install command, each skill file and each Berliner hook it updates) and asks before changing anything; a second question, or `--no-skill`, leaves your skill as it is. It brings a Berliner hook an older setup installed up to date, but never adds one; your token and config are never touched.
+- `berliner upgrade [--yes] [--no-skill] [--no-hooks]`: install the latest CLI and skill. It shows its plan (the versions, the exact install command, each skill file and each Berliner hook it updates) and asks before changing anything; a second question, or `--no-skill`, leaves your skill as it is, and `--no-hooks` leaves your hooks as they are. It brings a Berliner hook an older setup installed up to date, but never adds one; your token and config are never touched. When it updated a skill or hook, its last line names the tools to start a new session in so they load it.
 - `berliner hook <tool>`: run by the hooks setup installs, with the tool's payload on stdin. It never fails and never makes the agent wait, and prints only the reminder when a session starts; errors go to `${XDG_STATE_HOME:-~/.local/state}/berliner/hook.log`.
 
 `report` and `update` exit 0 even when something fails, printing a warning that starts with `berliner:` to stderr, so reporting never breaks an agent's pipeline. Pass `--strict` to make them exit 1 on failure, including a file that could not be uploaded or made public; the session is still saved. The other commands exit 1 on failure.

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" },
@@ -26,6 +28,7 @@ const config = {
         "no-install": { type: "boolean" },
         "no-browser": { type: "boolean" },
         "no-skill": { type: "boolean" },
+        "no-hooks": { type: "boolean" },
         none: { type: "boolean" },
         all: { type: "boolean" },
         run: { 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,10 +7,13 @@ 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";
 import { nudge } from "../tests/nudge.js";
+import { upgradeNotice } from "../version.js";
 // Same text in the OpenCode plugin (cli/opencode/berliner.js).
 const REMINDER = 'This session reports to Berliner. Once you know the task, name it: berliner update --title "<short title>". When a Linear or Jira ticket comes up, report it: berliner update --task <ID> --task-url <URL>. Before your final message, run berliner report with the PRs.';
 const TOOLS = ["claude-code", "codex", "opencode"];
@@ -18,7 +21,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 +32,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 +55,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) {
@@ -90,9 +104,11 @@ async function start(tool, env) {
     }
     else {
         // In the agent's context from the start, whether or not the skill triggers; after a compaction or /clear it may have lost
-        // the task and PRs it hasn't reported yet.
-        if (p.hook_event_name === "SessionStart" && SESSION_STARTS.includes(p.source))
-            return console.log(REMINDER);
+        // the task and PRs it hasn't reported yet. The day's upgrade check goes with it, so the agent can tell the user.
+        if (p.hook_event_name === "SessionStart" && SESSION_STARTS.includes(p.source)) {
+            const notice = await upgradeNotice(env);
+            return console.log(notice ? `${REMINDER}\n${notice}` : REMINDER);
+        }
         if (!REPORT_EVENTS.includes(p.hook_event_name))
             return;
         id = p.session_id;
@@ -169,49 +185,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 +222,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

@@ -6,24 +6,9 @@ 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 { currentVersion, latestVersion, newer, registryOf } from "../version.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) {
-    const registry = registryOf(env);
-    try {
-        const res = await fetch(`${registry}/@paxnax/berliner/latest`);
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        const { version } = (await res.json());
-        if (typeof version !== "string")
-            throw new Error("no version in the reply");
-        return version;
-    }
-    catch (err) {
-        throw new CliError(`Could not look up the latest berliner on ${registry} (${err.message}). Nothing was changed.`, "network");
-    }
-}
 // The skill and the OpenCode plugin come from the release being installed, so the plan's "already up to date" and what is
 // written match it. They are read out of the release tarball as data: running the release (npx) would load the cwd's .npmrc
 // and node_modules.
@@ -63,12 +48,6 @@ async function releaseFiles(version, bundled, env) {
         throw new CliError(`Could not read the skill and OpenCode plugin of berliner ${version} (${err.message}). Nothing was changed.`, "network");
     }
 }
-// Release versions only (x.y.z): the registry's latest tag never points at a prerelease.
-const newer = (a, b) => {
-    const [x, y] = [a, b].map((v) => v.split("-")[0].split(".").map(Number));
-    const i = x.findIndex((n, j) => n !== y[j]);
-    return i >= 0 && x[i] > y[i];
-};
 const sameAs = (path, text) => {
     try {
         return readFileSync(path, "utf8") === text;
@@ -81,11 +60,11 @@ 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) {
-    const current = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+    const current = currentVersion();
     const latest = await latestVersion(env);
     // A CLI ahead of the registry (a local build, a release still propagating) is never taken backwards, nor is its skill.
     const installing = newer(latest, current);
@@ -94,11 +73,12 @@ export async function upgrade(env, values) {
     const tools = detectTools(env);
     const targets = values["no-skill"] ? [] : skillTargets(tools, env);
     // The plugin too, so --no-skill still brings it up to date.
-    const release = targets.length || tools.some((t) => t.id === "opencode" && t.found) ? await releaseFiles(target, !installing, env) : null;
+    const plugin = !values["no-hooks"] && tools.some((t) => t.id === "opencode" && t.found);
+    const release = targets.length || plugin ? await releaseFiles(target, !installing, env) : null;
     const skill = release?.skill ?? "";
     let stale = targets.filter((t) => !sameAs(t.path, skill));
     // Computed now, for the plan.
-    const hooks = tools.flatMap((tool) => {
+    const hooks = (values["no-hooks"] ? [] : tools).flatMap((tool) => {
         const path = hookPath(tool.id, env);
         const text = updatedHooks(tool.id, path, release?.plugin);
         return text === null ? [] : [{ ...tool, path, text }];
@@ -126,13 +106,15 @@ export async function upgrade(env, values) {
                     return `${tool.name.padEnd(14)}${where}`;
                 }),
             },
-        ...(hooks.length
-            ? [{ label: "Update the Berliner hook for:", detail: hooks.map((h) => `${h.name.padEnd(14)}${tilde(h.path)} (${HOOK_CHANGE[h.id]})`) }]
-            : []),
+        ...(values["no-hooks"]
+            ? [{ label: "Leave the Berliner hooks as they are (--no-hooks)", detail: [] }]
+            : hooks.length
+                ? [{ label: "Update the Berliner hook for:", detail: hooks.map((h) => `${h.name.padEnd(14)}${tilde(h.path)} (${HOOK_CHANGE[h.id]})`) }]
+                : []),
     ]);
     if (!values.yes) {
         if (!process.stdin.isTTY)
-            throw new CliError("There is no terminal to ask on. Run upgrade again with --yes to continue without asking.", "usage");
+            throw new CliError("There is no terminal to ask on, so nothing was changed. To go ahead without asking, run upgrade again with --yes. If you are an AI agent, show the user this plan and get their approval first.", "usage");
         if (!(await confirm(process.stdin, process.stdout)))
             throw new CliError("Cancelled. Nothing was changed.", "usage");
         // Without an install, the skill is all Continue covered.
@@ -152,12 +134,15 @@ export async function upgrade(env, values) {
     }
     // A file that can't be written (read-only, say) is reported and skipped, so the other tools still get theirs.
     let unwritten = false;
+    // The tools that load what was written, for the reload line.
+    const reload = { skill: new Set(), hooks: new Set() };
     for (const t of stale) {
         const what = `${tools.find((tool) => tool.id === t.tool).name} skill`;
         try {
             mkdirSync(dirname(t.path), { recursive: true });
             writeFileSync(t.path, skill);
             console.log(`✓ ${what}: ${tilde(t.path)}`);
+            reload.skill.add(t.tool);
         }
         catch (err) {
             unwritten = true;
@@ -175,11 +160,16 @@ export async function upgrade(env, values) {
             // In place, so a settings file that is a symlink stays one.
             writeFileSync(h.path, text);
             console.log(`✓ ${h.name} hook: ${tilde(h.path)}`);
+            reload.hooks.add(h.id);
         }
         catch (err) {
             unwritten = true;
             console.error(`✗ ${h.name} hook: ${tilde(h.path)} can't be written (${err.message.split(",")[0]})`);
         }
     }
-    console.log(unwritten ? "\nSome files can't be written. Fix the ones marked ✗ above, then run upgrade again." : "\nDone.");
+    // A running agent keeps the skill and hooks it started with; the command itself is new from the next call.
+    const names = tools.filter((t) => reload.skill.has(t.id) || reload.hooks.has(t.id)).map((t) => t.name);
+    const what = [reload.skill.size && "skill", reload.hooks.size && "hooks"].filter(Boolean).join(" and ");
+    const again = names.length ? ` Start a new session in ${names.join(", ").replace(/, ([^,]*)$/, " and $1")} to load the updated ${what}.` : "";
+    console.log(unwritten ? `\nSome files can't be written. Fix the ones marked ✗ above, then run upgrade again.${again}` : `\nDone.${again}`);
 }

package/dist/index.js

@@ -19,6 +19,7 @@ import { update } from "./commands/update.js";
 import { upgrade } from "./commands/upgrade.js";
 import { readConfig } from "./config.js";
 import { warn } from "./output.js";
+import { upgradeNotice } from "./version.js";
 const usage = `Usage: berliner <command> [flags]
 
 Commands:
@@ -43,7 +44,7 @@ Commands:
   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]
-  upgrade               install the latest CLI and skill [--yes --no-skill]
+  upgrade               install the latest CLI, skill and hooks [--yes --no-skill --no-hooks]
   skill                 print the bundled SKILL.md
   hook <tool>           run by the hooks of claude-code, codex or opencode; reads the payload on stdin
 
@@ -114,3 +115,9 @@ catch (err) {
         console.error(usage);
     process.exitCode = softFail ? 0 : 1;
 }
+// The hook carries it in the session-start reminder instead, and upgrade looks for itself.
+if (args.command !== "hook" && args.command !== "upgrade") {
+    const notice = await upgradeNotice(process.env);
+    if (notice)
+        console.error(notice);
+}

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/dist/version.js

@@ -0,0 +1,54 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "./client.js";
+import { stateDir } from "./config.js";
+export const registryOf = (env) => (env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
+export const currentVersion = () => JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export async function latestVersion(env, timeoutMs) {
+    const registry = registryOf(env);
+    try {
+        const res = await fetch(`${registry}/@paxnax/berliner/latest`, { signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const { version } = (await res.json());
+        if (typeof version !== "string")
+            throw new Error("no version in the reply");
+        return version;
+    }
+    catch (err) {
+        throw new CliError(`Could not look up the latest berliner on ${registry} (${err.message}). Nothing was changed.`, "network");
+    }
+}
+// Release versions only (x.y.z): the registry's latest tag never points at a prerelease.
+export const newer = (a, b) => {
+    const [x, y] = [a, b].map((v) => v.split("-")[0].split(".").map(Number));
+    const i = x.findIndex((n, j) => n !== y[j]);
+    return i >= 0 && x[i] > y[i];
+};
+const DAY_MS = 24 * 3600_000;
+// Short, as it runs inline: the first command or session start of the day waits for it.
+const CHECK_TIMEOUT_MS = 1500;
+// Once a day per machine: the check file's mtime is when the last check started. A failed check counts too, so an
+// offline machine doesn't wait on every run. Never throws; null unless the registry has a newer release.
+export async function upgradeNotice(env) {
+    const stamp = join(stateDir(env), "version-check");
+    try {
+        if (Date.now() - statSync(stamp).mtimeMs < DAY_MS)
+            return null;
+    }
+    catch {
+        // Never checked on this machine.
+    }
+    try {
+        // Before the lookup, so runs started meanwhile don't check again.
+        mkdirSync(stateDir(env), { recursive: true, mode: 0o700 });
+        writeFileSync(stamp, "");
+        const latest = await latestVersion(env, CHECK_TIMEOUT_MS);
+        if (!newer(latest, currentVersion()))
+            return null;
+        return `New berliner CLI version ${latest} is out, run berliner upgrade to update it. If you are an AI agent, bring this to the user for approval instead of taking action yourself.`;
+    }
+    catch {
+        return null;
+    }
+}

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.8.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).
@@ -171,6 +171,23 @@ After the evidence line, it prints one line per file: `![Login page after the fi
 
 If the `berliner` command is not found, carry on with your work and say in your final message that `npx @paxnax/berliner@latest setup` needs to run. Do not try to install it yourself.
 
+## When a newer berliner is out
+
+Once a day the CLI checks for a newer release. When there is one, the session-start reminder or a `berliner` command's output says: `New berliner CLI version X.Y.Z is out, run berliner upgrade to update it. If you are an AI agent, bring this to the user for approval instead of taking action yourself.` Never upgrade on your own:
+
+1. Run `berliner upgrade` with no flags. Without a terminal it prints its plan and stops, changing nothing.
+2. Show the user the plan, then ask them to approve each part separately: the berliner command, the skill and the hooks.
+3. If they decline the command, run nothing. Otherwise run the command that matches their answers. It never stops to ask:
+
+| Skill | Hooks | Command |
+|---|---|---|
+| yes | yes | `berliner upgrade --yes` |
+| no | yes | `berliner upgrade --yes --no-skill` |
+| yes | no | `berliner upgrade --yes --no-hooks` |
+| no | no | `berliner upgrade --yes --no-skill --no-hooks` |
+
+4. Pass on the upgrade's last line. When it names tools to start a new session in, tell the user the updated skill or hooks load only in a new session there.
+
 ## Timeouts
 
 The session is saved first, then evidence is uploaded. Allow at least 10 minutes for the command when attaching videos.