@phnx-labs/agents-cli 1.22.52 → 1.22.54

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

@@ -62,7 +62,7 @@ export declare function attributedSetLostPids(prev: Set<number>, next: Set<numbe
 export declare function filterCachedUnattributed(sessions: ActiveSession[], attributed: Set<number>, alive: (pid: number, startedAtMs?: number) => boolean): ActiveSession[];
 type ActiveContext = 'terminal' | 'teams' | 'cloud' | 'headless';
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-export type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness'>;
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
 export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 export declare function isRunningLiveSession(s: ActiveSession): boolean;
@@ -112,6 +112,13 @@ export type RecapSource = 'label' | 'last' | 'prompt';
 export interface ActiveSession {
     context: ActiveContext;
     kind: string;
+    /**
+     * Custom harness / profile name when this live process was launched via
+     * `agents run <profile>` (e.g. `deepseek`). `kind` stays the HOST process
+     * (claude) so transcript lookup and live-signal parsers keep working.
+     * `sessions --active` displays this when set (PHNX-2935).
+     */
+    harness?: string;
     /** Specific host app — 'code', 'cursor', 'codium', 'iterm', 'terminal', 'warp', 'tmux', etc. */
     host?: string;
     pid?: number;
@@ -652,6 +659,8 @@ export declare function listUnattributedActive(attributed: Set<number>): Promise
 /** One tmux pane's resolved agent identity for the authoritative source. */
 interface PaneIdentity {
     agent: string;
+    /** Custom harness/profile name from the launch registry, when set. */
+    harness?: string;
     /** Exact session id when resolvable (launch registry, or the hook join). */
     sessionId?: string;
     /** The agent's OS pid from the launch registry (may differ from `pane_pid`). */

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
@@ -166,6 +167,8 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.origin = m.origin;
         if (!s.routineName && m.routineName)
             s.routineName = m.routineName;
+        if (!s.harness && m.harness)
+            s.harness = m.harness;
     }
 }
 function loadBackfillMetaFor(sessions) {
@@ -528,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
@@ -1010,6 +1009,7 @@ export async function listTeamsActive(opts = {}) {
         return applyState({
             context: 'teams',
             kind: a.agentType,
+            harness: a.profileName ?? undefined,
             pid: a.pid ?? undefined,
             sessionId: resolvedId,
             machine: offloaded ? execHost : undefined,
@@ -1071,6 +1071,7 @@ export async function listTerminalsActive() {
         return applyState({
             context: 'terminal',
             kind: t.kind,
+            harness: pidEntry?.harness,
             host: detectHost(t.pid, procByPid),
             tty: procByPid.get(t.pid)?.tty,
             pid: t.pid,
@@ -1557,6 +1558,7 @@ async function listUnattributedActiveLive(attributed) {
         out.push(applyState({
             context,
             kind,
+            harness: entry?.harness,
             host,
             tty: procByPid.get(pid)?.tty,
             pid,
@@ -1621,7 +1623,7 @@ export function resolvePaneIdentity(pane, sessName, meta, liveEntry, getHookInde
                 terminalId: liveEntry.terminalId,
             })?.session_id
             ?? nameSessionId;
-        return { agent: liveEntry.agent, sessionId, pid: liveEntry.pid };
+        return { agent: liveEntry.agent, harness: liveEntry.harness, sessionId, pid: liveEntry.pid };
     }
     // No live-registry entry. Session-meta labels are the wrapped-origin fallback;
     // prefer them, then fall back to the name so a pane with neither a registry
@@ -1771,6 +1773,7 @@ export async function listTmuxAgentSessions() {
         out.push(applyState({
             context: 'terminal',
             kind: id.agent,
+            harness: id.harness,
             host: 'tmux',
             pid,
             sessionId: id.sessionId ?? sessionIdFromFile(sessionFile),

package/dist/lib/session/actor-sidecar.d.ts

@@ -7,6 +7,13 @@ export interface SessionActorRecord {
     initiatedBy?: 'human' | 'agent';
     /** Effective permissions mode used by the launcher. */
     mode?: SessionRunMode;
+    /**
+     * Custom harness / profile name when launched via `agents run <profile>`
+     * (e.g. `deepseek`). Joined onto the session index at scan time so a
+     * durable listing can distinguish the profile from its host agent
+     * (PHNX-2935).
+     */
+    harness?: string;
     /** Stable wrapper names that resolve to this native session id. */
     aliases?: string[];
     startedAtMs: number;

package/dist/lib/session/actor-sidecar.js

@@ -40,6 +40,7 @@ function isSafeAlias(alias) {
 function hasRecordData(record) {
     return typeof record.actor === 'string'
         || typeof record.mode === 'string'
+        || typeof record.harness === 'string'
         || (Array.isArray(record.aliases) && record.aliases.some(alias => typeof alias === 'string'));
 }
 function normalizedAliases(aliases) {
@@ -83,6 +84,7 @@ export function writeSessionAliasRecord(sessionId, alias) {
             actor: previous?.actor,
             initiatedBy: previous?.initiatedBy,
             mode: previous?.mode,
+            harness: previous?.harness,
             aliases: normalizedAliases([...(previous?.aliases ?? []), alias]),
             startedAtMs: previous?.startedAtMs ?? Date.now(),
         });

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 = 40;
+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 = 40;
+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,16 +66,22 @@ 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 (
   id TEXT PRIMARY KEY,
   short_id TEXT NOT NULL,
   agent TEXT NOT NULL,
+  harness TEXT,
   origin TEXT DEFAULT 'cli',
   routine_name TEXT,
   routine_run_id TEXT,
@@ -134,6 +152,7 @@ CREATE VIRTUAL TABLE IF NOT EXISTS session_text USING fts5(
   topic,
   project,
   content,
+  assistant,
   tokenize = 'unicode61 remove_diacritics 2'
 );
 
@@ -157,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
@@ -408,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;
@@ -1072,6 +1097,60 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN background_shell_count INTEGER`);
         }
     }
+    if (fromVersion < 41) {
+        // v40 -> v41: persist the custom-harness / profile name a run was launched
+        // as (PHNX-2935). Transcript discovery still keys `agent` on the HOST
+        // (the file lives under the host's session dir), so without this column
+        // `agents sessions` cannot tell `agents run deepseek` from a native claude
+        // run. Additive, no ledger flush — the name is launch metadata joined from
+        // the actor sidecar, not parsed from the transcript. Pre-upgrade rows stay
+        // NULL (native / unknown) until a sidecar-backed rescan fills them.
+        const cols = new Set(db.prepare(`PRAGMA table_info(sessions)`).all().map((c) => c.name));
+        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
@@ -1194,6 +1273,21 @@ export function getDB() {
         db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_machine_ts ON sessions(machine, timestamp DESC)`);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_agent_ts ON sessions(agent, timestamp DESC)`);
     }
+    // harness column: only after the column is guaranteed present.
+    // Fresh SCHEMA (v41) includes the column; older DBs get it from migrate v41.
+    // schema_version can be stamped at SCHEMA_VERSION without the column existing
+    // — getDB writes the marker for any DB whose meta has no row (a hand-built
+    // or partially-created index), and migrateSchema never runs in that path
+    // (`currentVersion === undefined`). If a partial upgrade left schema_version
+    // ahead of the column, repair here so the next upsertSession INSERT naming
+    // `harness` does not throw (PHNX-2935). Same shape as the `machine` repair
+    // above, for the same reason.
+    {
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some((c) => c.name === 'harness')) {
+            db.exec(`ALTER TABLE sessions ADD COLUMN harness TEXT`);
+        }
+    }
     // One-shot cleanup of the pre-SQLite JSONL indexes. Safe — nothing reads
     // them anymore. Guarded by a meta flag so we only try once.
     const cleaned = db.prepare(`SELECT value FROM meta WHERE key = 'legacy_indexes_removed'`).get();
@@ -1427,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);
             }
@@ -1470,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})
       `)
@@ -1482,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);
@@ -1499,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);
@@ -1583,7 +1689,7 @@ export function recordDirScans(entries) {
 }
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
-    id, short_id, agent, origin, routine_name, routine_run_id,
+    id, short_id, agent, harness, origin, routine_name, routine_run_id,
     version, account, account_key, account_org, mode, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
     output_tokens, input_tokens, cache_read_tokens, cache_write_tokens,
@@ -1594,7 +1700,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     recent_directories_touched, linear_project, linear_project_url, machine,
     actor, initiated_by, used_browser, used_computer
   ) VALUES (
-    @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
+    @id, @short_id, @agent, @harness, @origin, @routine_name, @routine_run_id,
     @version, @account, @account_key, @account_org, @mode, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @output_tokens, @input_tokens, @cache_read_tokens, @cache_write_tokens,
@@ -1608,6 +1714,11 @@ const upsertSessionStmt = (db) => db.prepare(`
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
     agent = excluded.agent,
+    -- Custom harness/profile name is launch metadata, not transcript-derived.
+    -- COALESCE(existing, incoming) keeps a stored stamp on rescan (the scanner
+    -- carries none) and backfills a NULL-first row once the sidecar lands —
+    -- the same write-once pattern as actor/initiated_by (PHNX-2935).
+    harness = COALESCE(sessions.harness, excluded.harness),
     origin = excluded.origin,
     routine_name = excluded.routine_name,
     routine_run_id = excluded.routine_run_id,
@@ -1834,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.
@@ -1871,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
@@ -1886,6 +1997,7 @@ export function upsertSession(meta, content, scan) {
         id: meta.id,
         short_id: meta.shortId,
         agent: meta.agent,
+        harness: meta.harness ?? actorRec?.harness ?? null,
         origin: meta.origin ?? 'cli',
         routine_name: meta.routineName ?? null,
         routine_run_id: meta.routineRunId ?? null,
@@ -1941,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();
 }
@@ -1959,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
@@ -2042,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
@@ -2081,6 +2206,7 @@ export function upsertSessionsBatch(entries) {
                     id: meta.id,
                     short_id: meta.shortId,
                     agent: meta.agent,
+                    harness: meta.harness ?? actorIndex.get(meta.id)?.harness ?? null,
                     origin: meta.origin ?? 'cli',
                     routine_name: meta.routineName ?? null,
                     routine_run_id: meta.routineRunId ?? null,
@@ -2135,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);
             }
@@ -2309,6 +2435,7 @@ function rowToMeta(row) {
         id: row.id,
         shortId: row.short_id,
         agent: row.agent,
+        harness: row.harness ?? undefined,
         origin: (row.origin === 'routine' ? 'routine' : 'cli'),
         routineName: row.routine_name ?? undefined,
         routineRunId: row.routine_run_id ?? undefined,
@@ -3474,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
@@ -3488,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);
             }
         }