@phnx-labs/agents-cli 1.20.29 → 1.20.30

package/dist/lib/models.js

@@ -165,6 +165,26 @@ export function locateModelSource(agent, version) {
             return { path: pathBin, kind: 'cli' };
         return null;
     }
+    if (agent === 'antigravity') {
+        // The `agy` shim under node_modules/.bin exposes `agy models`. We don't parse
+        // any bundle; the CLI produces its own (display-name-only) catalog.
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'agy');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        const pathBin = findOnPath('agy');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
+    if (agent === 'kimi') {
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'kimi');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        const pathBin = findOnPath('kimi');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
     if (agent === 'cursor') {
         // cursor-agent is installed via curl script, not agents-cli. Version argument
         // is accepted for API symmetry but ignored -- cursor lives on PATH.
@@ -606,6 +626,114 @@ function extractOpenClawCatalog(binaryPath) {
     }));
     return { models, aliases: {} };
 }
+/**
+ * Extract Antigravity's catalog via `agy models`. Antigravity is unusual: it
+ * prints DISPLAY NAMES ONLY, one per line, with no machine ids and no --json:
+ *   Gemini 3.5 Flash (Medium)
+ *   Claude Sonnet 4.6 (Thinking)
+ * Verified (agy 1.0.11) that those display strings ARE the accepted `--model`
+ * values -- `agy --model "Claude Opus 4.6 (Thinking)"` routes to that model,
+ * and an unknown value silently falls back to the first row. So we use each
+ * display string as both id and displayName, and mark the first row default.
+ */
+function extractAntigravityCatalog(binaryPath) {
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['models'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 8 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // Strip ANSI in case a spinner or color codes slip through.
+    // eslint-disable-next-line no-control-regex
+    const plain = stdout.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    const models = [];
+    const seen = new Set();
+    for (const raw of plain.split('\n')) {
+        const name = raw.trim();
+        if (!name)
+            continue;
+        // Guard against any stray banner/usage lines: real rows look like
+        // "<Vendor> <Model> (<Level>)". Require an alphanumeric start and a
+        // parenthesized suffix, which every observed model row has.
+        if (!/^[A-Za-z0-9].*\([^)]+\)\s*$/.test(name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        models.push({
+            id: name,
+            displayName: name,
+            // Antigravity's first listed model is its default (unknown --model values
+            // fall back to it), so flag the first row we accept.
+            isDefault: models.length === 0,
+        });
+    }
+    return { models, aliases: {} };
+}
+/**
+ * Extract Kimi's catalog via `kimi provider list --json`, which emits the raw
+ * providers/models config. Model ids are the `models` object keys (e.g.
+ * `kimi-code/kimi-for-coding`). The default is reported on a separate plain
+ * `Default model: <id>` line by `kimi provider list` (no flags), so we run that
+ * too to flag the default row.
+ */
+function extractKimiCatalog(binaryPath) {
+    let jsonOut;
+    try {
+        jsonOut = execFileSync(binaryPath, ['provider', 'list', '--json'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    const firstBrace = jsonOut.indexOf('{');
+    if (firstBrace === -1)
+        return { models: [], aliases: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonOut.slice(firstBrace));
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // Resolve the default model id from the plain listing's "Default model:" line.
+    let defaultId = null;
+    try {
+        const plain = execFileSync(binaryPath, ['provider', 'list'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10_000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        const m = plain.match(/Default model:\s*(\S+)/);
+        if (m)
+            defaultId = m[1];
+    }
+    catch {
+        /* default flag is best-effort */
+    }
+    const modelsObj = parsed?.models && typeof parsed.models === 'object' ? parsed.models : {};
+    const models = [];
+    for (const id of Object.keys(modelsObj)) {
+        const info = modelsObj[id] ?? {};
+        models.push({
+            id,
+            displayName: typeof info.displayName === 'string' ? info.displayName : undefined,
+            isDefault: defaultId != null && id === defaultId,
+        });
+    }
+    return { models, aliases: {} };
+}
 /**
  * Build (or load from cache) the model catalog for a specific (agent, version).
  * Cache is keyed on source-file mtime (binary or js module), so re-extracts
@@ -654,6 +782,10 @@ export function getModelCatalog(agent, version) {
             ({ models, aliases } = extractCursorCatalog(src.path));
         else if (agent === 'openclaw')
             ({ models, aliases } = extractOpenClawCatalog(src.path));
+        else if (agent === 'antigravity')
+            ({ models, aliases } = extractAntigravityCatalog(src.path));
+        else if (agent === 'kimi')
+            ({ models, aliases } = extractKimiCatalog(src.path));
     }
     const catalog = {
         agent,
@@ -663,11 +795,12 @@ export function getModelCatalog(agent, version) {
         models,
         aliases,
     };
-    // Don't cache empty CLI extractions: the CLI may have been mid-install,
-    // network-dependent, or transiently failing. Caching 0 models would mask
-    // the real catalog forever (mtime won't change). Bundle/binary/js sources
-    // are deterministic, so cache those even when empty.
-    if (src.kind !== 'cli' || models.length > 0) {
+    // Never cache an empty extraction, regardless of source kind. A 0-model
+    // result is always suspect: the CLI may have been mid-install, network-
+    // dependent, or transiently failing, and a js/bundle/binary extractor that
+    // regex-misses would otherwise pin an empty catalog forever (mtime won't
+    // change until the source file does). Only persist a non-empty catalog.
+    if (models.length > 0) {
         cache.entries[key] = { sourcePath: src.path, mtime, catalog };
         saveCache();
     }

package/dist/lib/runner.js

@@ -95,14 +95,14 @@ export function buildJobCommand(config, resolvedPrompt) {
         appendModelAndReasoning(cmd, config);
     }
     if (config.agent === 'kimi') {
+        // kimi daemon jobs always run headless via `--prompt`, which cannot be
+        // combined with any startup-mode flag (--plan/--auto/--yolo all abort with
+        // "Cannot combine --prompt with --X"). edit/auto/skip reduce to kimi's default
+        // headless auto-run, so emit no flag; plan has no headless read-only
+        // equivalent, so fail closed rather than silently allowing writes.
         if (mode === 'plan') {
-            cmd.push('--plan');
-        }
-        else if (mode === 'auto') {
-            cmd.push('--auto');
-        }
-        else if (mode === 'skip') {
-            cmd.push('--yolo');
+            throw new Error('kimi has no headless read-only mode: routine jobs cannot run kimi with --mode plan ' +
+                '(kimi rejects --prompt + --plan). Use --mode edit, auto, or skip.');
         }
         appendModelAndReasoning(cmd, config);
     }

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

@@ -1,3 +1,4 @@
+import { type SessionActivity, type AwaitingReason, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
 export type ActiveContext = 'terminal' | 'teams' | 'cloud' | 'headless';
 export type ActiveStatus = 'running' | 'idle' | 'queued' | 'input_required';
 export interface ActiveSession {
@@ -12,6 +13,18 @@ export interface ActiveSession {
     label?: string;
     /** First meaningful line of the initial prompt (extracted topic). */
     topic?: string;
+    /** Live preview: the latest turn (agent message or tool action), from the state engine. */
+    preview?: string;
+    /** Inferred activity: working / waiting_input / idle (from the transcript tail). */
+    activity?: SessionActivity;
+    /** Why the agent is waiting, when activity is waiting_input. */
+    awaitingReason?: AwaitingReason;
+    /** PR opened during the session. */
+    pr?: DetectedPr;
+    /** Worktree the session runs in. */
+    worktree?: DetectedWorktree;
+    /** Tracker ticket the session is tied to. */
+    ticket?: DetectedTicket;
     sessionFile?: string;
     startedAtMs?: number;
     status: ActiveStatus;

package/dist/lib/session/active.js

@@ -25,7 +25,10 @@ import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
 import { buildClaudeLabelMap } from './discover.js';
+import { latestSessionFileForCwd } from './db.js';
 import { extractSessionTopic } from './prompt.js';
+import { readSessionTail } from './tail.js';
+import { inferSessionState } from './state.js';
 const execFileAsync = promisify(execFile);
 const HOME = os.homedir();
 const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
@@ -42,6 +45,7 @@ const AGENT_CLI_NAMES = {
     gemini: 'gemini',
     'cursor-agent': 'cursor',
     opencode: 'opencode',
+    droid: 'droid',
 };
 function isPidAlive(pid) {
     if (!pid || pid < 1)
@@ -128,6 +132,66 @@ function classifyActivity(sessionFile) {
         return 'running';
     }
 }
+/**
+ * Locate the live transcript for an agent process. Claude files are keyed by
+ * cwd (+ optional session uuid); Codex files are date-partitioned, so we resolve
+ * the newest indexed Codex session for the cwd instead.
+ */
+function findSessionFileForKind(kind, cwd, sessionId) {
+    if (!cwd)
+        return undefined;
+    if (kind === 'claude')
+        return findClaudeSessionFile(cwd, sessionId);
+    if (kind === 'codex')
+        return latestSessionFileForCwd('codex', cwd);
+    return undefined;
+}
+/** Recover the session UUID from a transcript filename (Claude `<uuid>.jsonl`, Codex `rollout-…-<uuid>.jsonl`). */
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function sessionIdFromFile(file) {
+    if (!file)
+        return undefined;
+    return path.basename(file).match(UUID_RE)?.[0];
+}
+/** Infer live state from a session file's tail (Claude/Codex). Undefined when unreadable. */
+function computeLiveState(kind, sessionFile, cwd, pidAlive) {
+    if (!sessionFile)
+        return undefined;
+    const agent = kind === 'codex' ? 'codex' : 'claude';
+    const events = readSessionTail(sessionFile, agent);
+    if (events.length === 0)
+        return undefined;
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionFile).mtimeMs;
+    }
+    catch { /* vanished between calls */ }
+    return inferSessionState(events, { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS });
+}
+/** Map inferred activity onto the coarse ActiveStatus used by the renderer and counts. */
+function statusFromActivity(activity) {
+    return activity === 'working' ? 'running' : activity === 'waiting_input' ? 'input_required' : 'idle';
+}
+/**
+ * Fold a computed SessionState onto an active-session row: rich status +
+ * preview + PR/worktree/ticket badges. With no state (unreadable/non-Claude/
+ * Codex file) it degrades to the mtime-only classification.
+ */
+function applyState(base, state, fallbackFile) {
+    if (!state)
+        return { ...base, status: classifyActivity(fallbackFile) };
+    return {
+        ...base,
+        status: statusFromActivity(state.activity),
+        activity: state.activity,
+        awaitingReason: state.awaitingReason,
+        // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
+        preview: state.preview ?? base.preview,
+        pr: state.pr,
+        worktree: state.worktree,
+        ticket: state.ticket,
+    };
+}
 /**
  * Extract the first user message's content from a Claude JSONL file.
  * Reads only the first ~50 lines for speed, since the user message is
@@ -207,24 +271,22 @@ export async function listTeamsActive() {
     const running = await mgr.listRunning();
     return running.map((a) => {
         const sessionId = a.parentSessionId ?? a.remoteSessionId ?? undefined;
-        const sessionFile = a.agentType === 'claude' && a.cwd
-            ? findClaudeSessionFile(a.cwd, sessionId ?? undefined)
-            : undefined;
+        const sessionFile = findSessionFileForKind(a.agentType, a.cwd ?? undefined, sessionId ?? undefined);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        return {
+        const state = computeLiveState(a.agentType, sessionFile, a.cwd ?? undefined, a.pid ? isPidAlive(a.pid) : true);
+        return applyState({
             context: 'teams',
             kind: a.agentType,
             pid: a.pid ?? undefined,
-            sessionId,
+            sessionId: sessionId ?? sessionIdFromFile(sessionFile),
             cwd: a.cwd ?? undefined,
             label: a.name ?? undefined,
             topic,
             sessionFile,
             startedAtMs: a.startedAt.getTime(),
-            status: classifyActivity(sessionFile),
             teamName: a.taskName,
             agentId: a.agentId,
-        };
+        }, state, sessionFile);
     });
 }
 /** Live editor-terminal agents across every IDE window. */
@@ -240,27 +302,25 @@ export async function listTerminalsActive() {
     // Build label map from Claude's sessions/*.json for /rename support
     const labelMap = buildClaudeLabelMap();
     return entries.map((t) => {
-        const sessionFile = t.kind === 'claude' && t.cwd
-            ? findClaudeSessionFile(t.cwd, t.sessionId)
-            : undefined;
+        const sessionFile = findSessionFileForKind(t.kind, t.cwd ?? undefined, t.sessionId);
         // Prefer label from live terminal, fall back to Claude's session label
         const label = t.label ?? (t.sessionId ? labelMap.get(t.sessionId) : undefined) ?? undefined;
         // Extract topic from session file (first meaningful user message)
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        return {
+        const state = computeLiveState(t.kind, sessionFile, t.cwd ?? undefined, isPidAlive(t.pid));
+        return applyState({
             context: 'terminal',
             kind: t.kind,
             host: detectHost(t.pid, procByPid),
             pid: t.pid,
-            sessionId: t.sessionId,
+            sessionId: t.sessionId ?? sessionIdFromFile(sessionFile),
             cwd: t.cwd ?? undefined,
             label,
             topic,
             sessionFile,
             startedAtMs: t.startedAtMs,
-            status: classifyActivity(sessionFile),
             windowId: t.windowId,
-        };
+        }, state, sessionFile);
     });
 }
 /** Cloud tasks still in a non-terminal state. `tasks.db` may not exist; that's fine. */
@@ -439,20 +499,21 @@ export async function listUnattributedActive(attributed) {
     for (let i = 0; i < candidates.length; i++) {
         const { pid, kind } = candidates[i];
         const cwd = cwds[i];
-        const sessionFile = kind === 'claude' && cwd ? findClaudeSessionFile(cwd) : undefined;
+        const sessionFile = findSessionFileForKind(kind, cwd);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
-        out.push({
+        const state = computeLiveState(kind, sessionFile, cwd, true);
+        out.push(applyState({
             context,
             kind,
             host,
             pid,
             cwd,
+            sessionId: sessionIdFromFile(sessionFile),
             topic,
             sessionFile,
-            status: classifyActivity(sessionFile),
-        });
+        }, state, sessionFile));
     }
     return out;
 }

package/dist/lib/session/cloud.js

@@ -44,6 +44,8 @@ function agentToFormat(agent) {
         return 'codex';
     if (agent === 'rush')
         return 'rush';
+    if (agent === 'droid')
+        return 'droid';
     return null;
 }
 export function assertContained(candidate, rootDir) {

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

@@ -30,6 +30,10 @@ export interface SessionRow {
     file_size: number | null;
     scanned_at: number | null;
     is_team_origin: number;
+    pr_url: string | null;
+    pr_number: number | null;
+    worktree_slug: string | null;
+    ticket_id: string | null;
 }
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
@@ -133,6 +137,13 @@ export declare function syncLabels(labelMap: Map<string, string | null>): number
  * Returns the number of rows updated.
  */
 export declare function syncTopics(topicMap: Map<string, string>): number;
+/**
+ * Newest indexed session file for an agent working in `cwd`. Lets the live
+ * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
+ * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
+ * session hasn't been scanned yet — the caller degrades to no live state.
+ */
+export declare function latestSessionFileForCwd(agent: SessionAgentId, cwd: string): string | undefined;
 /** Query sessions from the database, applying filters and ordering by timestamp descending. */
 export declare function querySessions(options?: QueryOptions): SessionMeta[];
 /** Count sessions matching the given filter options. */

package/dist/lib/session/db.js

@@ -13,7 +13,7 @@ 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 = 6;
+const SCHEMA_VERSION = 7;
 /**
  * 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`
@@ -59,7 +59,11 @@ CREATE TABLE IF NOT EXISTS sessions (
   file_mtime_ms INTEGER,
   file_size INTEGER,
   scanned_at INTEGER,
-  is_team_origin INTEGER DEFAULT 0
+  is_team_origin INTEGER DEFAULT 0,
+  pr_url TEXT,
+  pr_number INTEGER,
+  worktree_slug TEXT,
+  ticket_id TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -157,6 +161,21 @@ function migrateSchema(db, fromVersion) {
         }
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 7) {
+        // v6 → v7: the session-state engine now persists durable signals (PR opened,
+        // worktree, tracker ticket) at scan time. Add the columns and force a full
+        // rescan so every existing session gets them populated.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'pr_url'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN pr_url TEXT`);
+        if (!cols.some(c => c.name === 'pr_number'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN pr_number INTEGER`);
+        if (!cols.some(c => c.name === 'worktree_slug'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN worktree_slug TEXT`);
+        if (!cols.some(c => c.name === 'ticket_id'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN ticket_id TEXT`);
+        db.exec(`DELETE FROM scan_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -367,12 +386,14 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, version, account, timestamp,
     project, cwd, git_branch, topic, label, message_count, token_count,
     cost_usd, duration_ms,
-    file_path, file_mtime_ms, file_size, scanned_at, is_team_origin
+    file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
+    pr_url, pr_number, worktree_slug, ticket_id
   ) VALUES (
     @id, @short_id, @agent, @version, @account, @timestamp,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @cost_usd, @duration_ms,
-    @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin
+    @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
+    @pr_url, @pr_number, @worktree_slug, @ticket_id
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -393,7 +414,11 @@ const upsertSessionStmt = (db) => db.prepare(`
     file_mtime_ms = excluded.file_mtime_ms,
     file_size = excluded.file_size,
     scanned_at = excluded.scanned_at,
-    is_team_origin = excluded.is_team_origin
+    is_team_origin = excluded.is_team_origin,
+    pr_url = excluded.pr_url,
+    pr_number = excluded.pr_number,
+    worktree_slug = excluded.worktree_slug,
+    ticket_id = excluded.ticket_id
 `);
 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 (?, ?, ?, ?, ?)`);
@@ -436,6 +461,10 @@ export function upsertSession(meta, content, scan) {
         file_size: scan?.fileSize ?? null,
         scanned_at: Date.now(),
         is_team_origin: meta.isTeamOrigin ? 1 : 0,
+        pr_url: meta.prUrl ?? null,
+        pr_number: meta.prNumber ?? null,
+        worktree_slug: meta.worktreeSlug ?? null,
+        ticket_id: meta.ticketId ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -511,6 +540,10 @@ export function upsertSessionsBatch(entries) {
                 file_size: scan?.fileSize ?? null,
                 scanned_at: now,
                 is_team_origin: meta.isTeamOrigin ? 1 : 0,
+                pr_url: meta.prUrl ?? null,
+                pr_number: meta.prNumber ?? null,
+                worktree_slug: meta.worktreeSlug ?? null,
+                ticket_id: meta.ticketId ?? null,
             });
             delText.run(meta.id);
             insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
@@ -621,8 +654,32 @@ function rowToMeta(row) {
         topic: row.topic ?? undefined,
         label: row.label ?? undefined,
         isTeamOrigin: row.is_team_origin === 1,
+        prUrl: row.pr_url ?? undefined,
+        prNumber: row.pr_number ?? undefined,
+        worktreeSlug: row.worktree_slug ?? undefined,
+        ticketId: row.ticket_id ?? undefined,
     };
 }
+/**
+ * Newest indexed session file for an agent working in `cwd`. Lets the live
+ * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
+ * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
+ * session hasn't been scanned yet — the caller degrades to no live state.
+ */
+export function latestSessionFileForCwd(agent, cwd) {
+    if (!cwd)
+        return undefined;
+    let normalized = cwd;
+    try {
+        normalized = fs.realpathSync(cwd);
+    }
+    catch { /* use as-is */ }
+    const db = getDB();
+    const row = db
+        .prepare(`SELECT file_path FROM sessions WHERE agent = ? AND cwd = ? ORDER BY timestamp DESC LIMIT 1`)
+        .get(agent, normalized);
+    return row?.file_path;
+}
 /** Build a parameterized WHERE clause from query options. */
 function buildSessionWhere(options) {
     const where = [];

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

@@ -57,6 +57,11 @@ interface ClaudeSessionScan {
     entrypoint?: string;
     /** Concatenated user message text, ready to hand to FTS5. */
     contentText?: string;
+    /** Durable state signals persisted to the index by the session-state engine. */
+    prUrl?: string;
+    prNumber?: number;
+    worktreeSlug?: string;
+    ticketId?: string;
 }
 /**
  * Discover sessions. Scans only files whose (mtime, size) have changed since