@phnx-labs/agents-cli 1.20.30 → 1.20.32

package/dist/lib/devices/pending.js

@@ -0,0 +1,103 @@
+/**
+ * "Pending device" sentinels.
+ *
+ * When the daemon's tailscale probe finds a node that is neither registered nor
+ * ignored, it drops a sentinel file under ~/.agents/.cache/state/devices-pending/
+ * — the same filesystem-signal pattern the attention hook uses for the menu bar.
+ * The Swift helper polls that dir every 10s and renders a "NEW DEVICES" section
+ * with Register / Ignore. The file NAME is the device name; the file CONTENT is
+ * the platform (one line), so the tray can show "zion (macos)" without opening
+ * the registry.
+ *
+ * The daemon owns writes (reconcile to match the current pending set); the CLI
+ * `agents devices register|ignore` clears a single sentinel the moment the user
+ * acts, so the badge updates immediately instead of waiting for the next probe.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getDevicesPendingDir } from '../state.js';
+/** Device-name sentinels must be safe filenames (no path traversal). The device
+ * name charset is already the ssh-alias set, but guard defensively. */
+function isSafeName(name) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
+}
+/**
+ * Make the sentinel dir exactly match `pending`: create a file per pending
+ * device (content = platform), and delete any leftover sentinel whose device is
+ * no longer pending (it got registered, ignored, or left the tailnet). Best-
+ * effort — a filesystem error here must never crash the daemon, so callers pass
+ * this through their existing try/catch.
+ */
+export function reconcilePendingSentinels(pending) {
+    const dir = getDevicesPendingDir();
+    const want = new Map(pending.filter((p) => isSafeName(p.name)).map((p) => [p.name, p.platform]));
+    // Whole body is best-effort: a filesystem error here must never propagate into
+    // the daemon loop or `agents sync`. The top-level mkdir/readdir are guarded
+    // too, so no caller needs its own try/catch.
+    let existing;
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        existing = fs.readdirSync(dir).filter((n) => !n.startsWith('.'));
+    }
+    catch {
+        return;
+    }
+    // Remove sentinels that are no longer pending.
+    for (const name of existing) {
+        if (!want.has(name)) {
+            try {
+                fs.unlinkSync(path.join(dir, name));
+            }
+            catch { /* already gone */ }
+        }
+    }
+    // Write/refresh the sentinels that should exist.
+    for (const [name, platform] of want) {
+        const p = path.join(dir, name);
+        const body = `${platform}\n`;
+        // Only write when missing or changed, to avoid needless mtime churn.
+        let current = null;
+        try {
+            current = fs.readFileSync(p, 'utf-8');
+        }
+        catch {
+            current = null;
+        }
+        if (current !== body) {
+            try {
+                fs.writeFileSync(p, body);
+            }
+            catch { /* best-effort */ }
+        }
+    }
+}
+/** Remove one device's pending sentinel (after the user registers or ignores it).
+ * No-op if it doesn't exist. */
+export function clearPendingSentinel(name) {
+    if (!isSafeName(name))
+        return;
+    try {
+        fs.unlinkSync(path.join(getDevicesPendingDir(), name));
+    }
+    catch { /* already gone */ }
+}
+/** Read the current pending sentinels (name + platform). Used by tests and any
+ * TS-side consumer; the menu-bar helper reads the dir directly in Swift. */
+export function readPendingSentinels() {
+    const dir = getDevicesPendingDir();
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => !n.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+    return names.map((name) => {
+        let platform = 'unknown';
+        try {
+            platform = fs.readFileSync(path.join(dir, name), 'utf-8').trim() || 'unknown';
+        }
+        catch { /* keep default */ }
+        return { name, platform };
+    });
+}

package/dist/lib/devices/registry.d.ts

