@phnx-labs/agents-cli 1.22.53 → 1.22.54

package/dist/lib/session/active.js

@@ -45,6 +45,7 @@ import { classifyHostLink, HOST_HEARTBEAT_STALE_MS } from './host-link.js';
 import { mapBounded } from '../concurrency.js';
 import { linearIssueUrl } from './linear.js';
 import { viewingInLabel } from './viewing-in.js';
+import { claudeProjectDirName } from '../project-key.js';
 const execFileAsync = promisify(execFile);
 /**
  * The owner (actor id) to show for a session in `--active`. Prefers the actor
@@ -530,10 +531,6 @@ function readLiveTerminals() {
     }
     return Array.from(merged.values());
 }
-/** Convert an absolute cwd to the Claude-project folder name (slashes and dots → dashes). */
-function claudeProjectDirName(cwd) {
-    return cwd.replace(/[/.]/g, '-');
-}
 /**
  * Process-local memo for Claude transcript path resolution. Each active-session
  * poll re-walks every Claude version-home `projects/` tree for every live pid

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

@@ -12,21 +12,41 @@ import { type IndexedToolCall } from './tool-calls.js';
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 41;
+export declare const SCHEMA_VERSION = 42;
+/**
+ * Bump to force the content extractor (assistant-answer text, alongside the
+ * user-prompt text every harness already accumulates) to re-derive on every
+ * session's next scan. Unlike RESOURCE_INDEX_VERSION this is read by the
+ * change-detector itself (`filterChangedEntries`, discover.ts) via
+ * `scan_ledger.extractor_version` — a stored version below this one is treated
+ * as "changed" even when the file's (mtime, size) are unchanged, so bumping it
+ * here backfills every existing session's assistant text on its next scan
+ * without a `DELETE FROM scan_ledger` (which would also throw away the
+ * resumable parser_state/content_text for Claude/Codex).
+ */
+export declare const CONTENT_INDEX_VERSION = 1;
 /**
  * Bumping this invalidates every cached facet row without touching the schema
  * version, so a change to the extraction logic (a new metric, a corrected bucket)
  * re-derives on the next `agents insights` instead of silently reporting stale
  * numbers alongside fresh ones. Same role as RESOURCE_INDEX_VERSION.
  */
-/** Bump when facet extraction changes so cached rows recompute (stalls-by-model v6). */
-export declare const INSIGHTS_EXTRACTOR_VERSION = 6;
+/** Bump when facet extraction changes so cached rows recompute (shell-command-by-binary v7). */
+export declare const INSIGHTS_EXTRACTOR_VERSION = 7;
 export declare const SESSION_TOPIC_EXTRACTOR_VERSION = 1;
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
     fileMtimeMs: number;
     fileSize: number;
     scannedAt?: number;
