@paxnax/berliner 0.5.3 → 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/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>"`
     : "";
@@ -51,7 +58,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 +69,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

@@ -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 });
@@ -212,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,
@@ -223,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)}`;
@@ -236,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 {
@@ -252,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.
@@ -266,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);
 }

package/dist/commands/upgrade.js

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

package/dist/config.js

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

package/dist/gh.js

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

package/dist/index.js

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