@phnx-labs/agents-cli 1.20.34 → 1.20.36

package/dist/lib/session/active.js

@@ -24,13 +24,23 @@ import { promisify } from 'util';
 import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
+import { readPidSessionEntry, prunePidSessionRegistry } from './pid-registry.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';
 import { detectProvenance } from './provenance.js';
+import { mapBounded } from '../concurrency.js';
 const execFileAsync = promisify(execFile);
+/**
+ * Per-PID `lsof` probes run bounded and staggered rather than as one parallel
+ * fan-out: a simultaneous system-wide `lsof` burst reads to behavioral EDR
+ * (CrowdStrike Falcon) as lateral-movement recon. Results are identical — the
+ * cwds are just gathered at a bounded spawn rate instead of a single burst.
+ */
+export const LSOF_CONCURRENCY = 4;
+const LSOF_STAGGER_MS = 10;
 const HOME = os.homedir();
 const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
 /**
@@ -48,6 +58,19 @@ const AGENT_CLI_NAMES = {
     opencode: 'opencode',
     droid: 'droid',
 };
+/**
+ * Resolve an agent kind from a process's reported executable. `comm` may be an
+ * absolute path (shim-launched agents), and Windows image names carry an
+ * `.exe` suffix (`claude.exe`), so basename + suffix-strip before the lookup.
+ */
+function agentKindFromComm(commRaw) {
+    const base = path.basename(commRaw);
+    const stripped = base.replace(/\.exe$/i, '');
+    // Windows image names compare case-insensitively; POSIX comms stay exact —
+    // macOS's Claude desktop app process is named 'Claude' and must NOT match.
+    const key = stripped === base ? base : stripped.toLowerCase();
+    return AGENT_CLI_NAMES[key];
+}
 function isPidAlive(pid) {
     if (!pid || pid < 1)
         return false;
@@ -354,14 +377,14 @@ export function listCloudActive() {
  * and a terminal-app is preferred over the multiplexer inside it.
  */
 const HOST_MATCHERS = [
-    // IDE renderers (Electron helper processes)
-    { host: 'code', tokens: ['Code Helper', 'Code - Insiders Helper'] },
-    { host: 'cursor', tokens: ['Cursor Helper'] },
-    { host: 'codium', tokens: ['VSCodium Helper'] },
-    { host: 'windsurf', tokens: ['Windsurf Helper'] },
+    // IDE renderers (Electron helper processes on macOS, image names on Windows)
+    { host: 'code', tokens: ['Code Helper', 'Code - Insiders Helper', 'Code.exe'] },
+    { host: 'cursor', tokens: ['Cursor Helper', 'Cursor.exe'] },
+    { host: 'codium', tokens: ['VSCodium Helper', 'VSCodium.exe'] },
+    { host: 'windsurf', tokens: ['Windsurf Helper', 'Windsurf.exe'] },
     // Native terminal apps
     { host: 'iterm', tokens: ['iTerm2', 'iTermServer', 'iTerm'] },
-    { host: 'terminal', tokens: ['Terminal.app', '/Applications/Utilities/Terminal.app'] },
+    { host: 'terminal', tokens: ['Terminal.app', '/Applications/Utilities/Terminal.app', 'WindowsTerminal.exe'] },
     { host: 'warp', tokens: ['Warp.app', 'stable_'] },
     { host: 'alacritty', tokens: ['alacritty', 'Alacritty'] },
     { host: 'kitty', tokens: ['kitty'] },
@@ -379,6 +402,8 @@ const HOST_MATCHERS = [
  * matching against AGENT_CLI_NAMES.
  */
 async function readProcessTable() {
+    if (process.platform === 'win32')
+        return readProcessTableWin32();
     let out;
     try {
         ({ stdout: out } = await execFileAsync('ps', ['-A', '-o', 'pid=,ppid=,comm='], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 }));
@@ -396,8 +421,41 @@ async function readProcessTable() {
         if (!Number.isFinite(pid) || !Number.isFinite(ppid))
             continue;
         const commRaw = m[3].trim();
-        const kind = AGENT_CLI_NAMES[path.basename(commRaw)];
-        rows.push({ pid, ppid, comm: commRaw, kind });
+        rows.push({ pid, ppid, comm: commRaw, kind: agentKindFromComm(commRaw) });
+    }
+    return rows;
+}
+/**
+ * Windows process table in one CIM query (`wmic` is removed on current
+ * Windows 11, so PowerShell is the stable interface). Same pid/ppid/comm
+ * shape as the POSIX `ps` snapshot; `Name` is the image name (`claude.exe`).
+ */
+async function readProcessTableWin32() {
+    let out;
+    try {
+        ({ stdout: out } = await execFileAsync('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-Command',
+            'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name | ConvertTo-Csv -NoTypeInformation',
+        ], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, windowsHide: true }));
+    }
+    catch {
+        return [];
+    }
+    return parseWin32ProcessCsv(out);
+}
+/** Parse `ConvertTo-Csv` output of Win32_Process rows. Exported for tests. */
+export function parseWin32ProcessCsv(out) {
+    const rows = [];
+    for (const line of out.split(/\r?\n/)) {
+        const m = line.trim().match(/^"(\d+)","(\d+)","(.*)"$/);
+        if (!m)
+            continue;
+        const pid = parseInt(m[1], 10);
+        const ppid = parseInt(m[2], 10);
+        if (!Number.isFinite(pid) || !Number.isFinite(ppid))
+            continue;
+        const comm = m[3].replace(/""/g, '"');
+        rows.push({ pid, ppid, comm, kind: agentKindFromComm(comm) });
     }
     return rows;
 }
@@ -417,12 +475,25 @@ function hasAttributedAncestor(pid, ppidMap, attributed) {
     }
     return false;
 }
+/**
+ * Resolve every candidate PID's cwd, bounded and staggered so the probes no
+ * longer fan out as one simultaneous system-wide `lsof` burst (a behavioral-EDR
+ * recon trigger). Order matches the input `pids`. The `probe` seam is injectable
+ * for testing the bound; production always uses the real `lsof`-backed probe.
+ */
+export function resolveCwds(pids, probe = getCwdForPid) {
+    return mapBounded(pids, probe, { concurrency: LSOF_CONCURRENCY, staggerMs: LSOF_STAGGER_MS });
+}
 /**
  * Resolve a process's current working directory via `lsof`. The `-a` flag
  * ANDs the filters; without it macOS treats `-p` and `-d` as a union and
  * returns the cwd of every process on the system.
  */
 async function getCwdForPid(pid) {
+    // No lsof on Windows and no cheap foreign-process cwd API; the pid registry
+    // written by `ag run` supplies the cwd for registry-launched agents instead.
+    if (process.platform === 'win32')
+        return undefined;
     let out;
     try {
         const res = await execFileAsync('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], {
@@ -469,6 +540,99 @@ const UI_HOSTS = new Set([
     'iterm', 'terminal', 'warp', 'alacritty', 'kitty', 'hyper', 'wezterm', 'ghostty',
     'tmux', 'screen',
 ]);
+/**
+ * Find the launch registry entry recorded by a WRAPPER of this process. The
+ * shim delegate records the pid it spawned, but on Windows the `.cmd` shell
+ * path makes that a cmd.exe intermediary whose child is the real agent binary
+ * — so the agent pid itself has no entry and the wrapper one ancestor up does.
+ * The nearest entry wins, and only if its agent matches the candidate's kind:
+ * a claude session shelling out to codex must not hand codex its identity.
+ */
+export function readAncestorSessionEntry(pid, ppidMap, kind, readEntry = readPidSessionEntry) {
+    let cur = ppidMap.get(pid);
+    const seen = new Set();
+    while (cur && cur > 1 && !seen.has(cur)) {
+        const entry = readEntry(cur);
+        if (entry)
+            return entry.agent === kind ? entry : undefined;
+        seen.add(cur);
+        cur = ppidMap.get(cur);
+    }
+    return undefined;
+}
+/**
+ * Collapse agent processes spawned by another live agent process of the same
+ * kind onto their nearest kept ancestor. Claude runs subagents, forks, and
+ * even its bundled ripgrep as child `claude` processes — on POSIX those
+ * children resolve to the parent's cwd and collapse in dedupeBySession, but
+ * where no cwd can be recovered (Windows has no lsof) every fork would print
+ * as its own headless row. Two exceptions keep their own row: a candidate with
+ * its own registry entry — on its pid OR on a wrapper ancestor strictly below
+ * the pid it would fold into (the shim's entry lands on the cmd.exe
+ * intermediary on Windows) — and a child of a *different* agent kind (claude
+ * shelling out to codex is a real second session, not a fork).
+ * Returns the kept roots plus, per root pid, how many descendants folded in.
+ */
+export function foldSubordinateAgents(candidates, ppidMap, readEntry) {
+    const kindByPid = new Map(candidates.map(c => [c.pid, c.kind]));
+    const nearestSameKindAncestor = (pid, kind) => {
+        let cur = ppidMap.get(pid);
+        const seen = new Set();
+        while (cur && cur > 1 && !seen.has(cur)) {
+            if (kindByPid.get(cur) === kind)
+                return cur;
+            seen.add(cur);
+            cur = ppidMap.get(cur);
+        }
+        return undefined;
+    };
+    // Own launch identity: a matching-kind registry entry on the candidate or on
+    // any wrapper between it and the pid it would fold into (exclusive). Entries
+    // above the fold target belong to that ancestor's session, not this one.
+    const hasOwnSession = (c, stopPid) => {
+        if (readEntry(c.pid)?.agent === c.kind)
+            return true;
+        let cur = ppidMap.get(c.pid);
+        const seen = new Set();
+        while (cur && cur > 1 && cur !== stopPid && !seen.has(cur)) {
+            if (readEntry(cur)?.agent === c.kind)
+                return true;
+            seen.add(cur);
+            cur = ppidMap.get(cur);
+        }
+        return false;
+    };
+    const keptPids = new Set();
+    for (const c of candidates) {
+        const foldTarget = nearestSameKindAncestor(c.pid, c.kind);
+        if (foldTarget === undefined || hasOwnSession(c, foldTarget)) {
+            keptPids.add(c.pid);
+        }
+    }
+    const kept = [];
+    const foldedByRoot = new Map();
+    for (const c of candidates) {
+        if (keptPids.has(c.pid)) {
+            kept.push(c);
+            continue;
+        }
+        // Walk up through folded intermediates to the nearest kept same-kind pid.
+        let cur = nearestSameKindAncestor(c.pid, c.kind);
+        const seen = new Set();
+        while (cur !== undefined && !keptPids.has(cur) && !seen.has(cur)) {
+            seen.add(cur);
+            cur = nearestSameKindAncestor(cur, c.kind);
+        }
+        // A fold target must itself be a kept row (a ppid cycle from pid reuse
+        // can orphan the whole chain) — otherwise keep the row rather than drop it.
+        if (cur === undefined || !keptPids.has(cur)) {
+            kept.push(c);
+            continue;
+        }
+        foldedByRoot.set(cur, (foldedByRoot.get(cur) ?? 0) + 1);
+    }
+    return { kept, foldedByRoot };
+}
 /**
  * Agent processes not attributed to a team or the runtime registry.
  * Classified by walking the ppid chain: any recognised UI ancestor (IDE
@@ -494,13 +658,24 @@ export async function listUnattributedActive(attributed) {
             continue;
         candidates.push({ pid, kind });
     }
-    // Run lsof probes in parallel so N spawns take one round-trip, not N.
-    const cwds = await Promise.all(candidates.map(c => getCwdForPid(c.pid)));
+    // Forks/subagents of a live agent process collapse onto their root before
+    // the cwd probes — fewer spawns, and one session stays one row even when
+    // cwd-based dedupe is unavailable (Windows).
+    const { kept, foldedByRoot } = foldSubordinateAgents(candidates, ppidMap, readPidSessionEntry);
+    // Bounded + staggered lsof probes: same cwds, but a trickle of spawns instead
+    // of one simultaneous system-wide burst that behavioral EDR flags as recon.
+    const cwds = await resolveCwds(kept.map(c => c.pid));
     const out = [];
-    for (let i = 0; i < candidates.length; i++) {
-        const { pid, kind } = candidates[i];
-        const cwd = cwds[i];
-        const sessionFile = findSessionFileForKind(kind, cwd);
+    for (let i = 0; i < kept.length; i++) {
+        const { pid, kind } = kept[i];
+        // The per-pid registry (written by `ag run` and the shim delegate) gives
+        // the EXACT session id this pid was launched with — so N agents in one cwd
+        // resolve to N distinct sessions instead of all collapsing onto the newest
+        // .jsonl. The shim's entry may sit on a wrapper ancestor (Windows .cmd
+        // path). Absent entirely (direct launch outside agents-cli) → heuristic.
+        const entry = readPidSessionEntry(pid) ?? readAncestorSessionEntry(pid, ppidMap, kind);
+        const cwd = cwds[i] ?? entry?.cwd ?? undefined;
+        const sessionFile = findSessionFileForKind(kind, cwd, entry?.sessionId);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
@@ -511,11 +686,14 @@ export async function listUnattributedActive(attributed) {
             host,
             pid,
             cwd,
-            sessionId: sessionIdFromFile(sessionFile),
+            sessionId: entry?.sessionId ?? sessionIdFromFile(sessionFile),
             topic,
             sessionFile,
+            pidCount: 1 + (foldedByRoot.get(pid) ?? 0),
         }, state, sessionFile));
     }
+    // Housekeeping: drop registry files for pids that have since died.
+    prunePidSessionRegistry(isPidAlive);
     return out;
 }
 /**
@@ -573,10 +751,11 @@ function dedupeBySession(sessions) {
         }
         const existing = byKey.get(key);
         if (existing) {
-            existing.pidCount = (existing.pidCount ?? 1) + 1;
+            // Carry pre-folded fork counts (headless rows arrive with pidCount set).
+            existing.pidCount = (existing.pidCount ?? 1) + (s.pidCount ?? 1);
         }
         else {
-            s.pidCount = 1;
+            s.pidCount = s.pidCount ?? 1;
             byKey.set(key, s);
             out.push(s);
         }

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

@@ -74,6 +74,22 @@ interface ClaudeSessionScan {
  * TTL, no external lock files needed.
  */
 export declare function discoverSessions(options?: DiscoverOptions): Promise<SessionMeta[]>;
+/**
+ * How many agents' dotfile dirs we scan at once, and the minimum spacing between
+ * successive scan starts. A small bound + stagger turns a simultaneous bulk
+ * multi-dotfile sweep (a behavioral-EDR file-enumeration trigger) into a trickle.
+ */
+export declare const DOTFILE_SCAN_CONCURRENCY = 2;
+/** Run each agent's incremental scan, bounded + staggered. Order is irrelevant (each scan writes its own rows). */
+export declare function scanAgentsBounded<T>(items: readonly T[], run: (item: T) => Promise<void>): Promise<void[]>;
+/**
+ * The machine a discovered session originated on. Cross-machine sync mirrors a
+ * remote transcript to backups/<agent>/<machine>/<subdir>/… (see mirrorPath in
+ * sync/agents.ts); every other transcript is a live-home file on this box. So:
+ * when the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export declare function machineForSessionFile(filePath: string, agent: string): string;
 /**
  * Count sessions in scope without running an incremental scan. Assumes the DB
  * is already fresh (typically true because `discoverSessions` ran first this
@@ -105,8 +121,29 @@ export declare function getAgentSessionDirs(agent: string, subdir: string): stri
  * recent startedAt.
  */
 export declare function buildClaudeLabelMap(): Map<string, string | null>;
+/**
+ * Base64url-decode a JWT and return its `email` claim, if present. Split out so
+ * the decode is a single, testable step — and so it only runs when someone
+ * actually reads the Codex account (see the lazy resolution below).
+ */
+export declare function decodeJwtEmail(idToken: string): string | undefined;
+/** Test seam: how many times getCodexAccount has actually resolved (decoded) since the last reset. */
+export declare function __codexAccountResolveCountForTest(): number;
+/** Test seam: clear the memoized account + resolve counter so laziness can be observed from a clean slate. */
+export declare function __resetCodexAccountCacheForTest(): void;
 /** Parse the lines of a Codex `session_index.jsonl` into a session id -> title map. */
 export declare function parseCodexThreadNameIndex(raw: string): Map<string, string>;
+/**
+ * Stream-parse a single Codex JSONL file to extract session metadata.
+ *
+ * `resolveAccount` is a lazy thunk (not a resolved string): the JWT decode it
+ * performs is deferred until we know this file is a real session worth building
+ * metadata for, and only then — never during the file walk / stat phase.
+ */
+export declare function readCodexMeta(filePath: string, resolveAccount?: () => string | undefined, currentVersion?: string): Promise<{
+    meta: SessionMeta;
+    content: string;
+} | null>;
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
 export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessionScan>;
 /** Read up to maxLines non-empty lines from the beginning of a file. */

package/dist/lib/session/discover.js

@@ -20,8 +20,11 @@ import { walkForFiles } from '../fs-walk.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { extractSessionTopic } from './prompt.js';
+import { parseAntigravity } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
+import { machineId } from './sync/config.js';
+import { mapBounded } from '../concurrency.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
 const HOME = os.homedir();
 // Versions can live under either repo: the user repo (current canonical
@@ -55,27 +58,68 @@ export async function discoverSessions(options) {
     const onProgress = options?.onProgress;
     if (tryClaimScan(process.pid)) {
         try {
-            await Promise.all(agents.map(agent => {
-                switch (agent) {
-                    case 'claude': return scanClaudeIncremental(onProgress);
-                    case 'codex': return scanCodexIncremental(onProgress);
-                    case 'gemini': return scanGeminiIncremental(onProgress);
-                    case 'opencode': return scanOpenCodeIncremental();
-                    case 'openclaw': return scanOpenClawIncremental();
-                    case 'rush': return scanRushIncremental(onProgress);
-                    case 'hermes': return scanHermesIncremental(onProgress);
-                    case 'kimi': return scanKimiIncremental(onProgress);
-                    case 'droid': return scanDroidIncremental(onProgress);
-                }
-            }));
+            // Bounded + staggered instead of a single Promise.all: scanning every
+            // agent's dotfile dir (~/.claude, ~/.codex, ~/.gemini, …) simultaneously
+            // reads to behavioral EDR (CrowdStrike Falcon) as a ransomware-style bulk
+            // file-enumeration sweep. Same dirs, same results — just not all at once.
+            await scanAgentsBounded(agents, agent => dispatchAgentScan(agent, onProgress));
         }
         finally {
             releaseScan(process.pid);
         }
     }
     const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
+    for (const s of sessions)
+        s.machine = machineForSessionFile(s.filePath, s.agent);
     return sessions;
 }
+/**
+ * How many agents' dotfile dirs we scan at once, and the minimum spacing between
+ * successive scan starts. A small bound + stagger turns a simultaneous bulk
+ * multi-dotfile sweep (a behavioral-EDR file-enumeration trigger) into a trickle.
+ */
+export const DOTFILE_SCAN_CONCURRENCY = 2;
+const DOTFILE_SCAN_STAGGER_MS = 15;
+/** Run each agent's incremental scan, bounded + staggered. Order is irrelevant (each scan writes its own rows). */
+export function scanAgentsBounded(items, run) {
+    return mapBounded(items, run, {
+        concurrency: DOTFILE_SCAN_CONCURRENCY,
+        staggerMs: DOTFILE_SCAN_STAGGER_MS,
+    });
+}
+/** Dispatch a single agent's incremental dotfile scan. */
+function dispatchAgentScan(agent, onProgress) {
+    switch (agent) {
+        case 'claude': return scanClaudeIncremental(onProgress);
+        case 'codex': return scanCodexIncremental(onProgress);
+        case 'gemini': return scanGeminiIncremental(onProgress);
+        case 'antigravity': return scanAntigravityIncremental(onProgress);
+        case 'opencode': return scanOpenCodeIncremental();
+        case 'openclaw': return scanOpenClawIncremental();
+        case 'rush': return scanRushIncremental(onProgress);
+        case 'hermes': return scanHermesIncremental(onProgress);
+        case 'kimi': return scanKimiIncremental(onProgress);
+        case 'droid': return scanDroidIncremental(onProgress);
+        default: return Promise.resolve();
+    }
+}
+let _localMachineId;
+/**
+ * The machine a discovered session originated on. Cross-machine sync mirrors a
+ * remote transcript to backups/<agent>/<machine>/<subdir>/… (see mirrorPath in
+ * sync/agents.ts); every other transcript is a live-home file on this box. So:
+ * when the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export function machineForSessionFile(filePath, agent) {
+    const base = path.join(getHistoryDir(), 'backups', agent) + path.sep;
+    if (filePath.startsWith(base)) {
+        const seg = filePath.slice(base.length).split(path.sep)[0];
+        if (seg)
+            return seg;
+    }
+    return (_localMachineId ??= machineId());
+}
 /**
  * Count sessions in scope without running an incremental scan. Assumes the DB
  * is already fresh (typically true because `discoverSessions` ran first this
@@ -462,10 +506,37 @@ async function readClaudeMeta(filePath, sessionId, account, label) {
 // Codex account info
 // ---------------------------------------------------------------------------
 let cachedCodexAccount;
-/** Extract the Codex account email from the JWT id_token in auth.json. */
+/** Number of times the auth.json JWT was actually base64-decoded. Test seam for the lazy-decode contract. */
+let codexAccountResolveCount = 0;
+/**
+ * Base64url-decode a JWT and return its `email` claim, if present. Split out so
+ * the decode is a single, testable step — and so it only runs when someone
+ * actually reads the Codex account (see the lazy resolution below).
+ */
+export function decodeJwtEmail(idToken) {
+    const parts = idToken.split('.');
+    if (parts.length < 2)
+        return undefined;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        return typeof payload.email === 'string' ? payload.email : undefined;
+    }
+    catch {
+        return undefined; // malformed JWT
+    }
+}
+/**
+ * Extract the Codex account email from the JWT id_token in auth.json.
+ *
+ * Memoized and resolved LAZILY: the credential-harvesting-shaped JWT decode
+ * (base64-decoding ~/.codex/auth.json) only runs when the account is actually
+ * needed to build a session's metadata — never eagerly during the bulk scan.
+ * A scan with no changed Codex files never touches the auth file.
+ */
 function getCodexAccount() {
     if (cachedCodexAccount !== undefined)
         return cachedCodexAccount || undefined;
+    codexAccountResolveCount++;
     const candidates = [path.join(HOME, '.codex', 'auth.json')];
     for (const root of VERSIONS_ROOTS) {
         const versionsBase = path.join(root, 'versions', 'codex');
@@ -485,27 +556,35 @@ function getCodexAccount() {
             const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
             const idToken = data.tokens?.id_token;
             if (idToken) {
-                const parts = idToken.split('.');
-                if (parts.length >= 2) {
-                    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
-                    if (payload.email) {
-                        cachedCodexAccount = payload.email;
-                        return payload.email;
-                    }
+                const email = decodeJwtEmail(idToken);
+                if (email) {
+                    cachedCodexAccount = email;
+                    return email;
                 }
             }
         }
-        catch { /* auth file or JWT malformed */ }
+        catch { /* auth file malformed */ }
     }
     cachedCodexAccount = '';
     return undefined;
 }
+/** Test seam: how many times getCodexAccount has actually resolved (decoded) since the last reset. */
+export function __codexAccountResolveCountForTest() {
+    return codexAccountResolveCount;
+}
+/** Test seam: clear the memoized account + resolve counter so laziness can be observed from a clean slate. */
+export function __resetCodexAccountCacheForTest() {
+    cachedCodexAccount = undefined;
+    codexAccountResolveCount = 0;
+}
 // ---------------------------------------------------------------------------
 // Codex
 // ---------------------------------------------------------------------------
 /** Incrementally re-scan changed Codex session files and upsert into the DB. */
 async function scanCodexIncremental(onProgress) {
-    const account = getCodexAccount();
+    // Lazy: getCodexAccount (the auth.json JWT decode) is only resolved by
+    // readCodexMeta when a changed session actually needs it — never eagerly here,
+    // so a no-op scan (changed.length === 0) never touches the credential file.
     const currentVersion = await getCurrentAgentVersion('codex');
     const filePaths = [];
     for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
@@ -530,7 +609,7 @@ async function scanCodexIncremental(onProgress) {
     let parsed = 0;
     for (const { filePath, scan } of changed) {
         try {
-            const result = await readCodexMeta(filePath, account, currentVersion);
+            const result = await readCodexMeta(filePath, getCodexAccount, currentVersion);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
                 // Prefer the Codex-generated title over the first-prompt fallback.
@@ -594,8 +673,14 @@ function readCodexThreadNames() {
     }
     return titles;
 }
-/** Stream-parse a single Codex JSONL file to extract session metadata. */
-async function readCodexMeta(filePath, account, currentVersion) {
+/**
+ * Stream-parse a single Codex JSONL file to extract session metadata.
+ *
+ * `resolveAccount` is a lazy thunk (not a resolved string): the JWT decode it
+ * performs is deferred until we know this file is a real session worth building
+ * metadata for, and only then — never during the file walk / stat phase.
+ */
+export async function readCodexMeta(filePath, resolveAccount, currentVersion) {
     const scan = await scanCodexSession(filePath);
     const sessionId = scan.sessionId || '';
     if (!sessionId)
@@ -618,7 +703,7 @@ async function readCodexMeta(filePath, account, currentVersion) {
         tokenCount: scan.tokenCount,
         costUsd: scan.costUsd,
         durationMs: scan.durationMs,
-        account,
+        account: resolveAccount?.(),
         prUrl: scan.prUrl,
         prNumber: scan.prNumber,
         worktreeSlug: scan.worktreeSlug,
@@ -864,6 +949,98 @@ function buildGeminiProjectMap() {
     return map;
 }
 // ---------------------------------------------------------------------------
+// Antigravity
+//
+// Antigravity stores one SQLite DB per conversation at
+// ~/.gemini/antigravity-cli/conversations/<trajectory-uuid>.db. The filename
+// (minus .db) is the canonical session id. Each DB is stat'd against the ledger;
+// only changed DBs are re-parsed (via parseAntigravity, which shells out to
+// sqlite3). Tool count doubles as the message count; the toolSummary of the
+// first tool call becomes the topic, and any run_command's Cwd fills in cwd.
+// ---------------------------------------------------------------------------
+/** Incrementally re-scan changed Antigravity conversation DBs and upsert into the DB. */
+async function scanAntigravityIncremental(onProgress) {
+    const currentVersion = await getCurrentAgentVersion('antigravity');
+    const filePaths = [];
+    const seenPaths = new Set();
+    for (const conversationsDir of getAgentSessionDirs('antigravity', 'conversations')) {
+        let files;
+        try {
+            files = fs.readdirSync(conversationsDir).filter(f => f.endsWith('.db'));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const fp = path.join(conversationsDir, file);
+            if (seenPaths.has(fp))
+                continue;
+            seenPaths.add(fp);
+            filePaths.push(fp);
+        }
+    }
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'antigravity', parsed: 0, total: changed.length });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = readAntigravityMeta(filePath, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'antigravity', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(entries);
+    recordScans(touched);
+}
+/** Parse a single Antigravity conversation DB to extract session metadata. */
+function readAntigravityMeta(filePath, currentVersion) {
+    const sessionId = path.basename(filePath).replace(/\.db$/, '');
+    if (!sessionId)
+        return null;
+    const events = parseAntigravity(filePath);
+    // cwd: first run_command carries the working directory in its Cwd arg.
+    let cwd;
+    const contentParts = [];
+    for (const e of events) {
+        if (!cwd && typeof e.args?.Cwd === 'string' && e.args.Cwd)
+            cwd = e.args.Cwd;
+        if (e.content)
+            contentParts.push(e.content);
+    }
+    const normalizedCwd = cwd ? normalizeCwd(cwd) : undefined;
+    // Topic: the first tool's human summary is a decent one-line label.
+    const topic = events.find(e => e.content)?.content;
+    const stat = safeStatSync(filePath);
+    const meta = {
+        id: sessionId,
+        shortId: sessionId.slice(0, 8),
+        agent: 'antigravity',
+        timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
+        project: normalizedCwd ? path.basename(normalizedCwd) : undefined,
+        cwd: normalizedCwd,
+        filePath,
+        version: resolveSessionVersion('antigravity', filePath, undefined, currentVersion),
+        topic: topic ? topic.slice(0, 120) : undefined,
+        messageCount: events.length,
+    };
+    return { meta, content: contentParts.join('\n') };
+}
+// ---------------------------------------------------------------------------
 // OpenCode
 // ---------------------------------------------------------------------------
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');