+    /**
+     * `scan_ledger.extractor_version` as of the last scan, when read from the
+     * ledger (undefined for a freshly-computed stamp that hasn't been persisted
+     * yet). Compared against {@link CONTENT_INDEX_VERSION} by
+     * `filterChangedEntries` (discover.ts) to force a re-extract independent of
+     * (mtime, size).
+     */
+    extractorVersion?: number | null;
 }
 /** Filter and pagination options for querying the sessions table. */
 export interface QueryOptions {
@@ -163,6 +183,10 @@ interface ParserStateRow {
     fileMtimeMs: number;
     fileSize: number;
     scannedAt: number;
+    /** See {@link ScanStamp.extractorVersion}. A mismatch vs CONTENT_INDEX_VERSION
+     *  means this continuation predates the current content extractor and MUST
+     *  be treated as absent (forcing a full re-parse) rather than resumed from. */
+    extractorVersion: number | null;
 }
 /**
  * Bulk-load the resumable-parse continuation (parser_state + content_text) plus
@@ -208,11 +232,15 @@ export declare function recordDirScans(entries: Array<{
  * 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 declare function upsertSession(meta: SessionMeta, content: string, scan?: ScanStamp): void;
+export declare function upsertSession(meta: SessionMeta, content: string, scan?: ScanStamp, assistantContent?: string): void;
 /** Batch-upsert sessions with their FTS5 content and scan stamps in a single transaction. */
 export declare function upsertSessionsBatch(entries: Array<{
     meta: SessionMeta;
     content: string;
+    /** Assistant-answer text, accumulated the same way as `content` (the
+     *  user-prompt text) but stored in session_text's own `assistant` column
+     *  with a lower BM25 weight — see BM25_WEIGHTS. */
+    assistantContent?: string;
     scan?: ScanStamp;
     parserState?: string;
     contentText?: string;
@@ -584,6 +612,13 @@ interface FtsHit {
     sessionId: string;
     score: number;
     matchedTerms: string[];
+    /**
+     * A short bm25 `snippet()` excerpt around the best-matching column (label,
+     * topic, project, user content, or assistant answer), with the matched
+     * term(s) wrapped in `**…**`. Absent for a handle/label-tier hit (tiers 1-3
+     * below), which has no excerpt to show — the label itself IS the match.
+     */
+    snippet?: string;
 }
 /**
  * Escape a raw user query into a safe FTS5 MATCH expression.

package/dist/lib/session/db.js

@@ -27,7 +27,19 @@ const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 41;
+export const SCHEMA_VERSION = 42;
+/**
+ * Bump to force the content extractor (assistant-answer text, alongside the
+ * user-prompt text every harness already accumulates) to re-derive on every
+ * session's next scan. Unlike RESOURCE_INDEX_VERSION this is read by the
+ * change-detector itself (`filterChangedEntries`, discover.ts) via
+ * `scan_ledger.extractor_version` — a stored version below this one is treated
+ * as "changed" even when the file's (mtime, size) are unchanged, so bumping it
+ * here backfills every existing session's assistant text on its next scan
+ * without a `DELETE FROM scan_ledger` (which would also throw away the
+ * resumable parser_state/content_text for Claude/Codex).
+ */
+export const CONTENT_INDEX_VERSION = 1;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -54,10 +66,15 @@ function canonicalLedgerKey(filePath) {
         return filePath;
     }
 }
-// BM25 column weights for session_text: label > topic > project > content.
-// Higher weights make matches in that column rank higher.
-/** BM25 column weights for FTS5: label > topic > project > content. */
-const BM25_WEIGHTS = [5.0, 2.0, 1.5, 1.0];
+// BM25 column weights for session_text: label > topic > project > content >
+// assistant. Higher weights make matches in that column rank higher.
+// `assistant` (the agent's own answers) is weighted BELOW `content` (the
+// user's prompts): a user's own words are a stronger signal of "this is the
+// session I meant" than the agent echoing/paraphrasing them back, so an
+// assistant-only match still surfaces but ranks behind an equivalent
+// user-prompt match.
+/** BM25 column weights for FTS5: label > topic > project > content > assistant. */
+const BM25_WEIGHTS = [5.0, 2.0, 1.5, 1.0, 0.5];
 /** DDL for the sessions database (tables, indexes, FTS5 virtual table). */
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS sessions (
@@ -135,6 +152,7 @@ CREATE VIRTUAL TABLE IF NOT EXISTS session_text USING fts5(
   topic,
   project,
   content,
+  assistant,
   tokenize = 'unicode61 remove_diacritics 2'
 );
 
@@ -158,7 +176,13 @@ CREATE TABLE IF NOT EXISTS scan_ledger (
   -- doc so detectTicket + FTS can rebuild on append without re-reading the file.
   -- Written by B-2; B-1 only defines + round-trips them.
   parser_state TEXT,
-  content_text TEXT
+  content_text TEXT,
+  -- CONTENT_INDEX_VERSION this row's session_text content was last extracted
+  -- at. NULL (a pre-v42 row) never equals the current constant, so the
+  -- change-detector (filterChangedEntries) treats it as changed even when
+  -- (mtime, size) match — the lever that backfills assistant text into
+  -- existing sessions without wiping scan_ledger outright.
+  extractor_version INTEGER
 );
 
 -- Tracks the mtime + entry-count of every LEAF directory that directly holds
@@ -409,8 +433,8 @@ CREATE INDEX IF NOT EXISTS idx_computer_sessions_started ON computer_sessions(st
  * re-derives on the next `agents insights` instead of silently reporting stale
  * numbers alongside fresh ones. Same role as RESOURCE_INDEX_VERSION.
  */
-/** Bump when facet extraction changes so cached rows recompute (stalls-by-model v6). */
-export const INSIGHTS_EXTRACTOR_VERSION = 6;
+/** Bump when facet extraction changes so cached rows recompute (shell-command-by-binary v7). */
+export const INSIGHTS_EXTRACTOR_VERSION = 7;
 export const SESSION_TOPIC_EXTRACTOR_VERSION = 1;
 const PREVIEW_EXTRACTOR_VERSION = 1;
 let dbInstance = null;
@@ -1085,6 +1109,48 @@ function migrateSchema(db, fromVersion) {
         if (!cols.has('harness'))
             db.exec(`ALTER TABLE sessions ADD COLUMN harness TEXT`);
     }
+    if (fromVersion < 42) {
+        // v41 -> v42: index the agent's ANSWERS, not just the user's prompts.
+        // session_text gains an `assistant` column (own FTS5 column, own lower
+        // BM25 weight — see BM25_WEIGHTS) and scan_ledger gains `extractor_version`
+        // so the change-detector can force a re-extract independent of
+        // (mtime, size). FTS5 can't ALTER a virtual table's column set, but unlike
+        // v1->v2 (which dropped the table and forced a blind full rescan of
+        // everything), the existing label/topic/project/content in every row is
+        // still exactly right — only `assistant` is missing. Rename the old table
+        // out of the way, create the new 6-column one, and copy the old rows back
+        // in (assistant defaults to '' until the extractor_version lever backfills
+        // it on that row's next scan) — search over label/topic/project/content
+        // never blacks out for the transient window it takes existing sessions to
+        // get rescanned, which can be a long time for a session whose transcript
+        // is otherwise cold.
+        db.exec(`ALTER TABLE session_text RENAME TO session_text_v41`);
+        db.exec(`
+      CREATE VIRTUAL TABLE session_text USING fts5(
+        session_id UNINDEXED,
+        label,
+        topic,
+        project,
+        content,
+        assistant,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+    `);
+        db.exec(`
+      INSERT INTO session_text (session_id, label, topic, project, content, assistant)
+      SELECT session_id, label, topic, project, content, '' FROM session_text_v41
+    `);
+        db.exec(`DROP TABLE session_text_v41`);
+        const ledgerCols = db.prepare(`PRAGMA table_info(scan_ledger)`).all();
+        if (!ledgerCols.some(c => c.name === 'extractor_version')) {
+            db.exec(`ALTER TABLE scan_ledger ADD COLUMN extractor_version INTEGER`);
+        }
+        // No `DELETE FROM scan_ledger` — the new column is NULL on every existing
+        // row, which already never equals CONTENT_INDEX_VERSION, so every session
+        // re-extracts on its next scan while parser_state/content_text (the
+        // Claude/Codex resumable continuation) stay intact for rows that don't
+        // need a full reparse for any OTHER reason.
+    }
 }
 /**
  * Stamp `account_key` / `account_org` / `account` on every Claude row from its
@@ -1455,13 +1521,18 @@ export function getScanStampsForPaths(filePaths) {
         const placeholders = chunk.map(() => '?').join(',');
         const rows = db
             .prepare(`
-        SELECT file_path, file_mtime_ms, file_size, scanned_at
+        SELECT file_path, file_mtime_ms, file_size, scanned_at, extractor_version
         FROM scan_ledger
         WHERE file_path IN (${placeholders})
       `)
             .all(...chunk);
         for (const row of rows) {
-            const stamp = { fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, scannedAt: row.scanned_at };
+            const stamp = {
+                fileMtimeMs: row.file_mtime_ms,
+                fileSize: row.file_size,
+                scannedAt: row.scanned_at,
+                extractorVersion: row.extractor_version,
+            };
             for (const original of canonicalToOriginals.get(row.file_path) || []) {
                 result.set(original, stamp);
             }
@@ -1498,7 +1569,7 @@ export function getParserStatesForPaths(filePaths) {
         const placeholders = chunk.map(() => '?').join(',');
         const rows = db
             .prepare(`
-        SELECT file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text
+        SELECT file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text, extractor_version
         FROM scan_ledger
         WHERE file_path IN (${placeholders})
       `)
@@ -1510,6 +1581,7 @@ export function getParserStatesForPaths(filePaths) {
                 fileMtimeMs: row.file_mtime_ms,
                 fileSize: row.file_size,
                 scannedAt: row.scanned_at,
+                extractorVersion: row.extractor_version,
             };
             for (const original of canonicalToOriginals.get(row.file_path) || []) {
                 result.set(original, state);
@@ -1527,17 +1599,23 @@ export function recordScans(entries) {
         return;
     const db = getDB();
     const stmt = db.prepare(`
-    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at)
-    VALUES (?, ?, ?, ?)
+    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at, extractor_version)
+    VALUES (?, ?, ?, ?, ?)
     ON CONFLICT(file_path) DO UPDATE SET
       file_mtime_ms = excluded.file_mtime_ms,
       file_size = excluded.file_size,
-      scanned_at = excluded.scanned_at
+      scanned_at = excluded.scanned_at,
+      extractor_version = excluded.extractor_version
   `);
     const now = Date.now();
     const txn = db.transaction((items) => {
         for (const { filePath, scan } of items) {
-            stmt.run(canonicalLedgerKey(filePath), scan.fileMtimeMs, scan.fileSize, now);
+            // Stamped at the CURRENT content extractor version even for a file that
+            // yielded no session (malformed / no id): we ran today's extractor over
+            // it and it produced nothing, so it is current, not stale — otherwise a
+            // permanently-unparseable file would re-trigger "changed" on every scan
+            // forever once CONTENT_INDEX_VERSION is bumped.
+            stmt.run(canonicalLedgerKey(filePath), scan.fileMtimeMs, scan.fileSize, now, CONTENT_INDEX_VERSION);
         }
     });
     txn(entries);
@@ -1867,7 +1945,7 @@ function enrichCachedSessionMeta(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 (?, ?, ?, ?, ?)`);
+const insertTextStmt = (db) => db.prepare(`INSERT INTO session_text (session_id, label, topic, project, content, assistant) VALUES (?, ?, ?, ?, ?, ?)`);
 // Read back the label the upsert actually stored (which may be the preserved
 // one, not the incoming blank) so the FTS label column stays consistent with
 // sessions.label after a bare rescan.
@@ -1904,7 +1982,7 @@ function resolveMachine(meta) {
  * 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) {
+export function upsertSession(meta, content, scan, assistantContent = '') {
     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
@@ -1975,7 +2053,7 @@ export function upsertSession(meta, content, scan) {
         insText.run(meta.id, 
         // Use the label the upsert actually stored (preserve-non-empty rule),
         // not the raw incoming one, so FTS label ranking survives a bare rescan.
-        storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '');
+        storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '', assistantContent ?? '');
     });
     txn();
 }
@@ -1993,19 +2071,23 @@ export function upsertSessionsBatch(entries) {
     // 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
+    // alongside the stamp, plus the CURRENT content extractor version — a caller
+    // that reached this batch write ran today's extractor over the file, so the
+    // ledger row is current regardless of which branch (full/incremental)
+    // produced it. On a full/incremental Claude parse the caller passes the
     // serialized newState + accumulated user doc so the NEXT scan can resume from
     // the persisted offset (B-2). Other scanners pass neither, leaving both columns
     // NULL exactly as before — their ledger rows are unaffected.
     const ledger = db.prepare(`
-    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text)
-    VALUES (?, ?, ?, ?, ?, ?)
+    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text, extractor_version)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(file_path) DO UPDATE SET
       file_mtime_ms = excluded.file_mtime_ms,
       file_size = excluded.file_size,
       scanned_at = excluded.scanned_at,
       parser_state = excluded.parser_state,
-      content_text = excluded.content_text
+      content_text = excluded.content_text,
+      extractor_version = excluded.extractor_version
   `);
     // Build a lookup from canonical file path → entry, used inside the write
     // transaction to re-check the ledger AFTER acquiring the lock. When a
@@ -2076,17 +2158,26 @@ export function upsertSessionsBatch(entries) {
             const chunk = paths.slice(i, i + CHUNK);
             const phs = chunk.map(() => '?').join(',');
             const rows = db
-                .prepare(`SELECT file_path, file_mtime_ms, file_size FROM scan_ledger WHERE file_path IN (${phs})`)
+                .prepare(`SELECT file_path, file_mtime_ms, file_size, extractor_version FROM scan_ledger WHERE file_path IN (${phs})`)
                 .all(...chunk);
             for (const row of rows) {
                 const entry = byPath.get(row.file_path);
-                if (entry && row.file_mtime_ms === entry.scan.fileMtimeMs && row.file_size === entry.scan.fileSize) {
+                // A concurrent writer's row only makes THIS entry redundant when it is
+                // current at CONTENT_INDEX_VERSION too — otherwise a (mtime, size) match
+                // alone would make the version lever a no-op: the very reason this batch
+                // was scheduled (a stale extractor_version) would be silently skipped as
+                // "someone else already indexed it", when what they indexed predates the
+                // current extractor.
+                if (entry &&
+                    row.file_mtime_ms === entry.scan.fileMtimeMs &&
+                    row.file_size === entry.scan.fileSize &&
+                    row.extractor_version === CONTENT_INDEX_VERSION) {
                     alreadyIndexed.add(entry.meta.id);
                 }
             }
         }
         for (const entry of items) {
-            const { meta, content, scan, parserState, contentText } = entry;
+            const { meta, content, assistantContent, scan, parserState, contentText } = entry;
             if (alreadyIndexed.has(meta.id))
                 continue;
             // Per-row guard: one malformed session (e.g. a required field that resolves to
@@ -2170,9 +2261,9 @@ export function upsertSessionsBatch(entries) {
                 insText.run(meta.id, 
                 // Mirror upsertSession: index the label the upsert actually stored
                 // (preserve-non-empty rule), not the raw incoming one.
-                storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '');
+                storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '', assistantContent ?? '');
                 if (scan && meta.filePath) {
-                    ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now, parserState ?? null, contentText ?? null);
+                    ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now, parserState ?? null, contentText ?? null, CONTENT_INDEX_VERSION);
                 }
                 writtenEntries.push(entry);
             }
@@ -3510,11 +3601,16 @@ export function ftsSearch(input, limit = 200) {
         return hits.slice(0, limit);
     }
     // Tier 4: FTS5 content match, skipping anything already surfaced via label.
+    // `snippet(session_text, -1, ...)` lets FTS5 pick the best-matching column
+    // itself (label/topic/project/content/assistant) rather than us guessing —
+    // a query that only matched in `assistant` (an agent-only answer) still gets
+    // an excerpt from the right column instead of an empty content snippet.
     if (expr) {
         try {
             const rows = db
                 .prepare(`
-          SELECT session_id, bm25(session_text, ${BM25_WEIGHTS.join(', ')}) AS rank
+          SELECT session_id, bm25(session_text, ${BM25_WEIGHTS.join(', ')}) AS rank,
+                 snippet(session_text, -1, '**', '**', '…', 12) AS snip
           FROM session_text
           WHERE session_text MATCH ?
           ORDER BY rank ASC
@@ -3524,7 +3620,12 @@ export function ftsSearch(input, limit = 200) {
             for (const r of rows) {
                 if (seen.has(r.session_id))
                     continue;
-                hits.push({ sessionId: r.session_id, score: -r.rank, matchedTerms: terms });
+                hits.push({
+                    sessionId: r.session_id,
+                    score: -r.rank,
+                    matchedTerms: terms,
+                    snippet: r.snip?.trim() || undefined,
+                });
                 seen.add(r.session_id);
             }
         }

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

@@ -104,6 +104,8 @@ interface ClaudeSessionScan {
     entrypoint?: string;
     /** Concatenated user message text, ready to hand to FTS5. */
     contentText?: string;
+    /** Concatenated assistant-answer text, ready to hand to FTS5's `assistant` column. */
+    assistantText?: string;
     /** Durable state signals persisted to the index by the session-state engine. */
     prUrl?: string;
     prNumber?: number;
@@ -154,6 +156,7 @@ interface CodexSessionScan {
     durationMs?: number;
     lastActivity?: string;
     contentText?: string;
+    assistantText?: string;
     prUrl?: string;
     prNumber?: number;
     worktreeSlug?: string;
@@ -347,8 +350,15 @@ export declare function looksLikeSessionId(query: string): boolean;
  */
 export declare function resolveSessionById(sessions: SessionMeta[], idQuery: string): SessionMeta[];
 /**
- * Run an FTS5 search over the DB and intersect with the given session list,
- * preserving the existing SessionMeta[] contract so sessions.ts is unchanged.
+ * Run an FTS5 search over the DB and union hits with the given session list.
+ *
+ * The listing pool is a minority of the index — cwd-scoped, default-capped at
+ * 50, and skipping whole classes of indexed transcript — so intersecting FTS
+ * hits with it dropped grep-visible sessions that the index already found
+ * (PHNX-2767: `agents sessions "tmux pane"` returned 0 while the project
+ * transcripts matched). Hits already in the pool keep the caller's SessionMeta;
+ * hits the pool missed are hydrated from the index so a content query returns
+ * the transcript FTS matched.
  */
 export declare function searchContentIndex(sessions: SessionMeta[], query: string): Map<string, SessionMeta>;
 /**
@@ -375,6 +385,13 @@ interface PreStatEntry {
  * stat. Same debounce and change-detection as filterChangedFiles; the raw
  * mtime is floored here so warm files match the ledger exactly as the stat path
  * does (Math.floor(stat.mtimeMs)).
+ *
+ * A file is also treated as "changed" — independent of (mtime, size) — when
+ * its ledger row's `extractor_version` is behind {@link CONTENT_INDEX_VERSION}.
+ * This is the lever that backfills a content-extractor improvement (e.g.
+ * indexing assistant answers, not just user prompts) into every already-scanned
+ * session on its next pass, without a `DELETE FROM scan_ledger` that would also
+ * discard the Claude/Codex resumable parser_state.
  */
 export declare function filterChangedEntries(entries: PreStatEntry[]): Array<{
     filePath: string;
@@ -429,9 +446,11 @@ export declare function parseCodexThreadNameIndex(raw: string): Map<string, stri
 export declare function readCodexMeta(filePath: string, resolveAccount?: () => string | undefined, currentVersion?: string, scanStamp?: ScanStamp, priorRow?: {
     parserState: string | null;
     fileMtimeMs: number;
+    extractorVersion?: number | null;
 }): Promise<{
     meta: SessionMeta;
     content: string;
+    assistantContent: string;
     parserState?: string;
     contentText?: string;
     toolCalls?: IndexedToolCall[];
@@ -469,6 +488,10 @@ interface ClaudeParseState {
     lastTsMs?: number;
     seenAssistantIds: Set<string>;
     userTexts: string[];
+    /** Assistant-answer text (#PHNX content-search), accumulated the same way as
+     *  `userTexts` but indexed into session_text's own lower-weighted `assistant`
+     *  column instead of `content` — see BM25_WEIGHTS. */
+    assistantTexts: string[];
     sawPrCreate: boolean;
     prUrl?: string;
     prNumber?: number;
@@ -521,7 +544,7 @@ export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessi
  * exact even when the recent window is smaller than the true count.
  */
 export interface ClaudeParserState {
-    v: 4;
+    v: 5;
     /**
      * Fan-out tallies carried across a RESUMED parse (RUSH-3091/3095). They must
      * live in the durable blob: the resumable parser reads only new bytes, so
@@ -566,6 +589,7 @@ export interface ClaudeParserState {
     spawnedTeam?: string;
     ticketId?: string;
     contentText?: string;
+    assistantContentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
     toolCalls: ToolCallCollectorSnapshot;
@@ -663,6 +687,8 @@ interface CodexParseState {
     firstTsMs?: number;
     lastTsMs?: number;
     userTexts: string[];
+    /** See ClaudeParseState.assistantTexts — same accumulate-and-lower-weight FTS treatment. */
+    assistantTexts: string[];
     sawPrCreate: boolean;
     prUrl?: string;
     prNumber?: number;
@@ -693,7 +719,7 @@ export declare function initCodexParseState(): CodexParseState;
  * finalize is identical after a resume.
  */
 export interface CodexParserState {
-    v: 2;
+    v: 3;
     offset: number;
     jsonlDroppingOversizedLine?: boolean;
     sessionId?: string;
@@ -716,6 +742,7 @@ export interface CodexParserState {
     spawnedTeam?: string;
     ticketId?: string;
     contentText?: string;
+    assistantContentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
     toolCalls: ToolCallCollectorSnapshot;
@@ -772,6 +799,7 @@ export declare function __resetCodexScanBranchCountsForTest(): void;
 export declare function readCursorMeta(filePath: string, currentVersion?: string): {
     meta: SessionMeta;
     content: string;
+    assistantContent: string;
     events: SessionEvent[];
 } | null;
 /** Parse a single Kimi session state.json file to extract session metadata. */