@paxnax/berliner 0.5.3 → 0.7.0

package/dist/setup/hooks.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { claudeDir, codexDir, opencodeDir } from "./targets.js";
-const entries = (tool, asyncStop) => {
+const entries = (tool) => {
     const hooks = (extra = {}) => [{ type: "command", command: `berliner hook ${tool}`, ...extra }];
     return {
-        // Claude Code runs Stop after every reply; async keeps the agent from waiting on it.
-        Stop: { hooks: hooks(asyncStop ? { async: true } : {}) },
+        // Not async: Claude Code only reads what a foreground Stop hook prints to the agent. The hook still returns at once.
+        Stop: { hooks: hooks() },
         PreCompact: { hooks: hooks() },
         SessionEnd: { hooks: hooks() },
         // Not async: what it prints is the reminder, which the tool adds to the agent's context.
@@ -16,7 +16,7 @@ const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v)
 const ours = (entry) => isObject(entry) &&
     Array.isArray(entry.hooks) &&
     entry.hooks.some((h) => isObject(h) && typeof h.command === "string" && h.command.startsWith("berliner hook "));
-// The file with our entries added to the events that lack one (unless addMissing is false) and an older matcher of ours
+// The file with our entries added to the events that lack one (unless addMissing is false) and an older matcher or async flag of ours
 // brought up to date in place, or null when nothing changes. "unreadable" when it isn't a JSON object whose hooks we can add
 // to: then it is the user's to fix, and is never rewritten.
 function merged(file, add, addMissing = true) {
@@ -46,9 +46,25 @@ function merged(file, add, addMissing = true) {
             hooks[event] = [...list, entry];
             added = true;
         }
-        else if (i >= 0 && entry.matcher !== undefined && list[i].matcher !== entry.matcher) {
-            hooks[event] = list.map((e, j) => (j === i ? { ...e, matcher: entry.matcher } : e));
-            updated = true;
+        else if (i >= 0) {
+            const matcher = entry.matcher !== undefined && list[i].matcher !== entry.matcher;
+            const wantAsync = entry.hooks[0].async;
+            const stale = (h) => isObject(h) && ours({ hooks: [h] }) && h.async !== wantAsync;
+            const flag = list[i].hooks.some(stale);
+            if (matcher || flag) {
+                hooks[event] = list.map((e, j) => {
+                    if (j !== i)
+                        return e;
+                    const hs = e.hooks.map((h) => {
+                        if (!stale(h))
+                            return h;
+                        const { async: _, ...rest } = h;
+                        return wantAsync === undefined ? rest : { ...rest, async: wantAsync };
+                    });
+                    return { ...e, ...(matcher ? { matcher: entry.matcher } : {}), hooks: hs };
+                });
+                updated = true;
+            }
         }
     }
     if (!added && !updated)
@@ -68,10 +84,10 @@ function install(file, add) {
     return result.added ? "added" : "updated";
 }
 const describe = (result) => result === "unreadable" ? "can't be read, left unchanged" : result === null ? "already installed" : result.added ? "adds a hook" : "updates the hook";
-export const installClaudeHooks = (settingsPath) => install(settingsPath, entries("claude-code", true));
-export const describeClaudeHooks = (settingsPath) => describe(merged(settingsPath, entries("claude-code", true)));
-export const installCodexHooks = (hooksPath) => install(hooksPath, entries("codex", false));
-export const describeCodexHooks = (hooksPath) => describe(merged(hooksPath, entries("codex", false)));
+export const installClaudeHooks = (settingsPath) => install(settingsPath, entries("claude-code"));
+export const describeClaudeHooks = (settingsPath) => describe(merged(settingsPath, entries("claude-code")));
+export const installCodexHooks = (hooksPath) => install(hooksPath, entries("codex"));
+export const describeCodexHooks = (hooksPath) => describe(merged(hooksPath, entries("codex")));
 export const hookPath = (tool, env) => tool === "claude-code"
     ? join(claudeDir(env), "settings.json")
     : tool === "codex"
@@ -84,7 +100,7 @@ export function updatedHooks(tool, path, next) {
         const text = next ?? plugin();
         return existsSync(path) && !current(path, text) ? text : null;
     }
-    const result = merged(path, entries(tool, tool === "claude-code"), false);
+    const result = merged(path, entries(tool), false);
     return result === "unreadable" ? null : (result?.text ?? null);
 }
 // dist/setup/hooks.js -> ../../opencode/berliner.js (the package's opencode/ directory).

package/dist/team.js

@@ -0,0 +1,99 @@
+import { execFile } from "node:child_process";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { CliError } from "./client.js";
+import { readConfigFile, stateDir } from "./config.js";
+import { gitFacts } from "./git.js";
+import { warn } from "./output.js";
+const run = promisify(execFile);
+export const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// The `team` of .berliner.json at the repository root, or undefined outside a repository or without the file.
+async function repoTeam(cwd) {
+    const root = await run("git", ["rev-parse", "--show-toplevel"], { cwd, timeout: 2000 }).then((r) => r.stdout.trim(), () => null);
+    if (!root)
+        return undefined;
+    const file = join(root, ".berliner.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw new CliError(`${file} is not readable JSON: ${err.message}`, "usage");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new CliError(`${file} must hold a JSON object like {"team": "<uuid>"}`, "usage");
+    const { team } = parsed;
+    if (team !== undefined && typeof team !== "string")
+        throw new CliError(`"team" in ${file} must be a string (the team's id)`, "usage");
+    return team || undefined;
+}
+// The founder's order: --no-team, --team, .berliner.json, BERLINER_TEAM, the global config, else the developer's own plan.
+export async function resolveTeamSource(values, cwd, env) {
+    if (values["no-team"] && values.team !== undefined)
+        throw new CliError("--team and --no-team can't be used together", "usage");
+    if (values["no-team"])
+        return { team: null, source: "flag" };
+    if (values.team)
+        return { team: values.team, source: "flag" };
+    const repo = await repoTeam(cwd);
+    if (repo)
+        return { team: repo, source: "repo" };
+    if (env.BERLINER_TEAM)
+        return { team: env.BERLINER_TEAM, source: "env" };
+    const saved = readConfigFile(env)?.team;
+    return saved ? { team: saved, source: "config" } : { team: null, source: "none" };
+}
+export const resolveTeam = async (values, cwd, env) => (await resolveTeamSource(values, cwd, env)).team;
+// A session keeps the team it was created with, so a different setting now only deserves a word.
+export function teamWarning(saved, resolved) {
+    return (saved?.id ?? null) === resolved ? null : `this session is already on ${saved?.name ?? "your own plan"}; the team setting applies to new sessions`;
+}
+const refusals = (env) => join(stateDir(env), "refusals.json");
+function readNotes(env) {
+    try {
+        return JSON.parse(readFileSync(refusals(env), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+// Renamed into place, so a concurrent reader never sees half a file.
+// shortcut: two writers at once can lose one note (read, then write); the next refused report leaves it again.
+function writeNotes(env, notes) {
+    const file = refusals(env);
+    mkdirSync(stateDir(env), { recursive: true, mode: 0o700 });
+    if (!Object.keys(notes).length)
+        rmSync(file, { force: true });
+    else {
+        writeFileSync(`${file}.${process.pid}`, JSON.stringify(notes));
+        renameSync(`${file}.${process.pid}`, file);
+    }
+}
+// The hook can't print: it leaves the server's refusal here for the next command in that repository.
+export function noteRefusal(env, repository, message) {
+    writeNotes(env, { ...readNotes(env), [repository]: { message, at: new Date().toISOString() } });
+}
+export function takeRefusal(env, repository) {
+    const notes = readNotes(env);
+    const note = notes[repository];
+    if (!note)
+        return null;
+    delete notes[repository];
+    writeNotes(env, notes);
+    return note.message;
+}
+// Foreground commands print a refusal the hook left for this directory's repository, once. Outside a repository: nothing.
+export async function announceRefusal(env) {
+    try {
+        const repository = (await gitFacts(process.cwd(), null)).repository;
+        const message = repository && takeRefusal(env, repository);
+        if (message)
+            warn(message);
+    }
+    catch {
+        // A note that can't be read or removed must not stop the command.
+    }
+}

package/dist/tests/check.js

@@ -0,0 +1,108 @@
+import { execFile } from "node:child_process";
+import { lstatSync } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { testCommand } from "./command.js";
+import { claudeRuns, codexRuns } from "./runs.js";
+const run = promisify(execFile);
+const DOCS = /^docs\/|\.(?:md|mdx|txt)$/i;
+// Best effort like git.ts, within what is left of the budget: a git error or no time left gives null.
+async function git(cwd, args, deadline) {
+    const timeout = deadline - Date.now();
+    if (timeout <= 0)
+        return null;
+    try {
+        return (await run("git", ["-c", "core.quotePath=false", ...args], { cwd, timeout })).stdout;
+    }
+    catch {
+        return null;
+    }
+}
+const mtime = (file) => lstatSync(file, { throwIfNoEntry: false })?.mtimeMs;
+// A deleted file is dated by the change to its nearest remaining folder: that removal is the folder's last change unless a
+// later one came after it, which only makes the date later.
+function removedAt(root, file) {
+    for (let dir = path.dirname(file);; dir = path.dirname(dir)) {
+        const at = mtime(path.join(root, dir));
+        if (at !== undefined || dir === ".")
+            return at ?? Date.now();
+    }
+}
+// The code files the session changed, uncommitted or committed since it started, newest first, and whether any code file is
+// uncommitted whatever its date; null when git fails.
+async function changedFiles(root, startedAt, start, deadline) {
+    const status = await git(root, ["status", "--porcelain", "-z", "--untracked-files=all"], deadline);
+    if (status === null)
+        return null;
+    // A repository with no commit has no log.
+    const log = (await git(root, ["log", `--since=${startedAt}`, "--name-only", "--format=%x01%ct"], deadline)) ?? "";
+    const uncommitted = new Set();
+    const entries = status.split("\0");
+    for (let i = 0; i < entries.length; i++) {
+        if (!entries[i])
+            continue;
+        uncommitted.add(entries[i].slice(3));
+        // A rename or copy is followed by its source path.
+        if (/^[RC]/.test(entries[i]))
+            uncommitted.add(entries[++i]);
+    }
+    const committed = new Map();
+    let commitAt = 0;
+    for (const line of log.split("\n")) {
+        if (line.startsWith("\x01"))
+            commitAt = Number(line.slice(1)) * 1000;
+        else if (line && !committed.has(line))
+            committed.set(line, commitAt); // newest commit first
+    }
+    const files = [];
+    for (const file of new Set([...uncommitted, ...committed.keys()])) {
+        if (DOCS.test(file))
+            continue;
+        const at = mtime(path.join(root, file)) ?? (uncommitted.has(file) ? removedAt(root, file) : committed.get(file));
+        if (at !== undefined && at >= start)
+            files.push({ path: file, at });
+    }
+    return { files: files.sort((a, b) => b.at - a.at), dirty: [...uncommitted].some((f) => !DOCS.test(f)) };
+}
+// The session's test runs against its changes, or null when there is nothing to say. Quick mode reads only the runs since
+// the newest change, so a pass before it gives unchecked, not stale.
+export async function checkTests(o) {
+    // OpenCode records no commands.
+    if ((o.tool !== "claude-code" && o.tool !== "codex") || !o.startedAt)
+        return null;
+    const start = Date.parse(o.startedAt);
+    if (Number.isNaN(start))
+        return null;
+    const root = o.root ?? (await git(o.cwd, ["rev-parse", "--show-toplevel"], o.deadline))?.trim();
+    if (!root)
+        return null;
+    const main = testCommand(root);
+    if (!main)
+        return null;
+    const { command } = main;
+    const found = await changedFiles(root, o.startedAt, start, o.deadline);
+    if (!found?.files.length)
+        return null;
+    const { files, dirty } = found;
+    const [headSha, headAt] = (await git(root, ["log", "-1", "--format=%H %ct"], o.deadline))?.trim().split(" ") ?? [];
+    const read = o.tool === "codex" ? codexRuns : claudeRuns;
+    const runs = await read(o.transcriptPath, command, root, o.deadline, o.quick ? files[0].at : start);
+    if (!runs || Date.now() > o.deadline)
+        return null;
+    const counted = runs.filter((r) => r.outcome !== "unknown");
+    const last = counted.at(-1);
+    const pass = counted.findLast((r) => r.outcome === "passed");
+    const changed = pass ? files.filter((f) => f.at > pass.at) : files;
+    // The latest counted run decides: a failure after a pass is not verified.
+    const verdict = last?.outcome === "zero" ? "zero_tests" : last?.outcome !== "passed" ? "unchecked" : changed.length ? "stale" : "verified";
+    return {
+        verdict,
+        command,
+        changed: changed.map((f) => f.path),
+        changedAt: files[0].at,
+        // CI vouches for a commit only when CI runs the tests, and the server takes SHA-1 ids only, as gh.ts reads them.
+        headSha: main.source === "workflow" && /^[0-9a-f]{40}$/.test(headSha ?? "") ? headSha : null,
+        // Any uncommitted code change, however old, means HEAD is not the tree that was tested.
+        treeClean: headAt !== undefined && !dirty,
+    };
+}

package/dist/tests/command.js

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+// In the order they are tried.
+const KNOWN = [
+    "npm test",
+    "npm run test",
+    "pnpm test",
+    "yarn test",
+    "bun test",
+    "pytest",
+    "go test ./...",
+    "cargo test",
+    "vendor/bin/phpunit",
+    "composer test",
+    "bundle exec rspec",
+    "mix test",
+];
+const LOCKS = [
+    ["pnpm-lock.yaml", "pnpm test"],
+    ["yarn.lock", "yarn test"],
+    ["bun.lock", "bun test"],
+    ["bun.lockb", "bun test"],
+];
+const cache = new Map();
+// The repo's main test command: the first known one a CI workflow runs, else package.json's test script. Synchronous reads only.
+export function testCommand(root) {
+    const dir = path.join(root, ".github", "workflows");
+    const workflows = existsSync(dir)
+        ? readdirSync(dir)
+            .filter((f) => /\.ya?ml$/.test(f))
+            .sort()
+            .map((f) => path.join(dir, f))
+        : [];
+    const files = [...workflows, path.join(root, "package.json"), ...LOCKS.map(([f]) => path.join(root, f))];
+    const key = files.map((f) => `${f}:${existsSync(f) ? statSync(f).mtimeMs : ""}`).join("|");
+    const hit = cache.get(root);
+    if (hit?.key === key)
+        return hit.found;
+    const ci = fromWorkflows(workflows);
+    const found = ci ? { command: ci, source: "workflow" } : fromPackage(root);
+    cache.set(root, { key, found });
+    return found;
+}
+// shortcut: line matching, not YAML; upgrade if workflows with anchors or matrices that build the command go wrong.
+function fromWorkflows(files) {
+    for (const file of files) {
+        // A `run: cmd` line, a `- run: cmd` step or a line of a `run: |` block.
+        const lines = readFileSync(file, "utf8")
+            .split("\n")
+            .map((l) => l
+            .trim()
+            .replace(/^-\s+/, "")
+            .replace(/^run:\s*/, ""));
+        const found = KNOWN.find((c) => lines.some((l) => l === c || l.startsWith(`${c} `) || l.startsWith(`${c}\t`)));
+        if (found)
+            return found;
+    }
+    return null;
+}
+function fromPackage(root) {
+    let scripts;
+    try {
+        scripts = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).scripts;
+    }
+    catch {
+        return null;
+    }
+    // npm init's placeholder always fails: it is no tests.
+    if (typeof scripts?.test !== "string" || /no test specified/.test(scripts.test))
+        return null;
+    return { command: LOCKS.find(([f]) => existsSync(path.join(root, f)))?.[1] ?? "npm test", source: "package" };
+}

package/dist/tests/nudge.js

@@ -0,0 +1,68 @@
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { jsonl } from "../agents/read.js";
+import { nudgeEnabled } from "../commands/nudge.js";
+import { stateDir } from "../config.js";
+import { checkTests } from "./check.js";
+const run = promisify(execFile);
+const BUDGET_MS = 500;
+// The session's start without reading the whole record: both tools date their first entries.
+async function firstTimestamp(file, deadline) {
+    for await (const e of jsonl(file)) {
+        if (Date.now() > deadline)
+            return null;
+        if (typeof e.timestamp === "string")
+            return e.timestamp;
+    }
+    return null;
+}
+async function repoRoot(cwd, deadline) {
+    try {
+        return (await run("git", ["rev-parse", "--show-toplevel"], { cwd, timeout: Math.max(1, deadline - Date.now()) })).stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// The Stop hook's line asking the agent to run the tests, or null. Asked once per set of changes: the state is saved first.
+export async function nudge(tool, p, env) {
+    const deadline = Date.now() + BUDGET_MS;
+    if (tool === "opencode" || p.stop_hook_active === true)
+        return null;
+    if (typeof p.transcript_path !== "string" || !p.transcript_path || typeof p.cwd !== "string")
+        return null;
+    // A reply ending in a question waits on the user; it doesn't hand the work back. Markdown may close after the ?: `?**`, `?)`.
+    const last = typeof p.last_assistant_message === "string" ? p.last_assistant_message.trimEnd().split("\n").at(-1) : "";
+    if (/\?[*_)"`]*$/.test(last ?? ""))
+        return null;
+    const root = await repoRoot(p.cwd, deadline);
+    if (!root || !nudgeEnabled(env, root))
+        return null;
+    const startedAt = await firstTimestamp(p.transcript_path, deadline);
+    const check = await checkTests({ tool, transcriptPath: p.transcript_path, cwd: p.cwd, root, startedAt, deadline, quick: true });
+    if (!check || check.verdict === "verified")
+        return null;
+    const dir = join(stateDir(env), "nudge");
+    const file = join(dir, `${p.session_id}.json`);
+    const state = JSON.stringify({ changed: check.changed, changedAt: check.changedAt });
+    if (existsSync(file) && readFileSync(file, "utf8") === state)
+        return null;
+    // The changed paths name the user's files: only the user may read them.
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // shortcut: nudge state files are never removed, one small file per session, like the hook's payload files; prune old ones if they pile up.
+    writeFileSync(file, state, { mode: 0o600 });
+    const files = check.changed
+        .slice(0, 3)
+        .map((f) => `\`${f}\``)
+        .join(", ");
+    // No file changed since the last pass means the run after it failed.
+    const note = check.verdict === "zero_tests"
+        ? `\`${check.command}\` ran no tests. Please check the test filter and run the full suite before handing this back.`
+        : !files
+            ? `\`${check.command}\` failed on its last run. Please get it passing, or say why, before handing this back.`
+            : `This repo has tests and ${files} changed since they last passed. Please run \`${check.command}\` before handing this back.`;
+    // Codex expects JSON, not plain text, on Stop's stdout; block is how it continues the turn.
+    return JSON.stringify(tool === "codex" ? { decision: "block", reason: note } : { hookSpecificOutput: { hookEventName: "Stop", additionalContext: note } });
+}

package/dist/tests/runs.js

@@ -0,0 +1,195 @@
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { subagentFiles } from "../agents/claude.js";
+import { jsonl, jsonlBackward } from "../agents/read.js";
+// Words that change how a run reports, not which tests it runs. Kept short on purpose: anything else makes the run partial.
+const FLAGS = new Set(["--", "--silent", "--color", "--no-color", "-v", "--verbose", "--coverage", "2>&1"]);
+const ZERO = [
+    /No test files found/,
+    /No tests found/,
+    /\b0 tests\b/,
+    /\b0 passing\b/,
+    /no tests ran/,
+    /collected 0 items/,
+    /no tests to run/,
+    /Tests:\s+0 total/,
+];
+// Non-zero counts only: cargo prints "0 failed" when it passes and "0 passed" when nothing ran.
+const FAIL_COUNT = /\b[1-9]\d* (?:failed|failing)\b/;
+const PASS_COUNT = /\b[1-9]\d* (?:passed|passing)\b/;
+// node:test prints `# pass N` and `# fail N` (TAP) or `ℹ pass N` (spec); TAP's per-test `ok N - name` is no summary, so Go's
+// marker takes its package and time.
+const FAILED = [FAIL_COUNT, /^FAIL\b/m, /test result: FAILED/, /^\s*not ok\b/m, /^[#ℹ] fail [1-9]/m];
+const PASSED = [PASS_COUNT, /^ok\s+\S+\s+(?:[\d.]+s|\(cached\))\s*$/m, /^[#ℹ] pass [1-9]/m];
+const real = (dir) => {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return null;
+    }
+};
+const sameDir = (a, b) => a === b || (real(a) ?? a) === real(b);
+// A full run's shape, or null. Only a run in the repo root is full: in a monorepo, a workspace's own test script is part of
+// the suite. The directory is the call's, moved by each `cd <dir>` before it; one it can't work out (none, `-`, `~`, a
+// variable, quotes, pushd) makes the run partial. Piped: something after the test command owns the exit status, so only
+// the output can tell.
+function parse(command, main, cwd, root) {
+    const segments = command.split("&&");
+    const mainWords = main.split(" ");
+    let dir = cwd;
+    for (const [i, segment] of segments.entries()) {
+        const end = segment.search(/[|;\n]/);
+        const head = end < 0 ? segment : segment.slice(0, end);
+        const words = head.trim().split(/\s+/);
+        while (/^\w+=\S*$/.test(words[0] ?? ""))
+            words.shift();
+        if (words[0] === "cd" || words[0] === "pushd") {
+            const plain = words[0] === "cd" && words.length === 2 && /^[^-~$"'`\\][^$"'`\\]*$/.test(words[1]);
+            dir = dir && plain ? path.resolve(dir, words[1]) : undefined;
+        }
+        if (mainWords.every((w, j) => words[j] === w) && onlyFlags(words.slice(mainWords.length)) && dir && sameDir(dir, root)) {
+            // Splitting removed the &&s, so an & left over backgrounds the chain or redirects.
+            const tail = [segment.slice(head.length), ...segments.slice(i + 1)].join(" ").replaceAll("2>&1", "");
+            return { piped: /[|;&\n]/.test(tail) };
+        }
+        // A cd later in the step, after ; & || or a newline, moves the steps after it somewhere this doesn't follow.
+        if (/[;|&\n{]\s*(cd|pushd|popd)\b/.test(segment))
+            dir = undefined;
+    }
+    return null;
+}
+function onlyFlags(words) {
+    for (let k = 0; k < words.length; k++) {
+        if (words[k] === "--reporter")
+            k++;
+        else if (!FLAGS.has(words[k]) && !words[k].startsWith("--reporter="))
+            return false;
+    }
+    return true;
+}
+export const isFullRun = (command, main, cwd, root) => parse(command, main, cwd, root) !== null;
+function outcome(output, isError, piped) {
+    // A "nothing ran" line only means zero when no part of the run counted a test: cargo's doc-tests print "running 0 tests" after the unit tests.
+    if (ZERO.some((r) => r.test(output)) && !PASS_COUNT.test(output) && !FAIL_COUNT.test(output))
+        return "zero";
+    if (!piped)
+        return isError === false ? "passed" : isError === true ? "failed" : "unknown";
+    if (FAILED.some((r) => r.test(output)))
+        return "failed";
+    return PASSED.some((r) => r.test(output)) ? "passed" : "unknown";
+}
+const text = (c) => typeof c === "string" ? c : Array.isArray(c) ? c.map((p) => (p?.type === "text" && typeof p.text === "string" ? p.text : "")).join("\n") : "";
+const parts = (e) => (Array.isArray(e.message?.content) ? e.message.content.filter((p) => p && typeof p === "object") : []);
+const time = (ts) => (typeof ts === "string" ? Date.parse(ts) : Number.NaN);
+function bashCall(e, p, main, root) {
+    if (e.type !== "assistant" || p.type !== "tool_use" || p.name !== "Bash" || typeof p.input?.command !== "string")
+        return null;
+    const shape = parse(p.input.command, main, typeof e.cwd === "string" ? e.cwd : undefined, root);
+    return shape && { command: p.input.command, ...shape, background: p.input.run_in_background === true };
+}
+function toolResult(e, p) {
+    const at = time(e.timestamp);
+    return e.type === "user" && p.type === "tool_result" && !Number.isNaN(at) ? { at, content: p.content, isError: p.is_error } : null;
+}
+// A background call's result only says it started.
+const run = (call, r) => ({
+    command: call.command,
+    at: r.at,
+    outcome: call.background ? "unknown" : outcome(text(r.content), r.isError, call.piped),
+});
+async function forward(file, main, root, deadline) {
+    const calls = new Map();
+    const runs = [];
+    for await (const e of jsonl(file)) {
+        if (Date.now() > deadline)
+            return null;
+        for (const p of parts(e)) {
+            const call = bashCall(e, p, main, root);
+            if (call)
+                calls.set(p.id, call);
+            const r = toolResult(e, p);
+            const made = r && calls.get(p.tool_use_id);
+            if (r && made)
+                runs.push(run(made, r));
+        }
+    }
+    return runs;
+}
+// Last entry first, so a result is seen before its call. Stops at the first entry older than since.
+async function backward(file, main, root, deadline, since) {
+    const results = new Map();
+    const runs = [];
+    for await (const e of jsonlBackward(file)) {
+        if (Date.now() > deadline)
+            return null;
+        if (time(e.timestamp) < since)
+            break;
+        for (const p of parts(e)) {
+            const r = toolResult(e, p);
+            if (r)
+                results.set(p.tool_use_id, r);
+            const call = bashCall(e, p, main, root);
+            const got = call && results.get(p.id);
+            if (call && got)
+                runs.push(run(call, got));
+        }
+    }
+    return runs;
+}
+// The full runs of main in the repo root in the session and its subagents, in time order; null once Date.now() passes the
+// deadline. With since (ms), only the runs from then on, read from the end of each file.
+export async function claudeRuns(transcriptPath, main, root, deadline, since) {
+    const runs = [];
+    for (const file of [transcriptPath, ...(await subagentFiles(transcriptPath))]) {
+        const found = since === undefined ? await forward(file, main, root, deadline) : await backward(file, main, root, deadline, since);
+        if (!found)
+            return null;
+        runs.push(...found);
+    }
+    if (Date.now() > deadline)
+        return null;
+    return runs.sort((a, b) => a.at - b.at);
+}
+// Codex records the directory as a file URL.
+function codexDir(cwd) {
+    if (typeof cwd !== "string")
+        return undefined;
+    try {
+        return cwd.startsWith("file:") ? fileURLToPath(cwd) : cwd;
+    }
+    catch {
+        return undefined;
+    }
+}
+// A finished command as a run of main, or null. Codex records the argv; the script is what the shell was given.
+function codexRun(e, main, root) {
+    const item = e.payload?.item;
+    const at = time(e.timestamp);
+    if (e.type !== "event_msg" || e.payload?.type !== "item_completed" || item?.type !== "CommandExecution" || Number.isNaN(at))
+        return null;
+    const argv = item.command;
+    const command = Array.isArray(argv) && /^-\w*c$/.test(String(argv[1])) ? argv[2] : null;
+    const shape = typeof command === "string" ? parse(command, main, codexDir(item.cwd), root) : null;
+    if (!shape || typeof command !== "string")
+        return null;
+    // No exit status recorded: nothing says it passed or failed.
+    const code = item.exit_code;
+    const output = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
+    return { command, at, outcome: outcome(output, typeof code === "number" ? code !== 0 : undefined, shape.piped) };
+}
+// The same for a Codex rollout, which has no subagent files.
+export async function codexRuns(rolloutPath, main, root, deadline, since) {
+    const runs = [];
+    for await (const e of since === undefined ? jsonl(rolloutPath) : jsonlBackward(rolloutPath)) {
+        if (Date.now() > deadline)
+            return null;
+        if (since !== undefined && time(e.timestamp) < since)
+            break;
+        const r = codexRun(e, main, root);
+        if (r)
+            runs.push(r);
+    }
+    return runs.sort((a, b) => a.at - b.at);
+}

package/dist/upload.js

@@ -74,6 +74,7 @@ async function uploadOne(cfg, sessionId, file, budget) {
         size_bytes: size,
         sha256: hash.digest("hex"),
         caption: file.caption,
+        path_label: file.path_label,
     }, budget);
     const id = json.evidence.id;
     if (json.status === "exists")