@paxnax/berliner 0.5.2 → 0.6.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

@@ -2,7 +2,7 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { addTokens, jsonl, num, Span, 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

package/dist/agents/codex.js

@@ -1,5 +1,12 @@
 import { addTokens, jsonl, num, Span, 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)),
+    output: num(u.output_tokens),
+    cacheRead: num(u.cached_input_tokens),
+    cacheWrite: num(u.cache_write_input_tokens),
+    cacheWrite1h: 0,
+});
 // Line shapes as Codex 0.162.1 writes them (codex-rs/protocol). input_tokens includes both cached reads and cache writes,
 // as in Codex's own parsing test (100 input = 40 cached + 60 written); reasoning_output_tokens is part of output_tokens.
 export async function readCodex(rolloutPath) {
@@ -11,11 +18,23 @@ export async function readCodex(rolloutPath) {
     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();
     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));
+            }
+        }
         if (e.type !== "event_msg")
             continue;
         if (p?.type === "item_completed" && p.item?.type === "UserMessage" && Array.isArray(p.item.content)) {
@@ -32,16 +51,10 @@ export async function readCodex(rolloutPath) {
         const last = num(p?.info?.last_token_usage?.total_tokens);
         // A resumed session restarts the running total in the same rollout: it drops, or its first count is just its own last request.
         // A repeat of the previous event, last request included, is a duplicate notification.
-        // shortcut: a restart after a one-request run of the same size reads as a duplicate; use a run marker if Codex adds one.
+        // shortcut: without usage records, a restart after a one-request run of the same size reads as a duplicate; drop this path once pre-0.148 rollouts no longer matter.
         const dup = total === latestTotal && last === latestLast;
         const restart = total < latestTotal || (latestTotal > 0 && total === last && !dup);
-        const cur = {
-            input: Math.max(0, num(u.input_tokens) - num(u.cached_input_tokens) - num(u.cache_write_input_tokens)),
-            output: num(u.output_tokens),
-            cacheRead: num(u.cached_input_tokens),
-            cacheWrite: num(u.cache_write_input_tokens),
-            cacheWrite1h: 0,
-        };
+        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)
@@ -50,5 +63,8 @@ export async function readCodex(rolloutPath) {
         latestLast = last;
         latest = cur;
     }
-    return { model, tokensByModel: byModel, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };
+    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 };
 }

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/;

package/dist/args.js

@@ -10,6 +10,8 @@ const config = {
         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 +27,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>"`
     : "";
@@ -50,15 +57,24 @@ 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.
-export async function patchFirst(cfg, path, body, titled, guess) {
-    try {
+// 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, 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 } };
+    };
+    try {
+        return await patch();
     }
     catch (err) {
         if (!(err instanceof CliError && err.status === 404))
             throw err;
-        return saveSession(cfg, "PUT", path, { ...body, cost_usd: body.cost_usd ?? 0, plan: body.plan ?? cfg.plan ?? undefined }, guess);
+        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();
+            throw err;
+        });
     }
 }
 function number(values, flag) {
@@ -127,7 +143,7 @@ function prefilterPrs(body) {
 // `guess`, the agent's --plan, in that same retry; without --plan it is left out, so a new session gets the server's pick.
 // Anything else is thrown as before. Warnings are printed only once the save succeeded, so a failed save never claims
 // fields were dropped.
-export async function saveSession(cfg, method, path, input, guess) {
+export async function saveSession(cfg, method, path, input, guess, headers) {
     const first = prefilterPrs(input);
     const dropped = first.dropped;
     const fromEnv = cfg.plan !== null && input.plan === cfg.plan && guess !== cfg.plan;
@@ -142,7 +158,7 @@ export async function saveSession(cfg, method, path, input, guess) {
         return { ...res, dropped };
     };
     try {
-        return finish(await request(cfg, method, path, first.body));
+        return finish(await request(cfg, method, path, first.body, { headers }));
     }
     catch (err) {
         const fieldErrors = err instanceof CliError && err.status === 422 ? err.details?.fieldErrors : undefined;
@@ -155,6 +171,6 @@ export async function saveSession(cfg, method, path, input, guess) {
             delete retry[field];
             dropped.push({ field, reason: field === "prs" ? `all PRs dropped: ${[fieldErrors[field]].flat().join(", ")}` : [fieldErrors[field]].flat().join(", ") });
         }
-        return finish(await request(cfg, method, path, retry));
+        return finish(await request(cfg, method, path, retry, { headers }));
     }
 }

package/dist/commands/hook.js

@@ -8,6 +8,9 @@ import { readConfig, stateDir } from "../config.js";
 import { viewPr } from "../gh.js";
 import { gitFacts } from "../git.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"];
@@ -60,7 +63,7 @@ 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 +100,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 });
@@ -105,8 +119,10 @@ async function start(tool, env) {
     // shortcut: payload files are kept, one small file per session, as a child can't tell whether a newer one is on its way.
     writeFileSync(`${file}.${process.pid}`, text);
     renameSync(`${file}.${process.pid}`, file);
-    // No stdio and its own process group: the tool waits on this process only, and the child outlives it.
-    spawn(process.execPath, [process.argv[1], "hook", tool, "--run", file], { detached: true, stdio: "ignore" })
+    // No stdio and its own process group: the tool waits on this process only, and the child outlives it. Bun gets the
+    // launcher's flags, so the cwd's .env and bunfig.toml stay out of it (see index.ts).
+    const bun = process.versions.bun ? ["--config=/dev/null", "--env-file=/dev/null"] : [];
+    spawn(process.execPath, [...bun, process.argv[1], "hook", tool, "--run", file], { detached: true, stdio: "ignore" })
         .on("error", (err) => log(env, `${tool} ${id}: ${err.message}`))
         .unref();
 }