@@ -76,3 +76,14 @@ export interface DeviceInput {
 export declare function upsertDevice(name: string, input: DeviceInput): Promise<DeviceProfile>;
 /** Remove a device. Returns false if it was not registered. */
 export declare function removeDevice(name: string): Promise<boolean>;
+/** Load the set of ignored node names. Missing file => empty set. A malformed
+ * file is a hard error for the same reason the registry is: silently returning
+ * [] would let the next write wipe the user's dismissals. */
+export declare function loadIgnored(): Promise<Set<string>>;
+/** True if `name` is on the ignore-list. */
+export declare function isIgnored(name: string): Promise<boolean>;
+/** Add a node name to the ignore-list. Idempotent. Returns the resulting set. */
+export declare function addIgnored(name: string): Promise<Set<string>>;
+/** Remove a node name from the ignore-list (un-ignore). Returns false if it was
+ * not ignored. */
+export declare function removeIgnored(name: string): Promise<boolean>;

package/dist/lib/devices/registry.js

@@ -18,7 +18,7 @@ import * as fsSync from 'fs';
 import * as path from 'path';
 import { randomBytes } from 'crypto';
 import lockfile from 'proper-lockfile';
-import { getDevicesRegistryPath } from '../state.js';
+import { getDevicesRegistryPath, getDevicesIgnoredPath } from '../state.js';
 function registryPath() {
     return getDevicesRegistryPath();
 }
@@ -166,3 +166,55 @@ export async function removeDevice(name) {
         return true;
     });
 }
