@paxnax/berliner 0.5.3 → 0.7.0

package/README.md

@@ -117,6 +117,7 @@ Other commands:
 - `berliner summary [filters]`: totals for the same filters as `sessions`, then one line per subscription.
 - `berliner projects [--json]`: the project names in use, then each repository's default project.
 - `berliner project [<name>] [--none] [--repo owner/name] [--json]`: with no name, show this repository's default project; with a name, save it; `--none` saves that the repository has no project. The repository comes from `git remote get-url origin` unless you pass `--repo`. A session's project is its own `--project`, else its repository's default, else its ticket's prefix (`SMTNC-3268` gives `SMTNC`). Until a repository has a default, `report` and `update` print a `Project: none saved` line, which asks your agent to suggest one to you.
+- `berliner team [<uuid>] [--none]`: with no argument, print the team your sessions report to and where it came from; with a uuid, save it for this machine; `--none` clears it. A session reports to a team, or to your own plan, from the first of these that is set: `--team <uuid>` or `--no-team` on `report` and `update`, `team` in `.berliner.json` at the repository root (`{ "team": "<uuid>" }`, meant to be committed so the whole team shares it), `BERLINER_TEAM`, then the saved setting. `--no-team` beats all of them. Only the report that creates a session sends the team; it stays fixed after that, and a later setting that differs prints a warning. The server refuses a team report with `team_not_found`, `team_not_member`, `team_not_eligible` (the repository's owner is not an organization the team covers) or `team_inactive` (the team has no active plan), and the message says how to fix it. Inside Claude Code, Codex or OpenCode the hook cannot print, so the next `berliner report`, `update`, `session` or `sessions` in that repository prints it once. The team's owner sees every session and file reported to the team; members never see each other's.
 - `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.

package/dist/agents/claude.js

@@ -1,8 +1,8 @@
 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.
-async function subagentFiles(transcriptPath) {
+export async function subagentFiles(transcriptPath) {
     const dir = join(transcriptPath.replace(/\.jsonl$/, ""), "subagents");
     const names = await readdir(dir).catch(() => []);
     return names
@@ -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

@@ -1,18 +1,54 @@
 import { createReadStream } from "node:fs";
+import { open } from "node:fs/promises";
 import { createInterface } from "node:readline";
-// One object per line, streamed. A line that doesn't parse (one cut off mid-write, say) is skipped.
+// A line that doesn't parse (one cut off mid-write, say) is skipped.
+function parseLine(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    return typeof value === "object" && value !== null ? value : null;
+}
+// One object per line, streamed.
 export async function* jsonl(path) {
     for await (const line of createInterface({ input: createReadStream(path), crlfDelay: Infinity })) {
-        let value;
-        try {
-            value = JSON.parse(line);
-        }
-        catch {
-            continue;
+        const value = parseLine(line);
+        if (value)
+            yield value;
+    }
+}
+// The same, last line first, read from the end in chunks: the latest entries of a large file without reading all of it.
+export async function* jsonlBackward(path) {
+    const file = await open(path, "r");
+    try {
+        let pos = (await file.stat()).size;
+        // The start of the line after this chunk, kept as pieces so a long line isn't copied once per chunk.
+        let carry = [];
+        while (pos > 0) {
+            const size = Math.min(64 * 1024, pos);
+            pos -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, pos);
+            let end = size;
+            for (let nl = chunk.lastIndexOf(10); nl >= 0; nl = chunk.subarray(0, end).lastIndexOf(10)) {
+                const value = parseLine(Buffer.concat([chunk.subarray(nl + 1, end), ...carry]).toString());
+                carry = [];
+                end = nl;
+                if (value)
+                    yield value;
+            }
+            carry.unshift(chunk.subarray(0, end));
         }
-        if (typeof value === "object" && value !== null)
+        const value = parseLine(Buffer.concat(carry).toString());
+        if (value)
             yield value;
     }
+    finally {
+        await file.close();
+    }
 }
 // Full issue URLs only: a bare ID is ambiguous (UTF-8). Cut at the ID, so a slug or query never follows it.
 const TICKET_URL = /https?:\/\/(?:linear\.app\/[\w-]+\/issue|[\w-]+\.atlassian\.net\/browse)\/[A-Za-z][A-Za-z0-9]*-\d+\b/;
@@ -38,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,11 +5,15 @@ 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" },
         "task-url": { type: "string" },
         project: { type: "string" },
+        team: { type: "string" },
+        "no-team": { type: "boolean" },
         "started-at": { type: "string" },
         "ended-at": { type: "string" },
         commits: { type: "string" },
@@ -25,6 +29,7 @@ const config = {
         "no-browser": { type: "boolean" },
         "no-skill": { type: "boolean" },
         none: { type: "boolean" },
+        all: { type: "boolean" },
         run: { type: "string" },
         ci: { type: "string" },
         merge: { type: "string" },

package/dist/client.js

@@ -2,11 +2,13 @@ export class CliError extends Error {
     kind;
     status;
     details;
-    constructor(message, kind, status, details) {
+    code;
+    constructor(message, kind, status, details, code) {
         super(message);
         this.kind = kind;
         this.status = status;
         this.details = details;
+        this.code = code;
     }
 }
 export const absolute = (cfg, path) => cfg.url.replace(/\/+$/, "") + path;
@@ -49,7 +51,7 @@ export async function request(cfg, method, path, body, opts = {}) {
         const json = await res.json().catch(() => null);
         if (!res.ok) {
             const err = json;
-            throw new CliError(errorMessage(method, path, res.status, err), "http", res.status, err?.error?.details);
+            throw new CliError(errorMessage(method, path, res.status, err), "http", res.status, err?.error?.details, typeof err?.error?.code === "string" ? err.error.code : undefined);
         }
         return { status: res.status, json: json };
     }

package/dist/commands/body.js

@@ -1,7 +1,14 @@
 import { CliError, request } from "../client.js";
 import { gitFacts } from "../git.js";
 import { warn } from "../output.js";
+import { teamWarning } from "../team.js";
 import { derivedTitle, sessionFacts } from "./hook.js";
+// One line when the session is on another plan than the settings now say.
+export function warnTeam(session, team) {
+    const text = teamWarning(session.team, team);
+    if (text)
+        warn(text);
+}
 export const projectHint = (s) => s.repository_project_set === false && s.project_source !== "session"
     ? `\nProject: none saved for ${s.repository}. Suggest one to the user, then save it with: berliner project "<name>"`
     : "";
@@ -11,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,
@@ -35,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]);
@@ -51,7 +60,7 @@ export async function fromTool(tool, values, env, command) {
 // Inside a tool: the same fields, minus a derived title, for a session that exists; on a 404 (the first turn, before the hook
 // has reported), the PUT that creates it, at cost 0 while the cost is unknown and on BERLINER_PLAN when no plan is given.
 // Create-only: when another report created the session since the 404 (412), the PATCH after all, so its title and cost stay.
-export async function patchFirst(cfg, path, body, titled, guess) {
+export async function patchFirst(cfg, path, body, titled, guess, team = null) {
     const patch = async () => {
         const res = await saveSession(cfg, "PATCH", path, titled ? body : { ...body, title: undefined }, guess);
         return { ...res, json: { created: false, ...res.json } };
@@ -62,7 +71,7 @@ export async function patchFirst(cfg, path, body, titled, guess) {
     catch (err) {
         if (!(err instanceof CliError && err.status === 404))
             throw err;
-        const create = { ...body, cost_usd: body.cost_usd ?? 0, plan: body.plan ?? cfg.plan ?? undefined };
+        const create = { ...body, cost_usd: body.cost_usd ?? 0, plan: body.plan ?? cfg.plan ?? undefined, team: team ?? undefined };
         return saveSession(cfg, "PUT", path, create, guess, { "If-None-Match": "*" }).catch((err) => {
             if (err instanceof CliError && err.status === 412)
                 return patch();

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,7 +7,12 @@ 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";
 // 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"];
@@ -15,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) {
@@ -27,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;
@@ -50,17 +54,29 @@ 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) {
     const line = firstPrompt?.split("\n")[0].trim();
     return (line && Array.from(line).slice(0, 80).join("")) || git.branch || git.repository;
 }
-// `berliner hook <tool>` runs inside the agent tool: it never prints (bar the reminder), never fails and never makes the agent
+// `berliner hook <tool>` runs inside the agent tool: it never prints (bar the reminder and the test nudge), never fails and never makes the agent
 // wait. The work happens in a detached child (`--run`), and every error goes to hook.log.
 export async function hook(env, positionals, values) {
     const tool = positionals[0];
@@ -97,6 +113,17 @@ async function start(tool, env) {
     // The id names the payload file.
     if (typeof id !== "string" || !SAFE_ID.test(id))
         throw new Error("the payload has no usable session id");
+    // Before the report: the note has to reach the agent while its turn can still continue. It never stops the report.
+    if (p.hook_event_name === "Stop") {
+        try {
+            const line = await nudge(tool, { ...p, session_id: id }, env);
+            if (line)
+                console.log(line);
+        }
+        catch (err) {
+            log(env, `${tool} ${id}: nudge: ${err.message}`);
+        }
+    }
     const dir = join(stateDir(env), "hook");
     // Payloads name the user's projects and sessions: only the user may read them.
     mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -155,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"));
@@ -212,9 +196,30 @@ async function send(tool, file, env) {
     // The repository is required, and it is how Berliner groups work.
     if (!git.repository)
         throw new Error(`no GitHub repository at ${cwd}, not reported`);
+    const repository = git.repository;
+    // A bad .berliner.json throws: logged, and the report waits for it to be fixed.
+    const team = (await resolveTeam({}, cwd, env)) ?? undefined;
+    // The full check, whatever the nudge's opt-out. Nothing to check sends nulls, which clear an earlier verdict. A check that
+    // throws (logged) or runs out of time leaves the four fields out, so the stored verdict stays. OpenCode's payload has no
+    // transcript.
+    const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : "";
+    const deadline = Date.now() + 5000;
+    const check = transcriptPath
+        ? await checkTests({ tool, transcriptPath, cwd, startedAt: facts.startedAt, deadline }).then(
+        // checkTests also gives null when time runs out. A git call killed by its timeout can return a few ms before the
+        // wall clock reaches the deadline, hence the margin: a null that close to it is taken as a timeout.
+        (c) => c ?? (Date.now() >= deadline - 50 ? undefined : null), (err) => {
+            log(env, `${tool} ${sessionId}: test check: ${err.message}`);
+            return undefined;
+        })
+        : null;
+    const tests = check === undefined
+        ? {}
+        : { test_check: check?.verdict ?? null, test_command: check?.command ?? null, head_sha: check?.headSha ?? null, tree_clean: check?.treeClean ?? false };
     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,
@@ -223,6 +228,7 @@ async function send(tool, file, env) {
         // The server only fills an empty ticket with these: the agent's own always wins. The URL ends in the ticket's ID.
         detected_task_id: facts.taskUrl?.split("/").pop(),
         detected_task_url: facts.taskUrl ?? undefined,
+        ...tests,
     };
     const cfg = readConfig(env);
     const path = `/v1/sessions/${encodeURIComponent(sessionId)}`;
@@ -236,9 +242,12 @@ async function send(tool, file, env) {
         // The plan is BERLINER_PLAN from the tool's environment, else the server's pick from the user's subscriptions. A new
         // session needs a cost: 0 until prices load. Create-only: when an agent report created the session since the 404 (412),
         // only the machine's fields are sent. A server that ignores the header overwrites the title, as before.
-        const create = (plan) => request(cfg, "PUT", path, { ...body, cost_usd: body.cost_usd ?? 0, title: derivedTitle(facts.firstPrompt, git), plan }, { headers: { "If-None-Match": "*" } }).catch((err) => {
+        const create = (plan) => request(cfg, "PUT", path, { ...body, cost_usd: body.cost_usd ?? 0, title: derivedTitle(facts.firstPrompt, git), plan, team }, { headers: { "If-None-Match": "*" } }).catch((err) => {
             if (err instanceof CliError && err.status === 412)
                 return request(cfg, "PATCH", path, body);
+            // Never a personal session instead: the next foreground command in this repository prints the refusal.
+            if (err instanceof CliError && err.status === 422 && err.code?.startsWith("team_"))
+                noteRefusal(env, repository, err.message);
             throw err;
         });
         try {
@@ -252,6 +261,9 @@ async function send(tool, file, env) {
             log(env, `${tool} ${sessionId}: BERLINER_PLAN "${cfg.plan}" is not a plan; the server picked the plan`);
         }
     }
+    const mismatch = teamWarning(saved.json.session.team, team ?? null);
+    if (mismatch)
+        log(env, `${tool} ${sessionId}: ${mismatch}`);
     await refreshPrs(cfg, path, saved.json.session.prs, env, `${tool} ${sessionId}`);
 }
 // Untracked PRs keep their last reported state, so the machine's gh refreshes the open ones; the poller owns tracked PRs.
@@ -266,7 +278,7 @@ async function refreshPrs(cfg, path, prs, env, where) {
     })));
     const changed = open.flatMap((p, i) => {
         const s = seen[i];
-        return s && (s.merge_state !== p.merge_state || s.ci_state !== p.ci_state) ? [{ url: p.url, ...s }] : [];
+        return s && (s.merge_state !== p.merge_state || s.ci_state !== p.ci_state || s.head_sha !== p.head_sha) ? [{ url: p.url, ...s }] : [];
     });
     if (changed.length)
         await request(cfg, "PATCH", path, { prs: changed });

package/dist/commands/nudge.js

@@ -0,0 +1,64 @@
+import { execFileSync } from "node:child_process";
+import { CliError } from "../client.js";
+import { readConfigFile, saveConfig } from "../config.js";
+import { print } from "../output.js";
+import { confirm } from "./setup.js";
+// Plain synchronous read for the Stop hook's time budget; an unreadable config reads as enabled.
+export function nudgeEnabled(env, repoRoot) {
+    const nudge = readConfigFile(env)?.nudge;
+    return !(nudge?.off_all || nudge?.off?.includes(repoRoot));
+}
+// Keeps whether the question was asked, whatever the new setting.
+function save(env, nudge) {
+    const file = readConfigFile(env);
+    saveConfig(env, { ...file, nudge: { ...(file?.nudge?.asked && { asked: true }), ...nudge } });
+}
+// Setup and upgrade ask this once, after their own Continue; "no" turns the nudge off everywhere.
+export async function askNudge(env) {
+    const nudge = readConfigFile(env)?.nudge;
+    if (nudge?.asked || nudge?.off_all)
+        return;
+    const yes = await confirm(process.stdin, process.stdout, "Let Berliner ask agents to run the tests before they hand work back? [Y/n] ");
+    save(env, { ...nudge, asked: true, ...(!yes && { off_all: true }) });
+}
+function repoRoot() {
+    try {
+        return execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+// Shows the nudge setting, or turns it off or on for this repository, or with --all for every one.
+export async function nudge(env, values, positionals) {
+    const usage = "usage: berliner nudge [on|off] [--all] [--json]";
+    const [mode] = positionals;
+    if (positionals.length > 1 || (mode !== undefined && mode !== "on" && mode !== "off"))
+        throw new CliError(usage, "usage");
+    const root = repoRoot();
+    if (mode === undefined) {
+        const enabled = root ? nudgeEnabled(env, root) : !readConfigFile(env)?.nudge?.off_all;
+        return print({ data: { enabled }, text: `The test nudge is ${enabled ? "on" : "off"}${root ? ` in ${root}` : ""}.` }, values.json === true);
+    }
+    if (!values.all && !root)
+        throw new CliError("not in a git repository: run this inside one, or add --all", "usage");
+    const { off_all, off = [] } = readConfigFile(env)?.nudge ?? {};
+    const turnOff = mode === "off";
+    const next = values.all
+        ? turnOff
+            ? { off_all: true, off }
+            : {}
+        : { ...(off_all && { off_all }), off: turnOff ? [...new Set([...off, root])] : off.filter((r) => r !== root) };
+    save(env, next.off?.length === 0 ? { ...next, off: undefined } : next);
+    const where = values.all ? "any repository" : root;
+    // Turning it on for one repository changes nothing while it is off for all of them.
+    const stillOff = !turnOff && !values.all && next.off_all === true;
+    print({
+        data: { enabled: !turnOff && !stillOff },
+        text: stillOff
+            ? `Removed ${root} from the list, but the nudge is still off for every repository. Run \`berliner nudge on --all\` to turn it on.`
+            : turnOff
+                ? `Berliner won't ask agents to run the tests in ${where}.`
+                : `Berliner will ask agents to run the tests in ${where}.`,
+    }, values.json === true);
+}