@paxnax/berliner 0.5.3 → 0.7.0

package/opencode/berliner.js

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

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "@paxnax/berliner",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "Report coding-agent sessions to Berliner",
+  "keywords": [
+    "claude-code",
+    "codex",
+    "opencode",
+    "coding-agents",
+    "ai-cost-tracking",
+    "cli"
+  ],
+  "homepage": "https://berliner.app",
   "type": "module",
   "engines": {
     "node": ">=22"

package/skill/SKILL.md

@@ -28,6 +28,7 @@ Hooks installed by `berliner setup` already report the session's cost, model, re
 | `--pr` | Every pull request, one flag each. |
 | `--coverage` | Percent, from the test run's coverage summary. |
 | `--evidence` | Each screenshot or video. |
+| `--team`, `--no-team` | Only when the user asks for a one-off. See [Teams](#teams). |
 
 Do not pass `--session-id`, `--cost` or `--model`: the CLI fills them in from the tool's own records, and an explicit value is ignored with a warning. `--repo` and `--plan` are not needed either: the plan comes from the user's `BERLINER_PLAN`, or from their subscriptions in Settings. A report without `--title` keeps the session's existing title. `berliner update` ignores a session ID here.
 
@@ -86,6 +87,36 @@ In a non-interactive session (no user to answer), never ask and never save.
 
 The repository comes from `git remote get-url origin`; `--repo owner/name` names another one.
 
+## Teams
+
+A session reports to the user's own plan unless a team is set. The CLI picks the team from the first of these that exists:
+
+| Source | Use it for |
+|---|---|
+| `--team <uuid>` or `--no-team` | One report. `--no-team` beats every other source. |
+| `team` in `.berliner.json` at the repository root: `{ "team": "<uuid>" }` | The whole team. The file is meant to be committed. |
+| `BERLINER_TEAM` | One machine or shell. |
+| `berliner team <uuid>` | One machine, saved globally. `berliner team --none` clears it; `berliner team` prints the team in effect and where it came from. |
+
+With none of them, the session goes to the user's own plan. Do not set a team yourself: the user or the repository already did.
+
+Only the report that creates a session sends the team. A session's team is fixed after that, and the CLI warns when a later setting differs. Ignore the warning.
+
+The server can refuse the report that creates a team session with a 422. The message says how to fix it:
+
+| Code | Meaning | Fix |
+|---|---|---|
+| `team_not_found` | No team has that uuid. | Check the uuid in `.berliner.json`, `BERLINER_TEAM` or the global setting. |
+| `team_not_member` | The user is not a member of the team. | The user accepts the team's invite in the web app, or the owner invites them. |
+| `team_not_eligible` | The repository's owner is not an organization the team covers. | The team's owner adds the organization in the web app, or the user reports this repository without the team. |
+| `team_inactive` | The team has no active plan. | The team's owner sets up the plan in the web app. |
+
+When a report is refused, tell the user in your next message and quote the message the CLI printed. Inside Claude Code, Codex or OpenCode the hook cannot print it: it saves a note, and the next `berliner report`, `update`, `session` or `sessions` in that repository prints it once. The web app shows it as a banner too.
+
+Never add `--no-team` or a different `--team` just to get past a refusal unless the user agrees. That moves the session to another plan.
+
+The team's owner sees every session and file reported to the team. Members never see each other's team work.
+
 ## Keep PR states current
 
 A PR in a repository without the Berliner GitHub App keeps the state you last reported. So:
@@ -115,10 +146,11 @@ Report again with the same `--session-id` whenever something changes.
 - `--commits <n>` (outside the tools; the hooks count them): `git rev-list --count <base>..HEAD`
 - `--coverage <percent>`: from the test run's coverage summary.
 - `--pr <url>[,merge=<open|merged|closed>][,ci=<pending|running|passed|failed|none>]`: repeat per PR. URL from `gh pr view --json url`.
-- `--evidence <path>[::caption]`: repeat per screenshot or video.
+- `--evidence <path>[::caption[::happy|unhappy|edge]]`: repeat per screenshot or video; the optional last part says whether it shows the happy path, an unhappy path or an edge case. A caption can't contain `::`.
 - `--public`: with `--evidence`, also make those files viewable without sign-in. See below.
 - `--task <id>`, `--task-url <url>`: the ticket. See [Tickets](#tickets).
 - `--project <name>`: only the ticket's tracker project or a project the user named. See [Projects](#projects).
+- `--team <uuid>`, `--no-team`: which plan the session reports to. See [Teams](#teams).
 - `--started-at <ISO>`, `--ended-at <ISO>`.
 
 Quote any value that contains spaces.