+function ignoredPath() {
+    return getDevicesIgnoredPath();
+}
+/** Load the set of ignored node names. Missing file => empty set. A malformed
+ * file is a hard error for the same reason the registry is: silently returning
+ * [] would let the next write wipe the user's dismissals. */
+export async function loadIgnored() {
+    const p = ignoredPath();
+    let raw;
+    try {
+        raw = await fs.readFile(p, 'utf-8');
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT')
+            return new Set();
+        throw err;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return new Set(Array.isArray(parsed.ignored) ? parsed.ignored : []);
+    }
+    catch (err) {
+        throw new Error(`Device ignore-list corrupted at ${p}: ${err?.message ?? err}. Inspect and restore from backup.`);
+    }
+}
+/** True if `name` is on the ignore-list. */
+export async function isIgnored(name) {
+    return (await loadIgnored()).has(name);
+}
+/** Add a node name to the ignore-list. Idempotent. Returns the resulting set. */
+export async function addIgnored(name) {
+    assertValidDeviceName(name);
+    const p = ignoredPath();
+    return withRegistryLock(p, async () => {
+        const set = await loadIgnored();
+        set.add(name);
+        await atomicWriteJson(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
+        return set;
+    });
+}
+/** Remove a node name from the ignore-list (un-ignore). Returns false if it was
+ * not ignored. */
+export async function removeIgnored(name) {
+    const p = ignoredPath();
+    return withRegistryLock(p, async () => {
+        const set = await loadIgnored();
+        if (!set.delete(name))
+            return false;
+        await atomicWriteJson(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
+        return true;
+    });
+}

package/dist/lib/devices/sync.d.ts

@@ -0,0 +1,61 @@
+import { type TailscaleNode } from './tailscale.js';
+import type { PendingDevice } from './pending.js';
+/**
+ * bootstrap — register every non-ignored node (opt-out). First-run `agents
+ *   setup` and manual `agents devices sync`, so the fleet is usable out of box.
+ * refresh — only refresh reachability of already-registered nodes; a brand-new
+ *   node is NOT auto-added, it is surfaced as `pending` for the user to approve
+ *   (opt-in). Ongoing autosync and the daemon probe use this, so newcomers flow
+ *   through the menu-bar "NEW DEVICES → Register / Ignore" gate instead of
+ *   silently landing in the registry.
+ */
+export type DeviceSyncMode = 'bootstrap' | 'refresh';
+export interface DeviceSyncResult {
+    /** False when discovery could not run (e.g. tailscale absent) in soft mode. */
+    ok: boolean;
+    /** Number of tailscale nodes upserted into the registry. */
+    synced: number;
+    /** Nodes discovered but neither registered-before nor ignored (name+platform). */
+    pending: PendingDevice[];
+    /** Populated when ok is false: why discovery was skipped. */
+    reason?: string;
+}
+/**
+ * Node names present on the tailnet but neither already in the registry nor on
+ * the ignore-list — i.e. genuinely new devices worth surfacing. Pure so the
+ * flag matrix is unit-testable without a live tailnet.
+ */
+export declare function computePendingDevices(nodes: TailscaleNode[], registered: Iterable<string>, ignored: Iterable<string>): string[];
+/**
+ * Which discovered nodes to upsert this run — the mode-defining decision, pure
+ * so it is unit-testable without a tailnet. Ignored nodes are always skipped.
+ * In `refresh` mode a node that isn't already registered is skipped too (it
+ * stays pending for approval); `bootstrap` includes every non-ignored node.
+ */
+export declare function selectNodesToUpsert(nodes: TailscaleNode[], registered: Set<string>, ignored: Set<string>, mode: DeviceSyncMode): TailscaleNode[];
+/**
+ * Ingest `tailscale status --json` into the registry. In soft mode a missing
+ * tailscale binary / unreachable daemon resolves to `{ ok: false }` instead of
+ * throwing, so callers wiring this into setup/sync never abort the whole run.
+ * The `pending` list is computed against the registry state BEFORE this sync so
+ * "new" means "not previously registered and not ignored".
+ */
+export declare function runDeviceSync(opts?: {
+    soft?: boolean;
+    mode?: DeviceSyncMode;
+}): Promise<DeviceSyncResult>;
+/**
+ * The register/remove/ignore decision for the interactive curation picker.
+ * Pure so the highest-risk reconcile logic is unit-testable without a tailnet
+ * or a live prompt. `keep` is the set the user left checked; everything else is
+ * dismissed. Checked => register (and un-ignore if it was ignored). Unchecked
+ * => remove from the registry if it was there, and ignore it so auto-sync never
+ * re-adds it.
+ */
+export interface DeviceReconciliation {
+    toRegister: string[];
+    toUnignore: string[];
+    toRemove: string[];
+    toIgnore: string[];
+}
+export declare function planDeviceReconciliation(allNames: Iterable<string>, keep: Iterable<string>, registered: Iterable<string>, ignored: Iterable<string>): DeviceReconciliation;

package/dist/lib/devices/sync.js

@@ -0,0 +1,101 @@
+/**
+ * Reusable device discovery.
+ *
+ * `agents devices sync` was the only thing that ever populated the registry,
+ * and it was purely user-invoked — so the registry sat empty until someone
+ * remembered to run it. This module extracts the ingest so it can be triggered
+ * automatically (from `agents sync` and `agents setup`) without duplicating the
+ * tailscale-parse-and-upsert loop, and exposes the pure pending-device diff the
+ * curation picker and the menu-bar probe both need.
+ *
+ * Two failure modes, one function:
+ *   - hard (default): the CLI `agents devices sync` action wants a clear error
+ *     and a non-zero exit when tailscale is missing.
+ *   - soft (`soft: true`): auto-callers must never abort setup/sync because a
+ *     machine has no tailscale — they get a result with `ok: false` instead.
+ */
+import { loadDevices, loadIgnored, upsertDevice, } from './registry.js';
+import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from './tailscale.js';
+/**
+ * Node names present on the tailnet but neither already in the registry nor on
+ * the ignore-list — i.e. genuinely new devices worth surfacing. Pure so the
+ * flag matrix is unit-testable without a live tailnet.
+ */
+export function computePendingDevices(nodes, registered, ignored) {
+    const known = new Set(registered);
+    const skip = new Set(ignored);
+    return nodes
+        .map((n) => n.name)
+        .filter((name) => !known.has(name) && !skip.has(name));
+}
+/**
+ * Which discovered nodes to upsert this run — the mode-defining decision, pure
+ * so it is unit-testable without a tailnet. Ignored nodes are always skipped.
+ * In `refresh` mode a node that isn't already registered is skipped too (it
+ * stays pending for approval); `bootstrap` includes every non-ignored node.
+ */
+export function selectNodesToUpsert(nodes, registered, ignored, mode) {
+    return nodes.filter((n) => {
+        if (ignored.has(n.name))
+            return false;
+        if (mode === 'refresh' && !registered.has(n.name))
+            return false;
+        return true;
+    });
+}
+/**
+ * Ingest `tailscale status --json` into the registry. In soft mode a missing
+ * tailscale binary / unreachable daemon resolves to `{ ok: false }` instead of
+ * throwing, so callers wiring this into setup/sync never abort the whole run.
+ * The `pending` list is computed against the registry state BEFORE this sync so
+ * "new" means "not previously registered and not ignored".
+ */
+export async function runDeviceSync(opts = {}) {
+    const mode = opts.mode ?? 'bootstrap';
+    // Soft mode must be non-fatal for ANY failure, not just a missing tailscale:
+    // a corrupted registry/ignore file (both throw by design), a disk error, or
+    // registry lock contention (plausible when many agents SessionStart-autosync
+    // the same host at once) would otherwise abort the whole `agents sync`. The
+    // whole body is inside the guard so the "never a sync failure" promise holds.
+    try {
+        const nodes = parseTailscaleStatus(tailscaleStatusJson());
+        const [registeredBefore, ignored] = await Promise.all([loadDevices(), loadIgnored()]);
+        const registered = new Set(Object.keys(registeredBefore));
+        const pendingNames = computePendingDevices(nodes, registered, ignored);
+        const byName = new Map(nodes.map((n) => [n.name, n]));
+        const pending = pendingNames.map((name) => ({
+            name,
+            platform: byName.get(name)?.platform ?? 'unknown',
+        }));
+        const toUpsert = selectNodesToUpsert(nodes, registered, ignored, mode);
+        for (const node of toUpsert) {
+            await upsertDevice(node.name, nodeToDeviceInput(node));
+        }
+        return { ok: true, synced: toUpsert.length, pending };
+    }
+    catch (err) {
+        if (opts.soft) {
+            return { ok: false, synced: 0, pending: [], reason: err?.message ?? String(err) };
+        }
+        throw err;
+    }
+}
+export function planDeviceReconciliation(allNames, keep, registered, ignored) {
+    const keepSet = new Set(keep);
+    const regSet = new Set(registered);
+    const ignSet = new Set(ignored);
+    const out = { toRegister: [], toUnignore: [], toRemove: [], toIgnore: [] };
+    for (const name of allNames) {
+        if (keepSet.has(name)) {
+            out.toRegister.push(name);
+            if (ignSet.has(name))
+                out.toUnignore.push(name);
+        }
+        else {
+            if (regSet.has(name))
+                out.toRemove.push(name);
+            out.toIgnore.push(name);
+        }
+    }
+    return out;
+}

package/dist/lib/session/active.d.ts

@@ -28,6 +28,8 @@ export interface ActiveSession {
     sessionFile?: string;
     startedAtMs?: number;
     status: ActiveStatus;
+    /** How many live PIDs resolve to this same session (subagents/forks). 1 unless collapsed. */
+    pidCount?: number;
     teamName?: string;
     agentId?: string;
     cloudProvider?: string;

package/dist/lib/session/active.js

@@ -536,5 +536,33 @@ export async function getActiveSessions(opts = {}) {
         if (s.pid)
             knownPids.add(s.pid);
     const unattributed = opts.skipHeadless ? [] : await listUnattributedActive(knownPids);
-    return [...teams, ...terminals, ...cloud, ...unattributed];
+    return dedupeBySession([...teams, ...terminals, ...cloud, ...unattributed]);
+}
+/**
+ * Collapse rows that resolve to the *same* session — a session with many
+ * subagent/fork PIDs (all matched to one transcript file) would otherwise print
+ * dozens of identical rows. Keyed by session id (falling back to the file), the
+ * first row wins and carries a `pidCount`. Rows with no session identity (cloud,
+ * unresolved headless) pass through untouched.
+ */
+function dedupeBySession(sessions) {
+    const out = [];
+    const byKey = new Map();
+    for (const s of sessions) {
+        const key = s.sessionId || s.sessionFile;
+        if (!key) {
+            out.push(s);
+            continue;
+        }
+        const existing = byKey.get(key);
+        if (existing) {
+            existing.pidCount = (existing.pidCount ?? 1) + 1;
+        }
+        else {
+            s.pidCount = 1;
+            byKey.set(key, s);
+            out.push(s);
+        }
+    }
+    return out;
 }

package/dist/lib/session/digest.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Catch-up digest extractors.
+ *
+ * Pure functions that turn a session's events into the signals a developer needs
+ * to reload a task fast when switching between many agents: which files changed
+ * and how (created / modified / deleted), which tools dominated the work, and the
+ * last test/build result. Consumed by the single-session view and the picker
+ * preview. No I/O — fully unit-testable.
+ */
+import type { SessionEvent } from './types.js';
+export type FileOp = 'created' | 'modified' | 'deleted';
+export interface FileChange {
+    path: string;
+    op: FileOp;
+}
+/** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
+export declare function extractDeletedPaths(command: string): string[];
+/**
+ * Classify every touched file as created / modified / deleted from the event
+ * stream. Heuristics: a Write to a path never previously Read and not seen
+ * before is a *creation*; an Edit (or a Write to a known/read path) is a
+ * *modification*; a path in an `rm`/`git rm` command is a *deletion* (and wins
+ * over create/modify — a created-then-deleted file nets to gone). Plan files
+ * (`.claude/plans/*.md`) are excluded; they're surfaced by detectPlan.
+ */
+export declare function classifyFileChanges(events: SessionEvent[]): FileChange[];
+/** Net change summary: counts per op. */
+export declare function changeCounts(changes: FileChange[]): {
+    created: number;
+    modified: number;
+    deleted: number;
+};
+/** Tool histogram sorted highest-first, capped to `top` entries. */
+export declare function toolHistogram(toolCounts: Record<string, number>, top?: number): Array<{
+    tool: string;
+    count: number;
+}>;
+export interface TestResult {
+    runner: string;
+    passed?: number;
+    failed?: number;
+    /** True when we could parse a pass/fail verdict. */
+    ok: boolean;
+    ts: number;
+}
+/**
+ * The most recent test/build run and its verdict. Correlates a runner command
+ * (tool_use) with the next tool_result's output. Returns undefined if none ran.
+ */
+export declare function detectTestResult(events: SessionEvent[]): TestResult | undefined;

package/dist/lib/session/digest.js

@@ -0,0 +1,170 @@
+/**
+ * Catch-up digest extractors.
+ *
+ * Pure functions that turn a session's events into the signals a developer needs
+ * to reload a task fast when switching between many agents: which files changed
+ * and how (created / modified / deleted), which tools dominated the work, and the
+ * last test/build result. Consumed by the single-session view and the picker
+ * preview. No I/O — fully unit-testable.
+ */
+// Tool vocab mirrors parse.ts / render.ts so classification matches what those
+// modules already recognize across Claude/Codex/others.
+const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
+const WRITE_TOOLS = new Set(['Write', 'write_file', 'create_file']);
+const EDIT_TOOLS = new Set(['Edit', 'edit_file', 'replace', 'patch', 'MultiEdit', 'apply_patch']);
+/** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
+export function extractDeletedPaths(command) {
+    const out = [];
+    // Split on && ; | to inspect each simple command separately.
+    for (const seg of command.split(/&&|\|\||;|\|/)) {
+        const m = seg.trim().match(/^(?:sudo\s+)?(?:git\s+rm|rm|unlink)\s+(.+)$/);
+        if (!m)
+            continue;
+        for (const tok of m[1].split(/\s+/)) {
+            if (tok.startsWith('-'))
+                continue; // flags (-r, -f, --force)
+            if (/[*?{}]/.test(tok))
+                continue; // globs — too imprecise to attribute
+            out.push(tok.replace(/^['"]|['"]$/g, '')); // unquote
+        }
+    }
+    return out;
+}
+/**
+ * Classify every touched file as created / modified / deleted from the event
+ * stream. Heuristics: a Write to a path never previously Read and not seen
+ * before is a *creation*; an Edit (or a Write to a known/read path) is a
+ * *modification*; a path in an `rm`/`git rm` command is a *deletion* (and wins
+ * over create/modify — a created-then-deleted file nets to gone). Plan files
+ * (`.claude/plans/*.md`) are excluded; they're surfaced by detectPlan.
+ */
+export function classifyFileChanges(events) {
+    const readBefore = new Set();
+    const created = new Set();
+    const modified = new Set();
+    const deleted = new Set();
+    const seen = new Set();
+    for (const e of events) {
+        if (e.type !== 'tool_use' || e._local)
+            continue;
+        if (e.command)
+            for (const d of extractDeletedPaths(e.command))
+                deleted.add(d);
+        const tool = e.tool || '';
+        const args = e.args || {};
+        const p = e.path || args.file_path || args.path || '';
+        if (!p)
+            continue;
+        if (p.includes('.claude/plans/') && p.endsWith('.md'))
+            continue;
+        if (READ_TOOLS.has(tool)) {
+            readBefore.add(p);
+        }
+        else if (WRITE_TOOLS.has(tool)) {
+            if (!seen.has(p) && !readBefore.has(p))
+                created.add(p);
+            else
+                modified.add(p);
+            seen.add(p);
+            deleted.delete(p); // a write after a delete recreates the file
+        }
+        else if (EDIT_TOOLS.has(tool)) {
+            modified.add(p);
+            seen.add(p);
+            deleted.delete(p);
+        }
+    }
+    const out = [];
+    for (const p of created)
+        if (!deleted.has(p))
+            out.push({ path: p, op: 'created' });
+    for (const p of modified)
+        if (!created.has(p) && !deleted.has(p))
+            out.push({ path: p, op: 'modified' });
+    for (const p of deleted)
+        out.push({ path: p, op: 'deleted' });
+    return out;
+}
+/** Net change summary: counts per op. */
+export function changeCounts(changes) {
+    const c = { created: 0, modified: 0, deleted: 0 };
+    for (const ch of changes)
+        c[ch.op]++;
+    return c;
+}
+/** Tool histogram sorted highest-first, capped to `top` entries. */
+export function toolHistogram(toolCounts, top = 8) {
+    return Object.entries(toolCounts)
+        .map(([tool, count]) => ({ tool, count }))
+        .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
+        .slice(0, top);
+}
+/** Recognized test/build runners → the label we show. */
+const TEST_RUNNERS = [
+    { re: /\b((?:bun|npm|yarn|pnpm)\s+(?:run\s+)?test|vitest|jest)\b/, label: 'tests' },
+    { re: /\bpytest\b/, label: 'pytest' },
+    { re: /\bgo\s+test\b/, label: 'go test' },
+    { re: /\bcargo\s+test\b/, label: 'cargo test' },
+    { re: /\b(tsc|tsc\s+--noEmit)\b/, label: 'tsc' },
+];
+/** Parse pass/fail counts from common runner output. */
+function parseTestOutput(runner, output) {
+    // vitest/jest/bun: "N passed", "N failed"; pytest: "N passed, N failed".
+    // Take the LAST occurrence — runners print a per-file line first, then the
+    // authoritative aggregate ("Tests 4 failed | 294 passed") at the end.
+    const lastNum = (re) => {
+        let m;
+        let val;
+        const g = new RegExp(re.source, 'gi');
+        while ((m = g.exec(output)) !== null)
+            val = +m[1];
+        return val;
+    };
+    const passed = lastNum(/(\d+)\s+pass(?:ed)?/);
+    const failed = lastNum(/(\d+)\s+fail(?:ed|ures?)?/);
+    if (passed !== undefined || failed !== undefined) {
+        return { passed, failed, ok: true };
+    }
+    // tsc: no news is good news; "error TSxxxx" means failure.
+    if (runner === 'tsc') {
+        const errs = output.match(/error\s+TS\d+/gi);
+        return { failed: errs ? errs.length : 0, ok: true };
+    }
+    // go test: no pass/fail counts — uses `--- PASS/FAIL:` lines and an ok/FAIL
+    // summary. Count the per-test markers; fall back to the summary verdict.
+    if (runner === 'go test') {
+        const passCount = (output.match(/---\s+PASS/gi) || []).length;
+        const failCount = (output.match(/---\s+FAIL/gi) || []).length;
+        const sawFail = failCount > 0 || /(^|\s)FAIL($|\s)/.test(output);
+        const sawOk = /(^|\s)(ok|PASS)($|\s)/.test(output);
+        if (sawFail || sawOk) {
+            return { passed: passCount || undefined, failed: sawFail ? failCount || 1 : 0, ok: true };
+        }
+    }
+    return { ok: false };
+}
+/**
+ * The most recent test/build run and its verdict. Correlates a runner command
+ * (tool_use) with the next tool_result's output. Returns undefined if none ran.
+ */
+export function detectTestResult(events) {
+    let pending = null;
+    let last;
+    for (const e of events) {
+        const ts = new Date(e.timestamp).getTime() || 0;
+        if (e.type === 'tool_use' && e.command) {
+            const hit = TEST_RUNNERS.find(r => r.re.test(e.command));
+            pending = hit ? { runner: hit.label, ts } : pending;
+        }
+        else if (e.type === 'tool_result' && pending) {
+            const parsed = parseTestOutput(pending.runner, e.output || '');
+            last = { runner: pending.runner, ts: pending.ts, ...parsed };
+            pending = null;
+        }
+        else if (e.type === 'error' && pending) {
+            last = { runner: pending.runner, ts: pending.ts, ok: true, failed: 1 };
+            pending = null;
+        }
+    }
+    return last;
+}

package/dist/lib/session/render.d.ts

@@ -49,6 +49,8 @@ export interface SessionStats {
     userTurns: number;
     assistantTurns: number;
     toolCount: number;
+    /** Per-tool call counts (histogram), highest first when rendered. */
+    toolCounts: Record<string, number>;
     errorCount: number;
     outputTokens: number;
     cacheReadTokens: number;