@phnx-labs/agents-cli 1.20.34 → 1.20.35

package/dist/lib/session/discover.js

@@ -20,6 +20,7 @@ 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 { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
@@ -60,6 +61,7 @@ export async function discoverSessions(options) {
                     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);
@@ -864,6 +866,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');

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

@@ -50,6 +50,12 @@ export declare function parseCodex(filePath: string): SessionEvent[];
 export declare function parseCodexContent(content: string): SessionEvent[];
 /** Parse a Gemini JSON session file into normalized events. */
 export declare function parseGemini(filePath: string): SessionEvent[];
+/**
+ * Parse an Antigravity conversation SQLite DB into normalized tool_use events.
+ * Deduped by the tool-call id so each tool appears once (Antigravity writes a
+ * request step and a completion step that share the id).
+ */
+export declare function parseAntigravity(dbPath: string): SessionEvent[];
 /**
  * Parse an OpenCode session from its SQLite database.
  * filePath format: "/path/to/opencode.db#session_id"

package/dist/lib/session/parse.js

@@ -96,6 +96,9 @@ export function parseSession(filePath, agent) {
         case 'gemini':
             events = parseGemini(filePath);
             break;
+        case 'antigravity':
+            events = parseAntigravity(filePath);
+            break;
         case 'opencode':
             events = parseOpenCode(filePath);
             break;
@@ -131,6 +134,12 @@ export function detectAgent(filePath) {
         return 'claude';
     if (filePath.includes('/.codex/') || filePath.includes('\\.codex\\'))
         return 'codex';
+    // Antigravity lives under ~/.gemini/antigravity-cli/conversations/<uuid>.db, so
+    // it must be matched BEFORE the generic /.gemini/ check below or it would be
+    // misdetected as Gemini.
+    if ((filePath.includes('/antigravity-cli/conversations/') || filePath.includes('\\antigravity-cli\\conversations\\'))
+        && filePath.endsWith('.db'))
+        return 'antigravity';
     if (filePath.includes('/.gemini/') || filePath.includes('\\.gemini\\'))
         return 'gemini';
     if (filePath.includes('/.grok/') || filePath.includes('\\.grok\\'))
@@ -178,6 +187,11 @@ export function summarizeToolUse(tool, args) {
         case 'WebSearch':
         case 'WebFetch':
             return `${tool}: ${truncate(args.query || args.url || '', 80)}`;
+        // Codex plan tool: arrives as a function_call with {plan:[{step,status}]}.
+        case 'update_plan': {
+            const steps = Array.isArray(args.plan) ? args.plan.length : 0;
+            return `Plan: ${steps} step${steps === 1 ? '' : 's'}`;
+        }
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;
@@ -418,6 +432,16 @@ export function parseClaudeContent(content) {
 export function parseCodex(filePath) {
     return parseCodexContent(safeReadSessionFile(filePath));
 }
+/**
+ * Extract the target file path from a Codex apply_patch envelope. The patch body
+ * opens with `*** Begin Patch` and carries one or more file ops of the form
+ * `*** Update File: <path>` / `*** Add File: <path>` / `*** Delete File: <path>`.
+ * Returns the first file path found, or undefined for an unparseable body.
+ */
+function applyPatchTargetPath(input) {
+    const m = input.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m);
+    return m ? m[1].trim() : undefined;
+}
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -449,6 +473,23 @@ export function parseCodexContent(content) {
             });
             continue;
         }
