@phnx-labs/agents-cli 1.20.29 → 1.20.31

package/dist/lib/session/active.js

@@ -25,7 +25,10 @@ import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
 import { buildClaudeLabelMap } from './discover.js';
+import { latestSessionFileForCwd } from './db.js';
 import { extractSessionTopic } from './prompt.js';
+import { readSessionTail } from './tail.js';
+import { inferSessionState } from './state.js';
 const execFileAsync = promisify(execFile);
 const HOME = os.homedir();
 const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
@@ -42,6 +45,7 @@ const AGENT_CLI_NAMES = {
     gemini: 'gemini',
     'cursor-agent': 'cursor',
     opencode: 'opencode',
+    droid: 'droid',
 };
 function isPidAlive(pid) {
     if (!pid || pid < 1)
@@ -128,6 +132,66 @@ function classifyActivity(sessionFile) {
         return 'running';
     }
 }
+/**
+ * Locate the live transcript for an agent process. Claude files are keyed by
+ * cwd (+ optional session uuid); Codex files are date-partitioned, so we resolve
+ * the newest indexed Codex session for the cwd instead.
+ */
+function findSessionFileForKind(kind, cwd, sessionId) {
+    if (!cwd)
+        return undefined;
+    if (kind === 'claude')
+        return findClaudeSessionFile(cwd, sessionId);
+    if (kind === 'codex')
+        return latestSessionFileForCwd('codex', cwd);
+    return undefined;
+}
+/** Recover the session UUID from a transcript filename (Claude `<uuid>.jsonl`, Codex `rollout-…-<uuid>.jsonl`). */
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function sessionIdFromFile(file) {
+    if (!file)
+        return undefined;
+    return path.basename(file).match(UUID_RE)?.[0];
+}
+/** Infer live state from a session file's tail (Claude/Codex). Undefined when unreadable. */
+function computeLiveState(kind, sessionFile, cwd, pidAlive) {
+    if (!sessionFile)
+        return undefined;
+    const agent = kind === 'codex' ? 'codex' : 'claude';
+    const events = readSessionTail(sessionFile, agent);
+    if (events.length === 0)
+        return undefined;
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionFile).mtimeMs;
+    }
+    catch { /* vanished between calls */ }
+    return inferSessionState(events, { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS });
+}
+/** Map inferred activity onto the coarse ActiveStatus used by the renderer and counts. */
+function statusFromActivity(activity) {
+    return activity === 'working' ? 'running' : activity === 'waiting_input' ? 'input_required' : 'idle';
+}
+/**
+ * Fold a computed SessionState onto an active-session row: rich status +
+ * preview + PR/worktree/ticket badges. With no state (unreadable/non-Claude/
+ * Codex file) it degrades to the mtime-only classification.
+ */
+function applyState(base, state, fallbackFile) {
+    if (!state)
+        return { ...base, status: classifyActivity(fallbackFile) };
+    return {
+        ...base,
+        status: statusFromActivity(state.activity),
+        activity: state.activity,
+        awaitingReason: state.awaitingReason,
+        // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
+        preview: state.preview ?? base.preview,
+        pr: state.pr,
+        worktree: state.worktree,
+        ticket: state.ticket,
+    };
+}
 /**
  * Extract the first user message's content from a Claude JSONL file.
  * Reads only the first ~50 lines for speed, since the user message is
@@ -207,24 +271,22 @@ export async function listTeamsActive() {
     const running = await mgr.listRunning();
     return running.map((a) => {
         const sessionId = a.parentSessionId ?? a.remoteSessionId ?? undefined;
-        const sessionFile = a.agentType === 'claude' && a.cwd
-            ? findClaudeSessionFile(a.cwd, sessionId ?? undefined)
-            : undefined;
+        const sessionFile = findSessionFileForKind(a.agentType, a.cwd ?? undefined, sessionId ?? undefined);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        return {
+        const state = computeLiveState(a.agentType, sessionFile, a.cwd ?? undefined, a.pid ? isPidAlive(a.pid) : true);
+        return applyState({
             context: 'teams',
             kind: a.agentType,
             pid: a.pid ?? undefined,
-            sessionId,
+            sessionId: sessionId ?? sessionIdFromFile(sessionFile),
             cwd: a.cwd ?? undefined,
             label: a.name ?? undefined,
             topic,
             sessionFile,
             startedAtMs: a.startedAt.getTime(),
-            status: classifyActivity(sessionFile),
             teamName: a.taskName,
             agentId: a.agentId,
-        };
+        }, state, sessionFile);
     });
 }
 /** Live editor-terminal agents across every IDE window. */
