@phnx-labs/agents-cli 1.20.76 → 1.20.78

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

@@ -6,7 +6,8 @@
  * the last run are re-parsed. All metadata is upserted into the sessions DB so
  * subsequent queries are served entirely from the cache.
  */
-import type { SessionAgentId, SessionMeta } from './types.js';
+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 {
@@ -82,6 +83,8 @@ interface ClaudeSessionScan {
     spawnedTeam?: string;
     /** Plan markdown from the last ExitPlanMode tool call (Claude sessions only). */
     plan?: string;
+    todos?: TodoProgress;
+    recentDirectoriesTouched?: string[];
 }
 /** Lightweight metadata extracted from a Codex JSONL file during incremental scan. */
 interface CodexSessionScan {
@@ -105,6 +108,8 @@ interface CodexSessionScan {
     ticketId?: string;
     createdTickets?: string[];
     spawnedTeam?: string;
+    todos?: TodoProgress;
+    recentDirectoriesTouched?: string[];
 }
 /**
  * Discover sessions. Scans only files whose (mtime, size) have changed since
@@ -144,7 +149,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
@@ -190,6 +194,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
@@ -369,6 +387,8 @@ export interface ClaudeParseState {
     pendingTicketTools: Set<string>;
     spawnedTeam?: string;
     plan?: string;
+    checklistEvents: SessionEvent[];
+    recentDirectoriesTouched: string[];
 }
 /** Zero-value accumulator for a fresh (from-byte-0) Claude parse. */
 export declare function initClaudeParseState(): ClaudeParseState;
@@ -427,6 +447,8 @@ export interface ClaudeParserState {
     spawnedTeam?: string;
     ticketId?: string;
     contentText?: string;
+    checklistEvents: SessionEvent[];
+    recentDirectoriesTouched: string[];
 }
 /**
  * Snapshot a live {@link ClaudeParseState} into its serializable form at
@@ -500,6 +522,8 @@ export interface CodexParseState {
     createdTickets: Set<string>;
     pendingTicketTools: Set<string>;
     spawnedTeam?: string;
+    checklistEvents: SessionEvent[];
+    recentDirectoriesTouched: string[];
 }
 /** Zero-value accumulator for a fresh (from-byte-0) Codex parse. */
 export declare function initCodexParseState(): CodexParseState;
@@ -549,6 +573,8 @@ export interface CodexParserState {
     spawnedTeam?: string;
     ticketId?: string;
     contentText?: string;
+    checklistEvents: SessionEvent[];
+    recentDirectoriesTouched: string[];
 }
 /**
  * Snapshot a live {@link CodexParseState} into its serializable form at `offset`
@@ -641,4 +667,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 {};

package/dist/lib/session/discover.js

@@ -24,12 +24,14 @@ import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
 import { extractSessionTopic } from './prompt.js';
 import { parseAntigravity } from './parse.js';
-import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket } from './state.js';
+import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
-import { machineId } from './sync/config.js';
+import { machineForSessionFile } from './origin-machine.js';
+export { machineForSessionFile } from './origin-machine.js';
 import { mapBounded } from '../concurrency.js';
-import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
+import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, cacheLinearProject, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
+import { resolveLinearApiKey } from '../auto-dispatch-linear.js';
 const HOME = os.homedir();
 // Versions can live under either repo: the user repo (current canonical
 // location, ~/.agents/.history/versions/) or the system repo (legacy / npm-shipped,
@@ -99,10 +101,49 @@ export async function discoverSessions(options) {
         }
     }
     const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
+    await resolveLinearProjects(sessions);
     for (const s of sessions)
         s.machine = machineForSessionFile(s.filePath, s.agent);
     return scopeToManaged(sessions, agents, options);
 }
+const linearProjectCache = new Map();
+async function resolveLinearProjects(sessions) {
+    const apiKey = resolveLinearApiKey();
+    if (!apiKey)
+        return;
+    await Promise.all(sessions.map(async (session) => {
+        if (!session.ticketId || session.linearProject)
+            return;
+        let project = linearProjectCache.get(session.ticketId);
+        if (project === undefined) {
+            try {
+                const response = await fetch('https://api.linear.app/graphql', {
+                    method: 'POST',
+                    signal: AbortSignal.timeout(3_000),
+                    headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        query: `query($id:String!){ issue(id:$id){ project{ name url } } }`,
+                        variables: { id: session.ticketId },
+                    }),
+                });
+                if (!response.ok)
+                    throw new Error(String(response.status));
+                const body = await response.json();
+                const node = body.data?.issue?.project;
+                project = node?.name && node?.url ? { name: node.name, url: node.url } : null;
+            }
+            catch {
+                project = null;
+            }
+            linearProjectCache.set(session.ticketId, project);
+        }
+        if (!project)
+            return;
+        session.linearProject = project.name;
+        session.linearProjectUrl = project.url;
+        cacheLinearProject(session.id, project.name, project.url);
+    }));
+}
 /**
  * Drop unmanaged rows for agents that HAVE managed versions.
  *
@@ -183,7 +224,6 @@ function dispatchAgentScan(agent, onProgress) {
         default: return Promise.resolve();
     }
 }
-let _localMachineId;
 /**
  * The machine a discovered session originated on. Cross-machine sync mirrors a
  * remote transcript to backups/<agent>/<machine>/<subdir>/… (see mirrorPath in
@@ -230,15 +270,6 @@ export function isManagedSessionFile(filePath) {
         return !!realRoot && real.startsWith(realRoot + path.sep);
     });
 }
-export function machineForSessionFile(filePath, agent) {
-    const base = path.join(getHistoryDir(), 'backups', agent) + path.sep;
-    if (filePath.startsWith(base)) {
-        const seg = filePath.slice(base.length).split(path.sep)[0];
-        if (seg)
-            return seg;
-    }
-    return (_localMachineId ??= machineId());
-}
 /**
  * Count sessions in scope without running an incremental scan. Assumes the DB
  * is already fresh (typically true because `discoverSessions` ran first this
@@ -348,6 +379,23 @@ export function isCompleteSessionId(query) {
     const q = query.trim().toLowerCase();
     return UUID_36.test(q.replace(SESSION_UUID_PREFIX, '')) || SES_ULID.test(q);
 }
+/**
+ * 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 function looksLikeSessionId(query) {
+    const trimmed = query.trim();
+    return /^[0-9a-f-]{6,}$/i.test(trimmed) || isCompleteSessionId(trimmed);
+}
 /**
  * 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
@@ -968,6 +1016,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             createdTickets: scan.createdTickets,
             spawnedTeam: scan.spawnedTeam,
             plan: scan.plan,
+            todos: scan.todos,
+            recentDirectoriesTouched: scan.recentDirectoriesTouched,
         };
     }
     else {
@@ -995,6 +1045,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             createdTickets: scan.createdTickets,
             spawnedTeam: scan.spawnedTeam,
             plan: scan.plan,
+            todos: scan.todos,
+            recentDirectoriesTouched: scan.recentDirectoriesTouched,
         };
     }
     return {
@@ -1288,6 +1340,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         ticketId: scan.ticketId,
         createdTickets: scan.createdTickets,
         spawnedTeam: scan.spawnedTeam,
+        todos: scan.todos,
+        recentDirectoriesTouched: scan.recentDirectoriesTouched,
     };
     return {
         meta,
@@ -2370,8 +2424,27 @@ export function initClaudeParseState() {
         pendingTicketTools: new Set(),
         spawnedTeam: undefined,
         plan: undefined,
+        checklistEvents: [],
+        recentDirectoriesTouched: [],
     };
 }
+const CHECKLIST_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan', 'TaskCreate', 'TaskUpdate']);
+const DIRECTORY_TOOLS = new Set(['Edit', 'Write', 'edit_file', 'write_file', 'create_file', 'edit', 'write', 'Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute']);
+function foldDerivedToolState(state, event) {
+    if (CHECKLIST_TOOLS.has(event.tool ?? ''))
+        state.checklistEvents.push(event);
+    if (!DIRECTORY_TOOLS.has(event.tool ?? ''))
+        return;
+    const next = extractRecentDirectoriesTouched([event], state.cwd);
+    for (const dir of next ?? []) {
+        const old = state.recentDirectoriesTouched.indexOf(dir);
+        if (old >= 0)
+            state.recentDirectoriesTouched.splice(old, 1);
+        state.recentDirectoriesTouched.push(dir);
+    }
+    if (state.recentDirectoriesTouched.length > 10)
+        state.recentDirectoriesTouched.splice(0, state.recentDirectoriesTouched.length - 10);
+}
 /**
  * Fold one parsed transcript line into the accumulator. This is the exact loop
  * body {@link scanClaudeSession} used to run inline — extracted verbatim,
@@ -2407,6 +2480,10 @@ export function applyClaudeLine(state, parsed) {
                 if (p)
                     state.plan = b.input.plan;
             }
+            foldDerivedToolState(state, {
+                type: 'tool_use', agent: 'claude', timestamp: parsed.timestamp || '', tool: b?.name, args: b?.input || {},
+                path: b?.input?.file_path || b?.input?.path, command: b?.input?.command,
+            });
         }
     }
     if (state.pendingTicketTools.size > 0 && parsed.type === 'user' && Array.isArray(parsed.message?.content)) {
@@ -2558,6 +2635,8 @@ export function finalizeClaudeScan(state) {
         createdTickets: state.createdTickets.size > 0 ? [...state.createdTickets] : undefined,
         spawnedTeam: state.spawnedTeam,
         plan: state.plan,
+        todos: extractTodoProgressFromEvents(state.checklistEvents),
+        recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
     };
 }
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
@@ -2632,6 +2711,8 @@ export function serializeClaudeParserState(state, offset) {
         // not be persisted.
         ticketId: ticket?.id,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
+        checklistEvents: state.checklistEvents,
+        recentDirectoriesTouched: state.recentDirectoriesTouched,
     };
 }
 /**
@@ -2684,6 +2765,8 @@ export function hydrateClaudeParseState(prior) {
         pendingTicketTools: new Set(prior.pendingTicketTools),
         spawnedTeam: prior.spawnedTeam,
         plan: prior.plan,
+        checklistEvents: prior.checklistEvents ?? [],
+        recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
     };
 }
 /**
@@ -2883,6 +2966,8 @@ export function initCodexParseState() {
         createdTickets: new Set(),
         pendingTicketTools: new Set(),
         spawnedTeam: undefined,
+        checklistEvents: [],
+        recentDirectoriesTouched: [],
     };
 }
 /**
@@ -2898,11 +2983,16 @@ export function applyCodexLine(state, parsed) {
         const p = parsed.payload || {};
         if (p.type === 'function_call') {
             let cmd = '';
+            let args = {};
             try {
-                const args = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : (p.arguments || {});
+                args = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : (p.arguments || {});
                 cmd = String(args.command || args.cmd || '');
             }
             catch { /* non-JSON args */ }
+            foldDerivedToolState(state, {
+                type: 'tool_use', agent: 'codex', timestamp: parsed.timestamp || '', tool: p.name, args,
+                path: args.file_path || args.path, command: cmd || undefined,
+            });
             if (!state.prUrl && !state.sawPrCreate && isPrCreateCommand(cmd))
                 state.sawPrCreate = true;
             if (!state.spawnedTeam) {
@@ -3024,6 +3114,8 @@ export function finalizeCodexScan(state) {
         ticketId: ticket?.id,
         createdTickets: state.createdTickets.size > 0 ? [...state.createdTickets] : undefined,
         spawnedTeam: state.spawnedTeam,
+        todos: extractTodoProgressFromEvents(state.checklistEvents),
+        recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
     };
 }
 /** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
@@ -3085,6 +3177,8 @@ export function serializeCodexParserState(state, offset) {
         // be persisted.
         ticketId: ticket?.id,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
+        checklistEvents: state.checklistEvents,
+        recentDirectoriesTouched: state.recentDirectoriesTouched,
     };
 }
 /**
@@ -3118,6 +3212,8 @@ export function hydrateCodexParseState(prior) {
         createdTickets: new Set(prior.createdTickets),
         pendingTicketTools: new Set(prior.pendingTicketTools),
         spawnedTeam: prior.spawnedTeam,
+        checklistEvents: prior.checklistEvents ?? [],
+        recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
     };
 }
 /**

package/dist/lib/session/origin-machine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+/** Local machine id, cached for the process lifetime. */
+export declare function localMachineId(): string;
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export declare function machineForSessionFile(filePath: string, agent: string): string;

package/dist/lib/session/origin-machine.js

@@ -0,0 +1,34 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+import * as path from 'path';
+import { getHistoryDir } from '../state.js';
+import { machineId } from '../machine-id.js';
+let _localMachineId;
+/** Local machine id, cached for the process lifetime. */
+export function localMachineId() {
+    return (_localMachineId ??= machineId());
+}
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export function machineForSessionFile(filePath, agent) {
+    if (!filePath)
+        return localMachineId();
+    const base = path.join(getHistoryDir(), 'backups', agent) + path.sep;
+    if (filePath.startsWith(base)) {
+        const seg = filePath.slice(base.length).split(path.sep)[0];
+        if (seg)
+            return seg;
+    }
+    return localMachineId();
+}

package/dist/lib/session/parse.js

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import { truncate } from '../format.js';
 import * as path from 'path';
 import Database from '../sqlite.js';
+import { isSyntheticUserMessage } from './prompt.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -156,9 +157,17 @@ export function parseSession(filePath, agent) {
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
-    // safely splat values into chalk/console output.
-    for (const e of events)
+    // safely splat values into chalk/console output. Same pass flags
+    // harness-injected `role=user` scaffolding (Claude `<bash-input>`/`<bash-stdout>`
+    // from `!`-prefix runs, `<system-reminder>`, etc.) as `_synthetic` so turn
+    // slicing and `--include user` count only genuine user intent — one place,
+    // every harness, instead of per-consumer regex.
+    for (const e of events) {
         sanitizeEvent(e);
+        if (e.type === 'message' && e.role === 'user' && isSyntheticUserMessage(e.content)) {
+            e._synthetic = true;
+        }
+    }
     return events;
 }
 /** Infer the agent type from a session file path using known directory conventions. */

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

