@phnx-labs/agents-cli 1.20.77 → 1.20.82

package/dist/lib/session/db.js

@@ -2,7 +2,7 @@
  * SQLite-backed session index and full-text search.
  *
  * Stores session metadata and user-prompt text in a WAL-mode SQLite database
- * at ~/.agents/sessions/sessions.db. Provides incremental upsert, scan-stamp
+ * at ~/.agents/.history/sessions/sessions.db. Provides incremental upsert, scan-stamp
  * ledger (mtime/size tracking to skip unchanged files), FTS5 search with
  * BM25 ranking, and label-first search for /rename'd sessions.
  */
@@ -12,10 +12,12 @@ import Database from '../sqlite.js';
 import { parseSession } from './parse.js';
 import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { getSessionsDir, getSessionsDbPath } from '../state.js';
+import { machineForSessionFile } from './origin-machine.js';
+import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 17;
+const SCHEMA_VERSION = 20;
 /**
  * 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`
@@ -62,6 +64,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   output_tokens INTEGER,
   cost_usd REAL,
   duration_ms INTEGER,
+  model TEXT,
   file_path TEXT NOT NULL,
   file_mtime_ms INTEGER,
   file_size INTEGER,
@@ -72,16 +75,21 @@ CREATE TABLE IF NOT EXISTS sessions (
   worktree_slug TEXT,
   ticket_id TEXT,
   plan TEXT,
+  machine TEXT,
   todos TEXT,
   recent_directories_touched TEXT,
   linear_project TEXT,
-  linear_project_url TEXT
+  linear_project_url TEXT,
+  actor TEXT,
+  initiated_by TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
 CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent);
 CREATE INDEX IF NOT EXISTS idx_sessions_file_path ON sessions(file_path);
 CREATE INDEX IF NOT EXISTS idx_sessions_short_id ON sessions(short_id);
+-- idx_sessions_machine_ts / idx_sessions_agent_ts are created after migration
+-- v17 guarantees the machine column exists (same pattern as last_activity).
 
 CREATE VIRTUAL TABLE IF NOT EXISTS session_text USING fts5(
   session_id UNINDEXED,
@@ -323,6 +331,7 @@ function migrateSchema(db, fromVersion) {
         db.exec(`UPDATE sessions SET short_id = substr(id, 1, 8) WHERE short_id IS NULL OR short_id = ''`);
     }
     if (fromVersion < 17) {
+        // v16 → v17 (main): todos / recent dirs / linear project metadata.
         const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
         if (!cols.some(c => c.name === 'todos'))
             db.exec(`ALTER TABLE sessions ADD COLUMN todos TEXT`);
@@ -334,6 +343,46 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN linear_project_url TEXT`);
         db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
     }
+    if (fromVersion < 18) {
+        // v17 → v18: persist origin machine for smart-launch affinity GROUP BY machine.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'machine')) {
+            db.exec(`ALTER TABLE sessions ADD COLUMN machine TEXT`);
+        }
+        db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_sessions_machine_ts ON sessions(machine, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_sessions_agent_ts ON sessions(agent, timestamp DESC);
+    `);
+        const rows = db
+            .prepare(`SELECT id, agent, file_path FROM sessions WHERE machine IS NULL OR machine = ''`)
+            .all();
+        const upd = db.prepare(`UPDATE sessions SET machine = ? WHERE id = ?`);
+        const txn = db.transaction((items) => {
+            for (const r of items) {
+                upd.run(machineForSessionFile(r.file_path, r.agent), r.id);
+            }
+        });
+        txn(rows);
+    }
+    if (fromVersion < 19) {
+        // v18 → v19: actor provenance (RUSH-2018) — who initiated the session and
+        // the actor's kind. Populated at write time from the resolved actor (the
+        // pid-registry/spawn path), not derivable from the transcript, so there is
+        // no ledger wipe here: a rescan can't backfill these, and forcing a full
+        // re-parse would be pure churn. Existing rows stay NULL until re-created.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'actor'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN actor TEXT`);
+        if (!cols.some(c => c.name === 'initiated_by'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN initiated_by TEXT`);
+    }
+    if (fromVersion < 20) {
+        // v19 → v20: persist the transcript's model for the static session list.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'model'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN model TEXT`);
+        db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -367,6 +416,27 @@ export function getDB() {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_last_activity ON sessions(last_activity DESC)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_origin ON sessions(origin)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_routine_run_id ON sessions(routine_run_id)`);
+    // machine column + indexes: only after the column is guaranteed present.
+    // Fresh SCHEMA (v17) includes the column; older DBs get it from migrate v17.
+    // If a partial upgrade left schema_version ahead of the column, repair here.
+    {
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some((c) => c.name === 'machine')) {
+            db.exec(`ALTER TABLE sessions ADD COLUMN machine TEXT`);
+            const rows = db
+                .prepare(`SELECT id, agent, file_path FROM sessions WHERE machine IS NULL OR machine = ''`)
+                .all();
+            const upd = db.prepare(`UPDATE sessions SET machine = ? WHERE id = ?`);
+            const txn = db.transaction((items) => {
+                for (const r of items) {
+                    upd.run(machineForSessionFile(r.file_path, r.agent), r.id);
+                }
+            });
+            txn(rows);
+        }
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_machine_ts ON sessions(machine, timestamp DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_agent_ts ON sessions(agent, timestamp DESC)`);
+    }
     // One-shot cleanup of the pre-SQLite JSONL indexes. Safe — nothing reads
     // them anymore. Guarded by a meta flag so we only try once.
     const cleaned = db.prepare(`SELECT value FROM meta WHERE key = 'legacy_indexes_removed'`).get();
@@ -672,18 +742,20 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, origin, routine_name, routine_run_id,
     version, account, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
-    output_tokens, cost_usd, duration_ms,
+    output_tokens, cost_usd, duration_ms, model,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id, plan, todos,
-    recent_directories_touched, linear_project, linear_project_url
+    recent_directories_touched, linear_project, linear_project_url, machine,
+    actor, initiated_by
   ) VALUES (
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
     @version, @account, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
-    @output_tokens, @cost_usd, @duration_ms,
+    @output_tokens, @cost_usd, @duration_ms, @model,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan, @todos,
-    @recent_directories_touched, @linear_project, @linear_project_url
+    @recent_directories_touched, @linear_project, @linear_project_url, @machine,
+    @actor, @initiated_by
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -713,6 +785,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     output_tokens = excluded.output_tokens,
     cost_usd = excluded.cost_usd,
     duration_ms = excluded.duration_ms,
+    model = excluded.model,
     file_path = excluded.file_path,
     file_mtime_ms = excluded.file_mtime_ms,
     file_size = excluded.file_size,
@@ -732,7 +805,16 @@ const upsertSessionStmt = (db) => db.prepare(`
     linear_project_url = CASE
       WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project_url
       ELSE COALESCE(excluded.linear_project_url, sessions.linear_project_url)
-    END
+    END,
+    machine = excluded.machine,
+    -- actor / initiated_by record who launched the session. COALESCE(existing,
+    -- incoming) keeps a stored owner (a rescan carries no actor -> excluded.actor
+    -- is NULL -> the stored value wins, never clobbered) BUT backfills a row that
+    -- was inserted NULL-first — e.g. an older scanner, or any scan that ran before
+    -- the actor sidecar landed — once the sidecar-join finally provides one. Plain
+    -- exclusion locked those rows to NULL forever (RUSH-2018/2019 fix).
+    actor = COALESCE(sessions.actor, excluded.actor),
+    initiated_by = COALESCE(sessions.initiated_by, excluded.initiated_by)
 `);
 function enrichCachedSessionMeta(meta) {
     if (!meta.filePath)
@@ -778,12 +860,24 @@ function storedFtsLabel(readLabel, id) {
     const row = readLabel.get(id);
     return row?.label ?? '';
 }
+/** Resolve origin machine for a row: prefer caller-stamped meta, else path. */
+function resolveMachine(meta) {
+    if (meta.machine && meta.machine.trim())
+        return meta.machine.trim();
+    return machineForSessionFile(meta.filePath, meta.agent);
+}
 /**
  * Upsert a session row and replace its FTS5 content in a single transaction.
  * `content` is the tokenizable user-prompt text; pass '' to leave the row unsearchable.
  */
 export function upsertSession(meta, content, scan) {
     meta = enrichCachedSessionMeta(meta);
+    // Join the durable sessionId -> actor sidecar (RUSH-2019) when the caller
+    // didn't already carry an actor, so a scanned transcript still attributes to a
+    // person. The ON CONFLICT COALESCEs actor/initiated_by, so this fills a fresh
+    // row AND backfills one indexed null-first (before its sidecar existed), while a
+    // rescan carrying no actor still keeps the stored owner.
+    const actorRec = meta.actor ? undefined : readSessionActorRecord(meta.id);
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const row = {
@@ -807,6 +901,7 @@ export function upsertSession(meta, content, scan) {
         output_tokens: meta.outputTokens ?? null,
         cost_usd: meta.costUsd ?? null,
         duration_ms: meta.durationMs ?? null,
+        model: meta.model ?? null,
         file_path: meta.filePath,
         file_mtime_ms: scan?.fileMtimeMs ?? null,
         file_size: scan?.fileSize ?? null,
@@ -821,6 +916,9 @@ export function upsertSession(meta, content, scan) {
         recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
         linear_project: meta.linearProject ?? null,
         linear_project_url: meta.linearProjectUrl ?? null,
+        machine: resolveMachine(meta),
+        actor: meta.actor ?? actorRec?.actor ?? null,
+        initiated_by: meta.initiatedBy ?? actorRec?.initiatedBy ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -839,6 +937,12 @@ export function upsertSessionsBatch(entries) {
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const now = Date.now();
+    // One directory read for the whole batch: join the durable sessionId -> actor
+    // sidecar (RUSH-2019) so scanned transcripts attribute to a person. Only used
+    // for entries whose meta carries no actor; the ON CONFLICT COALESCEs the column,
+    // so this fills fresh rows AND backfills null-first ones, never clobbering a
+    // stored owner on rescan.
+    const actorIndex = loadSessionActorIndex();
     // Persist the Claude resumable-parse continuation (parser_state + content_text)
     // alongside the stamp. On a full/incremental Claude parse the caller passes the
     // serialized newState + accumulated user doc so the NEXT scan can resume from
@@ -917,6 +1021,7 @@ export function upsertSessionsBatch(entries) {
                     output_tokens: meta.outputTokens ?? null,
                     cost_usd: meta.costUsd ?? null,
                     duration_ms: meta.durationMs ?? null,
+                    model: meta.model ?? null,
                     file_path: meta.filePath,
                     file_mtime_ms: scan?.fileMtimeMs ?? null,
                     file_size: scan?.fileSize ?? null,
@@ -931,6 +1036,9 @@ export function upsertSessionsBatch(entries) {
                     recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
                     linear_project: meta.linearProject ?? null,
                     linear_project_url: meta.linearProjectUrl ?? null,
+                    machine: resolveMachine(meta),
+                    actor: meta.actor ?? actorIndex.get(meta.id)?.actor ?? null,
+                    initiated_by: meta.initiatedBy ?? actorIndex.get(meta.id)?.initiatedBy ?? null,
                 });
                 delText.run(meta.id);
                 insText.run(meta.id, 
@@ -1101,6 +1209,7 @@ function rowToMeta(row) {
         outputTokens: row.output_tokens ?? undefined,
         costUsd: row.cost_usd ?? undefined,
         durationMs: row.duration_ms ?? undefined,
+        model: row.model ?? undefined,
         version: row.version ?? undefined,
         account: row.account ?? undefined,
         topic: row.topic ?? undefined,
@@ -1115,6 +1224,11 @@ function rowToMeta(row) {
         recentDirectoriesTouched: parseJsonColumn(row.recent_directories_touched),
         linearProject: row.linear_project ?? undefined,
         linearProjectUrl: row.linear_project_url ?? undefined,
+        machine: row.machine ?? undefined,
+        actor: row.actor ?? undefined,
+        // Narrow the free-text column to the known kinds; an unexpected value maps
+        // to undefined rather than being asserted as a valid kind.
+        initiatedBy: row.initiated_by === 'human' || row.initiated_by === 'agent' ? row.initiated_by : undefined,
     };
 }
 function parseJsonColumn(value) {
@@ -1287,6 +1401,57 @@ export function countSessions(options = {}) {
     const row = db.prepare(sql).get(...params);
     return row ? row.n : 0;
 }
+export function queryAffinityRollup(options) {
+    const db = getDB();
+    const where = [];
+    const params = [];
+    const sinceMs = options.sinceMs ?? (Date.now() - 14 * 24 * 60 * 60 * 1000);
+    // ISO timestamps sort lexicographically; compare as string prefix of datetime.
+    where.push(`timestamp >= ?`);
+    params.push(new Date(sinceMs).toISOString());
+    if (options.onlyCli !== false) {
+        where.push(`IFNULL(origin, 'cli') = 'cli'`);
+    }
+    if (options.excludeTeamOrigin !== false) {
+        where.push(`IFNULL(is_team_origin, 0) = 0`);
+    }
+    if (options.agents && options.agents.length > 0) {
+        where.push(`agent IN (${options.agents.map(() => '?').join(',')})`);
+        params.push(...options.agents);
+    }
+    if (options.project) {
+        where.push(`LOWER(IFNULL(project, '')) LIKE ?`);
+        params.push(`%${options.project.toLowerCase()}%`);
+    }
+    let keyExpr;
+    let selectExtra;
+    if (options.groupBy === 'machine') {
+        keyExpr = `IFNULL(NULLIF(machine, ''), '(unknown)')`;
+        selectExtra = `${keyExpr} AS key, ${keyExpr} AS machine, NULL AS agent`;
+    }
+    else if (options.groupBy === 'agent') {
+        keyExpr = `agent`;
+        selectExtra = `agent AS key, NULL AS machine, agent AS agent`;
+    }
+    else {
+        keyExpr = `IFNULL(NULLIF(machine, ''), '(unknown)') || char(9) || agent`;
+        selectExtra = `${keyExpr} AS key, IFNULL(NULLIF(machine, ''), '(unknown)') AS machine, agent AS agent`;
+    }
+    const clause = where.length ? `WHERE ${where.join(' AND ')}` : '';
+    const sql = `
+    SELECT
+      ${selectExtra},
+      COUNT(*) AS launches,
+      IFNULL(SUM(duration_ms), 0) AS durationMs,
+      IFNULL(SUM(token_count), 0) AS tokenCount,
+      IFNULL(SUM(cost_usd), 0) AS costUsd
+    FROM sessions
+    ${clause}
+    GROUP BY key
+    ORDER BY launches DESC, key ASC
+  `;
+    return db.prepare(sql).all(...params);
+}
 /**
  * Aggregate cost / duration / tokens across sessions, grouped by agent,
  * project, or calendar day. Honors the same filter shape as querySessions

package/dist/lib/session/digest.js

@@ -99,31 +99,136 @@ export function toolHistogram(toolCounts, top = 8) {
         .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
         .slice(0, top);
 }
-/** Recognized test/build runners → the label we show. */
+/**
+ * Recognized test/build runners → the label we show.
+ *
+ * These match a *real invocation* of a runner, not any command that merely
+ * contains a runner token. In particular we must NOT fire on npm-script
+ * sub-targets like `bun test:setup`, `npm run test:watch`, or `pnpm test:ci` —
+ * those are setup/watch/CI-orchestration scripts, not a test run whose output we
+ * can scrape for a pass/fail verdict. A `test` token followed by `:something` is
+ * a distinct script name and is excluded via the `(?![:\w-])` guard.
+ */
 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' },
+    // Package-manager `test` script: `bun test`, `npm test`, `npm run test`,
+    // `yarn test`, `pnpm test`. The negative lookahead `(?![:\w-])` rejects
+    // `test:watch` / `test-ci` / `testfoo` — only the bare `test` target counts.
+    { re: /\b(?:bun|npm|yarn|pnpm)\s+(?:run\s+)?test(?![:\w-])/, label: 'tests' },
+    // Direct binaries — `vitest`, `jest`, `mocha` (optionally via a runner). These
+    // are real invocations; a trailing subcommand like `vitest run` is fine.
+    { re: /\b(?:vitest|jest|mocha)(?![:\w-])/, label: 'tests' },
+    { re: /\bpytest(?![:\w-])/, label: 'pytest' },
+    { re: /\bgo\s+test(?![:\w-])/, label: 'go test' },
+    { re: /\bcargo\s+test(?![:\w-])/, label: 'cargo test' },
+    { re: /\btsc(?:\s+--noEmit)?(?![:\w-])/, label: 'tsc' },
 ];
+/**
+ * Anchored summary-line extractors, per runner family. Each returns a pass/fail
+ * verdict ONLY when it matches that runner's authoritative summary construct —
+ * never an arbitrary `\d+ pass`-shaped substring elsewhere in stdout. This is
+ * what stops `442 passwords generated`, `442 files`, or `442 passes/sec` from
+ * being reported as `442 pass`.
+ */
+function parseSummaryLine(output) {
+    const lines = output.split(/\r?\n/);
+    // vitest: ` Tests  1 failed | 2 passed (3)` (mixed) or ` Tests  2 passed (2)`
+    // (all green). Leading indent + the `Tests` / `Test Files` label + double
+    // space is the summary row. Prefer the ` Tests ` row (test count) over the
+    // ` Test Files ` row (file count).
+    for (const label of ['Tests', 'Test Files']) {
+        for (const line of lines) {
+            const row = new RegExp(`^\\s*${label}\\s{2,}(.+)$`).exec(line);
+            if (!row)
+                continue;
+            const seg = row[1];
+            const passed = /(\d+)\s+passed/.exec(seg);
+            const failed = /(\d+)\s+failed/.exec(seg);
+            // Only accept a vitest row that actually reports a pass/fail count.
+            if (passed || failed) {
+                return {
+                    passed: passed ? +passed[1] : undefined,
+                    failed: failed ? +failed[1] : 0,
+                };
+            }
+        }
+    }
+    // jest: `Tests:       1 failed, 2 passed, 3 total`. The `Tests:` label anchors
+    // it; order of failed/passed varies.
+    for (const line of lines) {
+        const row = /^\s*Tests:\s+(.+)$/.exec(line);
+        if (!row)
+            continue;
+        const seg = row[1];
+        const passed = /(\d+)\s+passed/.exec(seg);
+        const failed = /(\d+)\s+failed/.exec(seg);
+        if (passed || failed) {
+            return { passed: passed ? +passed[1] : undefined, failed: failed ? +failed[1] : 0 };
+        }
+    }
+    // pytest: the summary rule line `==== 3 passed, 1 failed in 0.12s ====`. The
+    // surrounding `=` rule and the ` in <dur>s` tail anchor it to the real footer,
+    // not a stray `N passed` in captured stdout.
+    for (const line of lines) {
+        if (!/={3,}.*\bin\s+[\d.]+s\b.*={3,}/.test(line) && !/^={3,}.*={3,}$/.test(line))
+            continue;
+        if (!/\bin\s+[\d.]+m?s\b/.test(line))
+            continue;
+        const passed = /(\d+)\s+passed/.exec(line);
+        const failed = /(\d+)\s+failed/.exec(line);
+        const errors = /(\d+)\s+error/.exec(line);
+        if (passed || failed || errors) {
+            const failCount = (failed ? +failed[1] : 0) + (errors ? +errors[1] : 0);
+            return { passed: passed ? +passed[1] : undefined, failed: failed || errors ? failCount : 0 };
+        }
+    }
+    // bun test: a summary block of ` N pass` / ` N fail` lines (each its own line,
+    // leading-indented), closed by `Ran N tests across M files.`. Require the
+    // `Ran … tests` sentinel to be present so we only read bun's real summary
+    // block — bun also prints inline `(pass)`/`(fail)` per-test lines we ignore.
+    if (/^Ran\s+\d+\s+tests?\b/m.test(output)) {
+        let passed;
+        let failed;
+        for (const line of lines) {
+            const p = /^\s*(\d+)\s+pass$/.exec(line);
+            const f = /^\s*(\d+)\s+fail$/.exec(line);
+            if (p)
+                passed = +p[1];
+            if (f)
+                failed = +f[1];
+        }
+        if (passed !== undefined || failed !== undefined) {
+            return { passed, failed: failed ?? 0 };
+        }
+    }
+    // mocha: ` 2 passing` / ` 1 failing` (leading-indented, own line). The
+    // `passing`/`failing` gerund is mocha-specific and won't match `442 passwords`.
+    {
+        let passed;
+        let failed;
+        for (const line of lines) {
+            const p = /^\s*(\d+)\s+passing\b/.exec(line);
+            const f = /^\s*(\d+)\s+failing\b/.exec(line);
+            if (p)
+                passed = +p[1];
+            if (f)
+                failed = +f[1];
+        }
+        if (passed !== undefined || failed !== undefined) {
+            return { passed, failed: failed ?? 0 };
+        }
+    }
+    return undefined;
+}
 /** 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 };
+    // Anchor to a recognized runner summary construct (vitest ` Tests `, jest
+    // `Tests:`, pytest `=== N passed in Xs ===`, bun's `N pass`/`N fail` block,
+    // mocha `N passing`) — never a blanket `\d+ pass`-shaped scrape over stdout.
+    // That blanket scrape used to report `442 passwords`, `442 files passed
+    // validation`, or a `442 passes/sec` benchmark as `442 pass`.
+    const summary = parseSummaryLine(output);
+    if (summary) {
+        return { ...summary, ok: true };
     }
     // tsc: no news is good news; "error TSxxxx" means failure.
     if (runner === 'tsc') {

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

@@ -7,6 +7,7 @@
  * subsequent queries are served entirely from the cache.
  */
 import type { SessionAgentId, SessionEvent, SessionMeta, TodoProgress } from './types.js';
+export { machineForSessionFile } from './origin-machine.js';
 import { type ScanStamp } from './db.js';
 /** Options controlling which sessions to discover and how to report progress. */
 export interface DiscoverOptions {
@@ -53,6 +54,7 @@ interface ClaudeSessionScan {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     messageCount: number;
     tokenCount?: number;
@@ -92,6 +94,7 @@ interface CodexSessionScan {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     messageCount: number;
     tokenCount?: number;
@@ -148,7 +151,6 @@ export declare function scanAgentsBounded<T>(items: readonly T[], run: (item: T)
  * `agents add --isolated`, where the whole point was to keep the two apart.
  */
 export declare function isManagedSessionFile(filePath: string): boolean;
-export declare function machineForSessionFile(filePath: string, agent: string): string;
 /**
  * Count sessions in scope without running an incremental scan. Assumes the DB
  * is already fresh (typically true because `discoverSessions` ran first this
@@ -194,6 +196,20 @@ export declare function _normalizeCwdForTest(cwd?: string): string;
  * ids, whose charset is too permissive to distinguish from a search phrase.
  */
 export declare function isCompleteSessionId(query: string): boolean;
+/**
+ * Whether a query should be treated as a session id rather than a search phrase
+ * — the one canonical id-shaped test, shared by every session-id resolver.
+ *
+ * True for a complete id (`isCompleteSessionId`) AND for a bare hex short-id or
+ * prefix (`d3470b57`), which the complete-id check rejects. Any id-shaped query
+ * resolves by id ONLY (exact -> prefix -> `findSessionsById` index) and must
+ * never fall back to fuzzy content search: a short id like `d3470b57` otherwise
+ * surfaces every transcript that merely MENTIONS the string (a resume prompt
+ * echoes the parent id into the body of many later sessions). The hex test
+ * catches the bare short-id/prefix; `isCompleteSessionId` additionally catches
+ * the prefixed whole ids (`session_…`, `ses_…`) that the hex test rejects.
+ */
+export declare function looksLikeSessionId(query: string): boolean;
 /**
  * Resolve a session by full or short ID. Accepts a pre-loaded session list
  * (fast path from discoverSessions) and falls back to a DB lookup for the
@@ -352,6 +368,7 @@ export interface ClaudeParseState {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     customTitle?: string;
     aiTitle?: string;
@@ -410,6 +427,7 @@ export interface ClaudeParserState {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     entrypoint?: string;
     firstTsMs?: number;
     topic?: string;
@@ -653,4 +671,3 @@ export declare function readGrokMeta(filePath: string, currentVersion?: string):
 } | null;
 /** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
 export declare function parseTimeFilter(input: string): number;
-export {};