@@ -240,27 +302,25 @@ export async function listTerminalsActive() {
     // Build label map from Claude's sessions/*.json for /rename support
     const labelMap = buildClaudeLabelMap();
     return entries.map((t) => {
-        const sessionFile = t.kind === 'claude' && t.cwd
-            ? findClaudeSessionFile(t.cwd, t.sessionId)
-            : undefined;
+        const sessionFile = findSessionFileForKind(t.kind, t.cwd ?? undefined, t.sessionId);
         // Prefer label from live terminal, fall back to Claude's session label
         const label = t.label ?? (t.sessionId ? labelMap.get(t.sessionId) : undefined) ?? undefined;
         // Extract topic from session file (first meaningful user message)
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        return {
+        const state = computeLiveState(t.kind, sessionFile, t.cwd ?? undefined, isPidAlive(t.pid));
+        return applyState({
             context: 'terminal',
             kind: t.kind,
             host: detectHost(t.pid, procByPid),
             pid: t.pid,
-            sessionId: t.sessionId,
+            sessionId: t.sessionId ?? sessionIdFromFile(sessionFile),
             cwd: t.cwd ?? undefined,
             label,
             topic,
             sessionFile,
             startedAtMs: t.startedAtMs,
-            status: classifyActivity(sessionFile),
             windowId: t.windowId,
-        };
+        }, state, sessionFile);
     });
 }
 /** Cloud tasks still in a non-terminal state. `tasks.db` may not exist; that's fine. */
@@ -439,20 +499,21 @@ export async function listUnattributedActive(attributed) {
     for (let i = 0; i < candidates.length; i++) {
         const { pid, kind } = candidates[i];
         const cwd = cwds[i];
-        const sessionFile = kind === 'claude' && cwd ? findClaudeSessionFile(cwd) : undefined;
+        const sessionFile = findSessionFileForKind(kind, cwd);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
-        out.push({
+        const state = computeLiveState(kind, sessionFile, cwd, true);
+        out.push(applyState({
             context,
             kind,
             host,
             pid,
             cwd,
+            sessionId: sessionIdFromFile(sessionFile),
             topic,
             sessionFile,
-            status: classifyActivity(sessionFile),
-        });
+        }, state, sessionFile));
     }
     return out;
 }
@@ -475,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/cloud.js