@@ -5,6 +5,13 @@
  * wrapper tags, team-spawn boilerplate) so that only the real user intent
  * remains. Used by the session picker to show a human-readable topic line.
  */
+/**
+ * True when a `role=user` message is harness-injected scaffolding, not a genuine
+ * user turn. Text-based so it is cross-harness by construction (the markers are
+ * the same wrappers across Claude/Codex/etc.); harnesses that already drop their
+ * own scaffolding at parse time simply never reach here.
+ */
+export declare function isSyntheticUserMessage(raw: string | undefined): boolean;
 export declare const HEADLESS_PLAN_MODE_PREFIX = "You are running in HEADLESS PLAN MODE.";
 /** Strip framework noise from a raw session prompt, returning only meaningful user text. */
 export declare function cleanSessionPrompt(raw: string): string;

package/dist/lib/session/prompt.js

@@ -26,6 +26,43 @@ const NOISE_LINE_PATTERNS = [
 ];
 /** XML tag prefix used by local-command messages. */
 const LOCAL_COMMAND_PREFIX = '<local-command-caveat>';
+/**
+ * Patterns that mark a whole `role=user` message as harness-injected scaffolding
+ * rather than a genuine user turn: the `!`-prefix shell echo and its output,
+ * slash-command wrappers, injected reminders / task-notifications, the local
+ * caveat, the interrupt marker, skill bodies, and hook feedback. This is the
+ * single cross-harness list — `isSyntheticUserMessage` is consumed by the parser
+ * (`parseSession`) to flag such events `_synthetic`, so `--include user` and the
+ * `--first`/`--last` turn split see only real intent, and every consumer (the
+ * session picker, `session-recall`, external hooks) gets clean user turns without
+ * re-implementing the stripping. Extend this list, not each caller.
+ */
+const SYNTHETIC_USER_MESSAGE_PATTERNS = [
+    /^\s*<\/?(?:bash-input|bash-stdout|bash-stderr)>/i,
+    /^\s*<\/?(?:command-name|command-message|command-args|command-contents)>/i,
+    /^\s*<\/?(?:local-command-stdout|local-command-stderr|local-command-caveat)>/i,
+    /^\s*<\/?system-reminder>/i,
+    /^\s*<\/?task-notification>/i,
+    /^\s*<\/?user-prompt-submit-hook>/i,
+    /^\s*<\/?persisted-output>/i,
+    /^\s*<permissions instructions>/i,
+    /^\s*<collaboration_mode>/i,
+    /^\s*Caveat: The messages below were generated by the user while running/i,
+    /^\s*\[Request interrupted/i,
+    /^\s*Base directory for this skill:/i,
+    /^\s*[A-Za-z][A-Za-z-]* hook feedback:/,
+];
+/**
+ * True when a `role=user` message is harness-injected scaffolding, not a genuine
+ * user turn. Text-based so it is cross-harness by construction (the markers are
+ * the same wrappers across Claude/Codex/etc.); harnesses that already drop their
+ * own scaffolding at parse time simply never reach here.
+ */
+export function isSyntheticUserMessage(raw) {
+    if (!raw)
+        return false;
+    return SYNTHETIC_USER_MESSAGE_PATTERNS.some(pattern => pattern.test(raw));
+}
 // Prefix prepended to every Claude-in-plan-mode team spawn prompt.
 // Ends at a blank line before the real user task.
 export const HEADLESS_PLAN_MODE_PREFIX = 'You are running in HEADLESS PLAN MODE.';