+        if (lineType === 'event_msg') {
+            // Web search is reported out-of-band as event_msg (not response_item).
+            // The paired begin (`web_search_call`) has no query; only `web_search_end`
+            // carries the resolved query string, so we emit exactly one tool_use per
+            // search off the end event and ignore the begin to avoid duplicates.
+            if (payload.type === 'web_search_end') {
+                const query = typeof payload.query === 'string' ? payload.query : '';
+                events.push({
+                    type: 'tool_use',
+                    agent: 'codex',
+                    timestamp,
+                    tool: 'WebSearch',
+                    args: { query },
+                });
+            }
+            continue;
+        }
         if (lineType === 'response_item') {
             const ptype = payload.type;
             if (ptype === 'message') {
@@ -523,6 +564,45 @@ export function parseCodexContent(content) {
                 if (callId)
                     callMap.delete(callId);
             }
+            else if (ptype === 'custom_tool_call') {
+                // Codex edits arrive as custom_tool_call (apply_patch), NOT function_call.
+                const rawName = payload.name || 'unknown';
+                const input = typeof payload.input === 'string' ? payload.input : '';
+                const isApplyPatch = rawName === 'apply_patch';
+                const patchPath = isApplyPatch ? applyPatchTargetPath(input) : undefined;
+                // Normalize apply_patch to the shared Edit tool so it flows through
+                // artifact discovery (WRITE_TOOLS) and the Edit summarizer.
+                const tool = isApplyPatch ? 'Edit' : rawName;
+                const args = { input: input.length > 500 ? input.slice(0, 497) + '...' : input };
+                if (patchPath)
+                    args.file_path = patchPath;
+                const callId = payload.call_id || payload.id;
+                if (callId)
+                    callMap.set(callId, { name: tool, args });
+                events.push({
+                    type: 'tool_use',
+                    agent: 'codex',
+                    timestamp,
+                    tool,
+                    args,
+                    path: patchPath,
+                });
+            }
+            else if (ptype === 'custom_tool_call_output') {
+                const callId = payload.call_id || payload.id;
+                const callInfo = callId ? callMap.get(callId) : undefined;
+                const output = String(payload.output || '');
+                events.push({
+                    type: 'tool_result',
+                    agent: 'codex',
+                    timestamp,
+                    tool: callInfo?.name,
+                    success: true,
+                    output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                });
+                if (callId)
+                    callMap.delete(callId);
+            }
             else if (ptype === 'reasoning') {
                 // Codex reasoning -- try to get the readable summary
                 const summaries = payload.summary || [];
@@ -670,6 +750,204 @@ function extractGeminiContent(content) {
     }
     return '';
 }
+/** Read a base-128 varint from `b` at offset `i`; returns [value, nextOffset]. */
+function readVarint(b, i) {
+    let shift = 0;
+    let val = 0;
+    for (;;) {
+        const byte = b[i++];
+        val += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) === 0)
+            break;
+        shift += 7;
+    }
+    return [val, i];
+}
+/** Decode a protobuf message into a flat list of fields (one nesting level). */
+function decodeProtoMessage(b) {
+    const out = [];
+    let i = 0;
+    while (i < b.length) {
+        let tag;
+        [tag, i] = readVarint(b, i);
+        const field = tag >>> 3;
+        const wire = tag & 7;
+        if (wire === 0) {
+            let v;
+            [v, i] = readVarint(b, i);
+            out.push({ field, wire, value: v });
+        }
+        else if (wire === 2) {
+            let len;
+            [len, i] = readVarint(b, i);
+            out.push({ field, wire, value: b.subarray(i, i + len) });
+            i += len;
+        }
+        else if (wire === 5) {
+            i += 4; // fixed32 — skipped
+            out.push({ field, wire, value: 0 });
+        }
+        else if (wire === 1) {
+            i += 8; // fixed64 — skipped
+            out.push({ field, wire, value: 0 });
+        }
+        else {
+            break; // unknown wire type — stop to avoid runaway reads
+        }
+    }
+    return out;
+}
+const ANTIGRAVITY_TEXT_DECODER = new TextDecoder('utf-8', { fatal: false });
+/**
+ * Recursively locate the tool-call node: the first sub-message that carries an
+ * f2 string tool-name AND an f3 JSON-args string. Also captures the f1 call id
+ * (used to dedupe the request + completion steps) and the f30/f31 human labels.
+ */
+function findAntigravityToolCall(fields) {
+    let id;
+    let name;
+    let argsJson;
+    let summary;
+    let action;
+    const subs = [];
+    for (const f of fields) {
+        if (f.wire !== 2)
+            continue;
+        const bytes = f.value;
+        const s = ANTIGRAVITY_TEXT_DECODER.decode(bytes);
+        if (f.field === 1 && !id && /^[a-z0-9]{4,16}$/.test(s))
+            id = s;
+        else if (f.field === 2 && !name && /^[a-z][a-z_]{2,30}$/.test(s))
+            name = s;
+        else if (f.field === 3 && !argsJson && s.startsWith('{') && s.includes('"toolAction"'))
+            argsJson = s;
+        else if (f.field === 30 && !summary)
+            summary = s;
+        else if (f.field === 31 && !action)
+            action = s;
+        else {
+            try {
+                subs.push(decodeProtoMessage(bytes));
+            }
+            catch {
+                /* not a nested message */
+            }
+        }
+    }
+    if (name && argsJson) {
+        let args = {};
+        try {
+            args = JSON.parse(argsJson);
+        }
+        catch {
+            args = { _raw: argsJson };
+        }
+        return { id, name, args, summary, action };
+    }
+    for (const sub of subs) {
+        const hit = findAntigravityToolCall(sub);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * Map an Antigravity tool name onto the shared normalized vocabulary that the
+ * renderer already handles (so no render.ts changes are needed). Unknown tools
+ * pass through untouched (with their JSON args) so future tools are captured.
+ */
+const ANTIGRAVITY_TOOL_MAP = {
+    run_command: 'Bash',
+    view_file: 'Read',
+    read_file: 'Read',
+    list_dir: 'LS',
+    grep_search: 'Grep',
+    replace_file_content: 'Edit',
+    write_to_file: 'Write',
+    // Web tools surface identically once observed:
+    search_web: 'WebSearch',
+    read_url: 'WebFetch',
+    execute_url: 'WebFetch',
+};
+/**
+ * Parse an Antigravity conversation SQLite DB into normalized tool_use events.
+ * Deduped by the tool-call id so each tool appears once (Antigravity writes a
+ * request step and a completion step that share the id).
+ */
+export function parseAntigravity(dbPath) {
+    let rows;
+    try {
+        rows = execFileSync('sqlite3', ['-separator', '\t', dbPath, 'SELECT idx, step_type, quote(step_payload) FROM steps ORDER BY idx;'], {
+            encoding: 'utf-8',
+            timeout: 10000,
+            maxBuffer: 64 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        /* DB not accessible, sqlite3 missing, or query failed */
+        return [];
+    }
+    // Single timestamp for the whole session: the steps table carries no per-step
+    // time column, so fall back to the DB file's mtime for a stable, sortable value.
+    let timestamp = new Date().toISOString();
+    try {
+        timestamp = fs.statSync(dbPath).mtime.toISOString();
+    }
+    catch {
+        /* file vanished between query and stat — keep now() */
+    }
+    const events = [];
+    const seenCallIds = new Set();
+    for (const line of rows.split('\n')) {
+        if (!line.trim())
+            continue;
+        const tab1 = line.indexOf('\t');
+        if (tab1 === -1)
+            continue;
+        const tab2 = line.indexOf('\t', tab1 + 1);
+        if (tab2 === -1)
+            continue;
+        const hex = line.slice(tab2 + 1).trim();
+        // sqlite3 quote() renders a BLOB as X'...'; anything else (NULL) is skipped.
+        if (!hex.startsWith("X'") || !hex.endsWith("'"))
+            continue;
+        const bytes = Uint8Array.from(Buffer.from(hex.slice(2, -1), 'hex'));
+        let fields;
+        try {
+            fields = decodeProtoMessage(bytes);
+        }
+        catch {
+            continue;
+        }
+        const call = findAntigravityToolCall(fields);
+        if (!call)
+            continue;
+        // Dedupe: the request + completion steps of one tool share the f1 call id.
+        if (call.id) {
+            if (seenCallIds.has(call.id))
+                continue;
+            seenCallIds.add(call.id);
+        }
+        const norm = ANTIGRAVITY_TOOL_MAP[call.name] || call.name;
+        const a = call.args || {};
+        events.push({
+            type: 'tool_use',
+            agent: 'antigravity',
+            timestamp,
+            tool: norm,
+            args: a,
+            command: norm === 'Bash' ? a.CommandLine : undefined,
+            // Antigravity uses PascalCase arg keys; probe the known path-bearing ones.
+            path: a.AbsolutePath || a.TargetFile || a.DirectoryPath || a.SearchPath || undefined,
+            // Antigravity's own short human label — free, high quality. It surfaces
+            // either as the f30 string or (more reliably) as `toolSummary` inside the
+            // f3 JSON args.
+            content: call.summary || (typeof a.toolSummary === 'string' ? a.toolSummary : undefined) || undefined,
+        });
+    }
+    return events;
+}
 // ---------------------------------------------------------------------------
 // OpenCode parser
 // ---------------------------------------------------------------------------
@@ -1086,7 +1364,10 @@ export function parseKimi(filePath) {
                 const fn = event.function || {};
                 const toolName = typeof event.name === 'string' ? event.name : (fn.name || 'unknown');
                 let args = {};
-                if (typeof fn.arguments === 'string') {
+                if (event.args && typeof event.args === 'object') {
+                    args = event.args;
+                }
+                else if (typeof fn.arguments === 'string') {
                     try {
                         args = JSON.parse(fn.arguments);
                     }
@@ -1212,7 +1493,7 @@ export function parseDroid(filePath) {
                     tool: toolName,
                     args: toolInput,
                     path: toolInput.file_path || toolInput.path || undefined,
-                    command: toolName === 'Bash' ? toolInput.command : undefined,
+                    command: (toolName === 'Bash' || toolName === 'Execute') ? toolInput.command : undefined,
                 });
             }
             else if (block.type === 'tool_result') {

package/dist/lib/session/pid-registry.d.ts

@@ -0,0 +1,21 @@
+export interface PidSessionEntry {
+    pid: number;
+    agent: string;
+    /** The launch session id. Present for agents launched with a known id (Claude). */
+    sessionId?: string;
+    cwd?: string;
+    /**
+     * `$TMUX_PANE` at launch — stored for diagnostics and possible future
+     * disambiguation. NOT currently consulted on read: the listing path keys
+     * purely on pid (stale entries are pruned when the pid dies), so this is
+     * metadata, not an anti-collision key.
+     */
+    tmuxPane?: string;
+    startedAtMs: number;
+}
+/** Record a launched agent process. Never throws — the registry is an optimization. */
+export declare function writePidSessionEntry(entry: PidSessionEntry): void;
+/** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
+export declare function readPidSessionEntry(pid: number): PidSessionEntry | undefined;
+/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
+export declare function prunePidSessionRegistry(isAlive: (pid: number) => boolean): void;

package/dist/lib/session/pid-registry.js

@@ -0,0 +1,80 @@
+/**
+ * Per-PID session registry — the headless equivalent of the swarmify VS Code
+ * extension's `live-terminals.json`.
+ *
+ * On a machine with no terminal extension (a bare SSH/tmux host), the only way
+ * `ag sessions --active` can attribute a `ps`-discovered agent process to a
+ * session is to guess "newest .jsonl in the cwd" — which collapses N agents
+ * sharing one repo onto a single session (all rows show the same topic/id).
+ *
+ * `ag run` closes that gap by recording, at spawn time, one file per launched
+ * agent process keyed by its OS pid: the exact session id it was launched with
+ * (Claude is started with `--session-id <uuid>`, so the launcher knows it),
+ * plus agent/cwd/tmux pane. The active-sessions headless path reads it back for
+ * an exact pid -> session match instead of a heuristic.
+ *
+ * Best-effort throughout: a failed write or a corrupt file degrades to the old
+ * heuristic, never throws into the launch or the listing path.
+ */
+import fs from 'fs';
+import path from 'path';
+import { getTerminalsDir } from '../state.js';
+function pidRegistryDir() {
+    return path.join(getTerminalsDir(), 'by-pid');
+}
+function entryPath(pid) {
+    return path.join(pidRegistryDir(), `${pid}.json`);
+}
+/** Record a launched agent process. Never throws — the registry is an optimization. */
+export function writePidSessionEntry(entry) {
+    if (!entry.pid || entry.pid < 1)
+        return;
+    try {
+        fs.mkdirSync(pidRegistryDir(), { recursive: true });
+        fs.writeFileSync(entryPath(entry.pid), JSON.stringify(entry), 'utf8');
+    }
+    catch {
+        /* degrade to the newest-jsonl heuristic */
+    }
+}
+/** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
+export function readPidSessionEntry(pid) {
+    let raw;
+    try {
+        raw = fs.readFileSync(entryPath(pid), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && typeof parsed.pid === 'number') {
+            return parsed;
+        }
+    }
+    catch {
+        /* unparseable */
+    }
+    return undefined;
+}
+/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
+export function prunePidSessionRegistry(isAlive) {
+    let files;
+    try {
+        files = fs.readdirSync(pidRegistryDir()).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return;
+    }
+    for (const f of files) {
+        const pid = Number(f.slice(0, -'.json'.length));
+        if (!Number.isInteger(pid) || isAlive(pid))
+            continue;
+        try {
+            fs.unlinkSync(path.join(pidRegistryDir(), f));
+        }
+        catch {
+            /* raced with another writer/pruner */
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { ActiveSession } from './active.js';
+/**
+ * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
+ * `agents` that predates this feature ignores it harmlessly instead of erroring
+ * on an unknown option. A remote new enough to fan out reads it and stays local.
+ */
+export declare const NO_FANOUT_ENV = "AGENTS_SESSIONS_LOCAL";
+/**
+ * Parse a peer's `--active --json` stdout into active sessions, tagging each
+ * with `machine`. Defensive against version skew / partial output: non-JSON or
+ * a non-array yields `[]`, and non-object entries are dropped rather than
+ * throwing. Exported for unit testing without a live tailnet.
+ */
+export declare function parseRemoteActive(stdout: string, machine: string): ActiveSession[];
+export interface RemoteActiveResult {
+    sessions: ActiveSession[];
+    /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
+    deviceCount: number;
+}
+/**
+ * Gather active sessions from other machines. With an explicit `hosts` list
+ * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
+ * online devices from `ag devices`, excluding this machine and any without an
+ * address. Results from all peers run in parallel and are flattened.
+ */
+export declare function gatherRemoteActive(hosts?: string[]): Promise<RemoteActiveResult>;