@@ -44,6 +44,8 @@ function agentToFormat(agent) {
         return 'codex';
     if (agent === 'rush')
         return 'rush';
+    if (agent === 'droid')
+        return 'droid';
     return null;
 }
 export function assertContained(candidate, rootDir) {

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

@@ -30,6 +30,10 @@ export interface SessionRow {
     file_size: number | null;
     scanned_at: number | null;
     is_team_origin: number;
+    pr_url: string | null;
+    pr_number: number | null;
+    worktree_slug: string | null;
+    ticket_id: string | null;
 }
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
@@ -133,6 +137,13 @@ export declare function syncLabels(labelMap: Map<string, string | null>): number
  * Returns the number of rows updated.
  */
 export declare function syncTopics(topicMap: Map<string, string>): number;
+/**
+ * Newest indexed session file for an agent working in `cwd`. Lets the live
+ * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
+ * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
+ * session hasn't been scanned yet — the caller degrades to no live state.
+ */
+export declare function latestSessionFileForCwd(agent: SessionAgentId, cwd: string): string | undefined;
 /** Query sessions from the database, applying filters and ordering by timestamp descending. */
 export declare function querySessions(options?: QueryOptions): SessionMeta[];
 /** Count sessions matching the given filter options. */

package/dist/lib/session/db.js

@@ -13,7 +13,7 @@ import { getSessionsDir, getSessionsDbPath } from '../state.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 6;
+const SCHEMA_VERSION = 7;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -59,7 +59,11 @@ CREATE TABLE IF NOT EXISTS sessions (
   file_mtime_ms INTEGER,
   file_size INTEGER,
   scanned_at INTEGER,
-  is_team_origin INTEGER DEFAULT 0
+  is_team_origin INTEGER DEFAULT 0,
+  pr_url TEXT,
+  pr_number INTEGER,
+  worktree_slug TEXT,
+  ticket_id TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -157,6 +161,21 @@ function migrateSchema(db, fromVersion) {
         }
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 7) {
+        // v6 → v7: the session-state engine now persists durable signals (PR opened,
+        // worktree, tracker ticket) at scan time. Add the columns and force a full
+        // rescan so every existing session gets them populated.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'pr_url'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN pr_url TEXT`);
+        if (!cols.some(c => c.name === 'pr_number'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN pr_number INTEGER`);
+        if (!cols.some(c => c.name === 'worktree_slug'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN worktree_slug TEXT`);
+        if (!cols.some(c => c.name === 'ticket_id'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN ticket_id TEXT`);
+        db.exec(`DELETE FROM scan_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -367,12 +386,14 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, version, account, timestamp,
     project, cwd, git_branch, topic, label, message_count, token_count,
     cost_usd, duration_ms,
-    file_path, file_mtime_ms, file_size, scanned_at, is_team_origin
+    file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
+    pr_url, pr_number, worktree_slug, ticket_id
   ) VALUES (
     @id, @short_id, @agent, @version, @account, @timestamp,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @cost_usd, @duration_ms,
-    @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin
+    @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
+    @pr_url, @pr_number, @worktree_slug, @ticket_id
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -393,7 +414,11 @@ const upsertSessionStmt = (db) => db.prepare(`
     file_mtime_ms = excluded.file_mtime_ms,
     file_size = excluded.file_size,
     scanned_at = excluded.scanned_at,
-    is_team_origin = excluded.is_team_origin
+    is_team_origin = excluded.is_team_origin,
+    pr_url = excluded.pr_url,
+    pr_number = excluded.pr_number,
+    worktree_slug = excluded.worktree_slug,
+    ticket_id = excluded.ticket_id
 `);
 const deleteTextStmt = (db) => db.prepare(`DELETE FROM session_text WHERE session_id = ?`);
 const insertTextStmt = (db) => db.prepare(`INSERT INTO session_text (session_id, label, topic, project, content) VALUES (?, ?, ?, ?, ?)`);
@@ -436,6 +461,10 @@ export function upsertSession(meta, content, scan) {
         file_size: scan?.fileSize ?? null,
         scanned_at: Date.now(),
         is_team_origin: meta.isTeamOrigin ? 1 : 0,
+        pr_url: meta.prUrl ?? null,
+        pr_number: meta.prNumber ?? null,
+        worktree_slug: meta.worktreeSlug ?? null,
+        ticket_id: meta.ticketId ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -511,6 +540,10 @@ export function upsertSessionsBatch(entries) {
                 file_size: scan?.fileSize ?? null,
                 scanned_at: now,
                 is_team_origin: meta.isTeamOrigin ? 1 : 0,
+                pr_url: meta.prUrl ?? null,
+                pr_number: meta.prNumber ?? null,
+                worktree_slug: meta.worktreeSlug ?? null,
+                ticket_id: meta.ticketId ?? null,
             });
             delText.run(meta.id);
             insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
@@ -621,8 +654,32 @@ function rowToMeta(row) {
         topic: row.topic ?? undefined,
         label: row.label ?? undefined,
         isTeamOrigin: row.is_team_origin === 1,
+        prUrl: row.pr_url ?? undefined,
+        prNumber: row.pr_number ?? undefined,
+        worktreeSlug: row.worktree_slug ?? undefined,
+        ticketId: row.ticket_id ?? undefined,
     };
 }
+/**
+ * Newest indexed session file for an agent working in `cwd`. Lets the live
+ * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
+ * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
+ * session hasn't been scanned yet — the caller degrades to no live state.
+ */
+export function latestSessionFileForCwd(agent, cwd) {
+    if (!cwd)
+        return undefined;
+    let normalized = cwd;
+    try {
+        normalized = fs.realpathSync(cwd);
+    }
+    catch { /* use as-is */ }
+    const db = getDB();
+    const row = db
+        .prepare(`SELECT file_path FROM sessions WHERE agent = ? AND cwd = ? ORDER BY timestamp DESC LIMIT 1`)
+        .get(agent, normalized);
+    return row?.file_path;
+}
 /** Build a parameterized WHERE clause from query options. */
 function buildSessionWhere(options) {
     const where = [];

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/discover.d.ts

@@ -57,6 +57,11 @@ interface ClaudeSessionScan {
     entrypoint?: string;
     /** Concatenated user message text, ready to hand to FTS5. */
     contentText?: string;
+    /** Durable state signals persisted to the index by the session-state engine. */
+    prUrl?: string;
+    prNumber?: number;
+    worktreeSlug?: string;
+    ticketId?: string;
 }
 /**
  * Discover sessions. Scans only files whose (mtime, size) have changed since