@paxnax/berliner 0.5.1 → 0.5.2

package/dist/agents/codex.js

@@ -9,6 +9,7 @@ export async function readCodex(rolloutPath) {
     let taskUrl = null;
     let latest = zero;
     let latestTotal = 0;
+    let latestLast = 0;
     const byModel = {};
     for await (const e of jsonl(rolloutPath)) {
         span.add(e.timestamp);
@@ -28,8 +29,12 @@ export async function readCodex(rolloutPath) {
         if (!u)
             continue;
         const total = num(u.total_tokens);
+        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.
-        const restart = total < latestTotal || (total > latestTotal && latestTotal > 0 && total === num(p?.info?.last_token_usage?.total_tokens));
+        // 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.
+        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),
@@ -42,6 +47,7 @@ export async function readCodex(rolloutPath) {
         if (model)
             byModel[model] = addTokens(byModel[model] ?? zero, delta);
         latestTotal = total;
+        latestLast = last;
         latest = cur;
     }
     return { model, tokensByModel: byModel, costUsd: null, startedAt: span.first, endedAt: span.last, firstPrompt, taskUrl };

package/dist/client.js

@@ -11,7 +11,7 @@ export class CliError extends Error {
 }
 export const absolute = (cfg, path) => cfg.url.replace(/\/+$/, "") + path;
 export async function request(cfg, method, path, body, opts = {}) {
-    const { timeoutMs = 10_000, retries = 3, deadlineMs = 15_000, auth = true } = opts;
+    const { timeoutMs = 10_000, retries = 3, deadlineMs = 15_000, auth = true, headers = {} } = opts;
     if (auth && !cfg.token)
         throw new CliError("No API token: run `npx @paxnax/berliner@latest setup`, or set BERLINER_TOKEN.", "usage");
     // One budget for all attempts, so a hung server can't hold the agent's pipeline for long (anti-goal 1).
@@ -28,6 +28,7 @@ export async function request(cfg, method, path, body, opts = {}) {
                 headers: {
                     ...(auth ? { Authorization: `Bearer ${cfg.token}` } : {}),
                     ...(body === undefined ? {} : { "Content-Type": raw ? "application/octet-stream" : "application/json" }),
+                    ...headers,
                 },
                 // A Uint8Array is sent as-is (evidence bytes); fetch sets its Content-Length.
                 body: body === undefined ? undefined : raw ? body : JSON.stringify(body),

package/dist/commands/hook.js

@@ -28,15 +28,16 @@ export function inTool(env) {
     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, and OpenCode's plugin sends the session itself;
-// otherwise it is looked up. Null without a record.
+// 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 itself too, used only without a saved record. Null without a record.
 export async function sessionFacts(tool, sessionId, env, payload = {}) {
     let facts;
-    if (tool === "opencode" && payload.session)
+    const named = typeof payload.transcript_path === "string" && payload.transcript_path ? payload.transcript_path : null;
+    const file = named ?? (await findRecord(tool, sessionId, env));
+    // The plugin saves the record, in order, before it spawns each reporter, so a reporter that runs late still finds the newest.
+    if (tool === "opencode" && !file && payload.session)
         facts = readOpenCode(payload.session);
     else {
-        const named = typeof payload.transcript_path === "string" && payload.transcript_path ? payload.transcript_path : null;
-        const file = named ?? (await findRecord(tool, sessionId, env));
         if (!file)
             return null;
         if (tool === "claude-code")
@@ -230,10 +231,14 @@ async function send(tool, file, env) {
     catch (err) {
         if (!(err instanceof CliError && err.status === 404))
             throw err;
-        // shortcut: an agent report landing between the 404 and this PUT gets the derived title; a create-only call would close that.
         // 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.
-        const create = (plan) => request(cfg, "PUT", path, { ...body, cost_usd: body.cost_usd ?? 0, title: derivedTitle(facts.firstPrompt, git), plan });
+        // 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) => {
+            if (err instanceof CliError && err.status === 412)
+                return request(cfg, "PATCH", path, body);
+            throw err;
+        });
         try {
             saved = await create(cfg.plan ?? undefined);
         }

package/dist/commands/report.js

@@ -43,9 +43,8 @@ export async function report(cfg, values, positionals, env) {
     if (json_)
         print({ data: { ...json, evidence: result }, text }, true);
     else {
-        console.log(`Evidence: ${result.uploaded} uploaded, ${result.existing} already uploaded, ${result.skipped.length} skipped.`);
-        for (const p of result.published ?? [])
-            console.log(p.markdown);
+        const summary = `Evidence: ${result.uploaded} uploaded, ${result.existing} already uploaded, ${result.skipped.length} skipped.`;
+        print({ data: result, text: [summary, ...(result.published ?? []).map((p) => p.markdown)].join("\n") }, false);
     }
     for (const s of result.skipped)
         warn(`${s.path}: ${s.reason}`);

package/dist/commands/upgrade.js

@@ -86,7 +86,7 @@ export async function upgrade(env, values) {
     const targets = values["no-skill"] ? [] : skillTargets(tools, env);
     const skill = targets.length ? await skillOf(target, !installing, env) : "";
     let stale = targets.filter((t) => !sameAs(t.path, skill));
-    // Computed now, so what is written is what the plan showed.
+    // Computed now, for the plan.
     const hooks = tools.flatMap((tool) => {
         const path = hookPath(tool.id, env);
         const text = updatedHooks(tool.id, path);
@@ -153,9 +153,15 @@ export async function upgrade(env, values) {
         }
     }
     for (const h of hooks) {
+        // Merged again into the file as it is now, so an edit made during the prompt or the install is kept. The plugin is the one
+        // the plan showed: the install may have replaced this package's copy.
+        // shortcut: an edit between this read and write is still lost; lock if that shows up.
+        const text = h.id === "opencode" ? h.text : updatedHooks(h.id, h.path);
+        if (text === null)
+            continue;
         try {
             // In place, so a settings file that is a symlink stays one.
-            writeFileSync(h.path, h.text);
+            writeFileSync(h.path, text);
             console.log(`✓ ${h.name} hook: ${tilde(h.path)}`);
         }
         catch (err) {

package/dist/output.js

@@ -1,12 +1,14 @@
+// Stored text must not drive the terminal (OSC 52, cursor moves); one char for one keeps table widths.
+const safe = (s) => s.replace(/(?![\t\n])\p{Cc}/gu, "\ufffd");
 export function print(result, json) {
-    console.log(json ? JSON.stringify(result.data, null, 2) : result.text);
+    console.log(json ? JSON.stringify(result.data, null, 2) : safe(result.text));
 }
 // Always a single line, so agents and CI logs see exactly one warning.
 export function warn(msg) {
-    console.error(`berliner: ${msg.replace(/\s*\n\s*/g, " ")}`);
+    console.error(`berliner: ${safe(msg.replace(/\s*\n\s*/g, " "))}`);
 }
 // GitHub renders an image from Markdown but not a video from another host, so a video is its bare URL.
-export const embed = (e, url) => e.kind === "video" ? url : `![${(e.caption || e.filename).replace(/[[\]]/g, "\\$&")}](${url})`;
+export const embed = (e, url) => e.kind === "video" ? url : `![${(e.caption || e.filename).replace(/\s*\n\s*/g, " ").replace(/[\\[\]]/g, "\\$&")}](${url})`;
 // Same wording as the web's mergeLabel (app/src/web/format.ts).
 const MERGE = { open: "Open", merged: "Merged", closed: "Closed", none: "No PRs" };
 export const mergeLabel = (s) => s.pr_count > 1 ? `${s.merged_count} of ${s.pr_count} merged` : (MERGE[s.merge] ?? s.merge);

package/opencode/berliner.js

@@ -26,6 +26,9 @@ const MAX_DEPTH = 10;
 
 const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
 const get = async (client, id) => (await client.session.get({ path: { id } }))?.data;
+// Resolves with p, or with undefined after ms: an SDK call that never answers must not hold up OpenCode. Unreferenced, so a
+// pending deadline never keeps a process alive.
+const within = (p, ms) => Promise.race([p, new Promise((r) => setTimeout(r, ms).unref?.())]);
 
 // One agent session is one Berliner session: a subagent's child session belongs to the top-level session above it.
 async function topLevelId(client, id) {
@@ -77,14 +80,16 @@ async function save(client, sessionID) {
   return session;
 }
 
-// One session's saves run one at a time, in the order they came, so an older total never overwrites a newer one.
+// One session's saves run one at a time, in the order they came, so an older total never overwrites a newer one. A save that
+// hangs holds the next one up for 10 seconds at most.
 // shortcut: only within this OpenCode process; two `berliner hook` processes can still write out of order, lock there if that shows up.
+// shortcut: a save that resumes after its deadline can write older totals; the next save rewrites them.
 const queues = new Map();
 const serial = (id, fn) => {
   const p = (queues.get(id) ?? Promise.resolve()).then(fn, fn);
   queues.set(
     id,
-    p.catch(() => {}),
+    within(p, 10_000).catch(() => {}),
   );
   return p;
 };
@@ -111,11 +116,15 @@ export const BerlinerPlugin = async ({ client }) => ({
       if (!input?.sessionID) return;
       output.env.OPENCODE_SESSION_ID = input.sessionID;
       // A subagent's shell gets the top-level session, so a `berliner report` the agent runs there doesn't split it off.
-      const top = await topLevelId(client, input.sessionID);
+      // A second each at most: past it the shell keeps the id it was given, or runs before the save is done.
+      const top = await within(topLevelId(client, input.sessionID), 1000);
       if (!top) return;
       output.env.OPENCODE_SESSION_ID = top;
       // So that report finds the totals before the session's first idle. Not reported from here: that waits for idle.
-      await serial(top, () => save(client, top));
+      await within(
+        serial(top, () => save(client, top)),
+        1000,
+      );
     } catch {
       // Never fail the agent's shell.
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paxnax/berliner",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Report coding-agent sessions to Berliner",
   "type": "module",
   "engines": {