@phnx-labs/agents-cli 1.20.76 → 1.20.77

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

@@ -40,6 +40,10 @@ export interface SessionRow {
     worktree_slug: string | null;
     ticket_id: string | null;
     plan: string | null;
+    todos: string | null;
+    recent_directories_touched: string | null;
+    linear_project: string | null;
+    linear_project_url: string | null;
 }
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
@@ -215,6 +219,8 @@ export declare function isSessionActivityFresh(row: {
     timestamp: string;
     file_mtime_ms: number | null;
 }, maxAgeMs: number, nowMs: number): boolean;
+/** Persist a lazily resolved Linear project without reparsing the transcript. */
+export declare function cacheLinearProject(sessionId: string, project: string, projectUrl: string): void;
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,

package/dist/lib/session/db.js

@@ -9,11 +9,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from '../sqlite.js';
+import { parseSession } from './parse.js';
+import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 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 = 16;
+const SCHEMA_VERSION = 17;
 /**
  * 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`
@@ -69,7 +71,11 @@ CREATE TABLE IF NOT EXISTS sessions (
   pr_number INTEGER,
   worktree_slug TEXT,
   ticket_id TEXT,
-  plan TEXT
+  plan TEXT,
+  todos TEXT,
+  recent_directories_touched TEXT,
+  linear_project TEXT,
+  linear_project_url TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -316,6 +322,18 @@ function migrateSchema(db, fromVersion) {
         // primary key — so every corrupt row becomes addressable. No rescan needed.
         db.exec(`UPDATE sessions SET short_id = substr(id, 1, 8) WHERE short_id IS NULL OR short_id = ''`);
     }
+    if (fromVersion < 17) {
+        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`);
+        if (!cols.some(c => c.name === 'recent_directories_touched'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN recent_directories_touched TEXT`);
+        if (!cols.some(c => c.name === 'linear_project'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN linear_project TEXT`);
+        if (!cols.some(c => c.name === 'linear_project_url'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN linear_project_url 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() {
@@ -656,14 +674,16 @@ const upsertSessionStmt = (db) => db.prepare(`
     project, cwd, git_branch, topic, label, message_count, token_count,
     output_tokens, cost_usd, duration_ms,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
-    pr_url, pr_number, worktree_slug, ticket_id, plan
+    pr_url, pr_number, worktree_slug, ticket_id, plan, todos,
+    recent_directories_touched, linear_project, linear_project_url
   ) 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,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
-    @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan
+    @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan, @todos,
+    @recent_directories_touched, @linear_project, @linear_project_url
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -702,8 +722,34 @@ const upsertSessionStmt = (db) => db.prepare(`
     pr_number = excluded.pr_number,
     worktree_slug = excluded.worktree_slug,
     ticket_id = excluded.ticket_id,
-    plan = excluded.plan
+    plan = excluded.plan,
+    todos = excluded.todos,
+    recent_directories_touched = excluded.recent_directories_touched,
+    linear_project = CASE
+      WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project
+      ELSE COALESCE(excluded.linear_project, sessions.linear_project)
+    END,
+    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
 `);
+function enrichCachedSessionMeta(meta) {
+    if (!meta.filePath)
+        return meta;
+    try {
+        const events = parseSession(meta.filePath, meta.agent);
+        return {
+            ...meta,
+            todos: extractTodoProgressFromEvents(events),
+            recentDirectoriesTouched: extractRecentDirectoriesTouched(events, meta.cwd),
+        };
+    }
+    catch {
+        // Synthetic/cloud rows can intentionally name a transcript that is not local.
+        return meta;
+    }
+}
 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 (?, ?, ?, ?, ?)`);
 // Read back the label the upsert actually stored (which may be the preserved
@@ -737,6 +783,7 @@ function storedFtsLabel(readLabel, id) {
  * `content` is the tokenizable user-prompt text; pass '' to leave the row unsearchable.
  */
 export function upsertSession(meta, content, scan) {
+    meta = enrichCachedSessionMeta(meta);
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const row = {
@@ -770,6 +817,10 @@ export function upsertSession(meta, content, scan) {
         worktree_slug: meta.worktreeSlug ?? null,
         ticket_id: meta.ticketId ?? null,
         plan: meta.plan ?? null,
+        todos: meta.todos ? JSON.stringify(meta.todos) : null,
+        recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
+        linear_project: meta.linearProject ?? null,
+        linear_project_url: meta.linearProjectUrl ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -812,6 +863,9 @@ export function upsertSessionsBatch(entries) {
     const byPath = new Map(entries
         .filter(e => e.scan && e.meta.filePath)
         .map(e => [canonicalLedgerKey(e.meta.filePath), e]));
+    const enrichedEntries = entries.map(entry => entry.meta.agent === 'claude' || entry.meta.agent === 'codex'
+        ? entry
+        : { ...entry, meta: enrichCachedSessionMeta(entry.meta) });
     const txn = db.transaction((items) => {
         // Re-read the ledger now that we hold the write lock. Any file committed
         // by a concurrent process since our pre-scan is visible here.
@@ -873,6 +927,10 @@ export function upsertSessionsBatch(entries) {
                     worktree_slug: meta.worktreeSlug ?? null,
                     ticket_id: meta.ticketId ?? null,
                     plan: meta.plan ?? null,
+                    todos: meta.todos ? JSON.stringify(meta.todos) : null,
+                    recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
+                    linear_project: meta.linearProject ?? null,
+                    linear_project_url: meta.linearProjectUrl ?? null,
                 });
                 delText.run(meta.id);
                 insText.run(meta.id, 
@@ -890,7 +948,7 @@ export function upsertSessionsBatch(entries) {
             }
         }
     });
-    txn(entries);
+    txn(enrichedEntries);
 }
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored
@@ -1053,8 +1111,22 @@ function rowToMeta(row) {
         worktreeSlug: row.worktree_slug ?? undefined,
         ticketId: row.ticket_id ?? undefined,
         plan: row.plan ?? undefined,
+        todos: parseJsonColumn(row.todos),
+        recentDirectoriesTouched: parseJsonColumn(row.recent_directories_touched),
+        linearProject: row.linear_project ?? undefined,
+        linearProjectUrl: row.linear_project_url ?? undefined,
     };
 }
+function parseJsonColumn(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The recency signal used to sort and label the listing: last-message time when
  * a parser computed it (`meta.lastActivity` from `lastTsMs`), else the file's
@@ -1075,6 +1147,11 @@ export function isSessionActivityFresh(row, maxAgeMs, nowMs) {
     const activityMs = Number.isFinite(parsedActivityMs) ? parsedActivityMs : row.file_mtime_ms ?? undefined;
     return activityMs != null && nowMs - activityMs <= maxAgeMs;
 }
+/** Persist a lazily resolved Linear project without reparsing the transcript. */
+export function cacheLinearProject(sessionId, project, projectUrl) {
+    getDB().prepare(`UPDATE sessions SET linear_project = ?, linear_project_url = ? WHERE id = ?`)
+        .run(project, projectUrl, sessionId);
+}
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,

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

@@ -6,7 +6,7 @@
  * 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';
 import { type ScanStamp } from './db.js';
 /** Options controlling which sessions to discover and how to report progress. */
 export interface DiscoverOptions {
@@ -82,6 +82,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 +107,8 @@ interface CodexSessionScan {
     ticketId?: string;
     createdTickets?: string[];
     spawnedTeam?: string;
+    todos?: TodoProgress;
+    recentDirectoriesTouched?: string[];
 }
 /**
  * Discover sessions. Scans only files whose (mtime, size) have changed since
@@ -369,6 +373,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 +433,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 +508,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 +559,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`

package/dist/lib/session/discover.js

@@ -24,12 +24,13 @@ 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 { 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 +100,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.
  *
@@ -968,6 +1008,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 +1037,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 +1332,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 +2416,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 +2472,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 +2627,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 +2703,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 +2757,8 @@ export function hydrateClaudeParseState(prior) {
         pendingTicketTools: new Set(prior.pendingTicketTools),
         spawnedTeam: prior.spawnedTeam,
         plan: prior.plan,
+        checklistEvents: prior.checklistEvents ?? [],
+        recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
     };
 }
 /**
@@ -2883,6 +2958,8 @@ export function initCodexParseState() {
         createdTickets: new Set(),
         pendingTicketTools: new Set(),
         spawnedTeam: undefined,
+        checklistEvents: [],
+        recentDirectoriesTouched: [],
     };
 }
 /**
@@ -2898,11 +2975,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 +3106,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 +3169,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 +3204,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/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.';

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

@@ -37,6 +37,13 @@ export interface SessionProvenance {
     mux?: MuxLocation;
     /** Whether an existing rail can type back into this session (see module doc). */
     reply: ReplyRail;
+    /** The initiating device, resolved at query time from ssh.clientIp against the
+     * device registry (ssh transport only). Answers "who launched this and from
+     * where" without scraping ps/who/tailscale. */
+    origin?: {
+        device: string;
+        user?: string;
+    };
 }
 /** Env vars that carry provenance. Kept small so the macOS `ps` scan stays cheap. */
 export declare const PROVENANCE_ENV_KEYS: readonly ["SSH_CONNECTION", "SSH_TTY", "TMUX", "TMUX_PANE", "TERM_PROGRAM", "STY", "ITERM_SESSION_ID"];

package/dist/lib/session/render.js

@@ -13,6 +13,7 @@ import { cleanSessionPrompt, extractSessionTopic } from './prompt.js';
 import { renderMarkdown } from '../markdown.js';
 import { redactSecrets } from '../redact.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from './digest.js';
+import { extractTodoProgressFromEvents } from './state.js';
 // ── Path helpers ──────────────────────────────────────────────────────────────
 /**
  * Return absPath relative to cwd; fall back to ~/… then absolute.
@@ -528,7 +529,7 @@ export function renderSummary(events, cwd) {
     // Commands with timestamps
     const cmdList = [];
     // Plan items
-    const todoItems = [];
+    const todoItems = extractTodoProgressFromEvents(events)?.items.map(item => item.content) ?? [];
     let exitPlanContent = null;
     let planFilePath = null;
     // Subagent spawns
@@ -569,19 +570,6 @@ export function renderSummary(events, cwd) {
                     recentActivity.push({ kind: 'cmd', label: cmd, ts });
                 }
             }
-            // Plan items: TodoWrite items + TaskCreate descriptions (project's task tracker)
-            if (tool === 'TodoWrite' && Array.isArray(args.todos)) {
-                for (const item of args.todos) {
-                    const text = item.content || item.text || String(item);
-                    if (text && !todoItems.includes(text))
-                        todoItems.push(text);
-                }
-            }
-            if (tool === 'TaskCreate' && (args.description || args.prompt)) {
-                const text = String(args.description || args.prompt || '').slice(0, 140);
-                if (text && !todoItems.includes(text))
-                    todoItems.push(text);
-            }
             if (tool === 'ExitPlanMode') {
                 exitPlanContent = args.result || args.plan || args.content || null;
             }
@@ -796,6 +784,9 @@ export function parseRoleList(raw, flag) {
     return parts;
 }
 function roleOfEvent(e) {
+    // Synthetic scaffolding still maps to 'user' here so `--exclude user` drops it
+    // like any other user-role event (pre-flag behavior). `--include user`'s
+    // "genuine intent only" carve-out lives in applyRoleFilter, not here.
     if (e.type === 'message' && e.role === 'user')
         return 'user';
     if (e.type === 'message' && e.role === 'assistant')
@@ -817,7 +808,14 @@ function applyRoleFilter(events, opts) {
         const set = new Set(opts.include);
         return events.filter(e => {
             const role = roleOfEvent(e);
-            return role !== null && set.has(role);
+            if (role === null)
+                return false;
+            // `--include user` means genuine user intent, so drop harness-injected
+            // `_synthetic` scaffolding (bash-input, system-reminder) even though it
+            // carries role=user. `--exclude user` still drops it via roleOfEvent.
+            if (role === 'user' && e._synthetic)
+                return false;
+            return set.has(role);
         });
     }
     if (opts.exclude && opts.exclude.length > 0) {
@@ -845,7 +843,11 @@ function applyTurnSlice(events, opts) {
     if (!Number.isFinite(n) || n <= 0) {
         throw new Error(`Turn count must be a positive integer, got ${n}`);
     }
-    const isTurnStart = (e) => e.type === 'message' && e.role === 'user';
+    // A turn starts at a GENUINE user message — harness-injected `_synthetic`
+    // scaffolding (`<bash-input>`/`<bash-stdout>`, etc.) does not start a turn,
+    // so `--first N` / `--last N` count real asks, not the jump command that
+    // opened the session and its shell output.
+    const isTurnStart = (e) => e.type === 'message' && e.role === 'user' && !e._synthetic;
     const turnStartIdx = [];
     for (let i = 0; i < events.length; i++)
         if (isTurnStart(events[i]))

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

@@ -126,6 +126,10 @@ export interface StateContext {
  * list, so a session with no plan carries no `todos` field.
  */
 export declare function extractTodoProgress(args?: Record<string, any>): TodoProgress | undefined;
+/** Fold snapshot checklist tools and Claude TaskCreate/TaskUpdate event logs. */
+export declare function extractTodoProgressFromEvents(events: SessionEvent[]): TodoProgress | undefined;
+/** Derive a recency-ordered, de-duplicated list of directories touched by tools. */
+export declare function extractRecentDirectoriesTouched(events: SessionEvent[], cwd?: string): string[] | undefined;
 /** Detect a worktree from the session cwd, per the `.agents/worktrees/<slug>/` convention. */
 export declare function detectWorktree(cwd?: string, branch?: string): DetectedWorktree | undefined;
 /** Detect a tracker ticket from free text (prompt/topic) then a branch name. */