@@ -210,6 +226,26 @@ 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,
@@ -221,6 +257,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)}`;
@@ -234,9 +271,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 {
@@ -250,6 +290,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.
@@ -264,7 +307,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);
+}

package/dist/commands/report.js

@@ -1,10 +1,12 @@
 import { CliError } from "../client.js";
 import { print, warn } from "../output.js";
 import { uploadEvidence } from "../upload.js";
-import { fromTool, patchFirst, projectHint, saveSession, sessionBody } from "./body.js";
+import { announceRefusal, resolveTeam } from "../team.js";
+import { fromTool, patchFirst, projectHint, saveSession, sessionBody, warnTeam } from "./body.js";
 import { inTool } from "./hook.js";
 const required = ["session-id", "title", "repo", "cost", "model", "plan"];
 export async function report(cfg, values, positionals, env) {
+    await announceRefusal(env);
     // Usually an unquoted value with spaces, e.g. --title Fix the bug.
     if (positionals.length)
         throw new CliError(`unexpected argument "${positionals[0]}"; quote values that contain spaces`, "usage");
@@ -19,16 +21,18 @@ 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");
+    const team = await resolveTeam(values, process.cwd(), env);
     const body = { ...sessionBody(values), plan: cfg.plan ?? values.plan };
     const id = values["session-id"];
     const path = `/v1/sessions/${encodeURIComponent(id)}`;
     // Inside a tool a report without --title is usually a follow-up: the derived title is only for a new session. A report
     // without a cost must not replace the saved one either.
     const { json: saved, dropped } = await (tool && (!titled || body.cost_usd === undefined)
-        ? patchFirst(cfg, path, body, titled, values.plan)
-        : saveSession(cfg, "PUT", path, body, values.plan));
+        ? patchFirst(cfg, path, body, titled, values.plan, team)
+        : saveSession(cfg, "PUT", path, { ...body, team: team ?? undefined }, values.plan));
     const json = dropped.length ? { ...saved, dropped } : saved;
     const { created, session } = json;
+    warnTeam(session, team);
     const text = `Saved session ${session.id} (${created ? "created" : "updated"}). ${session.pr_count} PR(s) linked.${projectHint(session)}`;
     const json_ = values.json === true;
     // Human mode prints the session line before uploads start; --json waits so stdout is one document.

package/dist/commands/session.js

@@ -1,6 +1,8 @@
 import { absolute, CliError, request } from "../client.js";
 import { mergeLabel, print } from "../output.js";
+import { announceRefusal } from "../team.js";
 export async function session(cfg, values, positionals) {
+    await announceRefusal(process.env);
     if (positionals.length !== 1)
         throw new CliError("usage: berliner session <session-id> [--json]", "usage");
     const { json } = await request(cfg, "GET", `/v1/sessions/${encodeURIComponent(positionals[0])}`);
@@ -19,6 +21,7 @@ export async function session(cfg, values, positionals) {
         ["Duration (s)", s.duration_seconds],
         ["Commits", s.commits],
         ["Coverage", s.coverage],
+        ["Tests", s.tests && `${s.tests.check}${s.tests.command ? ` (${s.tests.command})` : ""}${s.tests.by_ci ? " via CI" : ""}`],
         ["CI", s.ci],
         ["Merge", mergeLabel(s)],
     ];

package/dist/commands/sessions.js

@@ -1,8 +1,10 @@
 import { request } from "../client.js";
 import { 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)

package/dist/commands/setup.js

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

package/dist/commands/team.js

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

package/dist/commands/update.js

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