@phnx-labs/agents-cli 1.22.117 → 1.22.119

package/dist/lib/session/parse.js

@@ -142,7 +142,6 @@ function truncateNormalizedToolOutput(output, maxChars) {
 const TRANSCRIPT_PARSERS = {
     claude: (filePath, opts) => parseClaude(filePath, opts),
     codex: (filePath) => parseCodex(filePath),
-    gemini: (filePath) => parseGemini(filePath),
     antigravity: (filePath) => parseAntigravity(filePath),
     // Cloud-captured opencode sessions are normalized JSONL (produced by the
     // factory at capture time), NOT the local `opencode.db#<session>` SQLite
@@ -183,14 +182,10 @@ 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.
+    // Antigravity lives under ~/.gemini/antigravity-cli/conversations/<uuid>.db.
     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\\'))
         return 'grok';
     if (filePath.includes('/.rush/') || filePath.includes('\\.rush\\'))
@@ -216,9 +211,6 @@ export function detectAgent(filePath) {
         return cloudMatch[1];
     if (filePath.includes('opencode.db'))
         return 'opencode';
-    // Try file extension + content heuristic
-    if (filePath.endsWith('.json'))
-        return 'gemini';
     return null;
 }
 /**
@@ -1051,135 +1043,6 @@ export function parseCodexContent(content) {
     }
     return events;
 }
-// ---------------------------------------------------------------------------
-// Gemini parser
-// ---------------------------------------------------------------------------
-/** Parse a Gemini JSON session file into normalized events. */
-export function parseGemini(filePath) {
-    const content = safeReadSessionFile(filePath);
-    let session;
-    try {
-        session = JSON.parse(content);
-    }
-    catch {
-        /* Gemini session file is not valid JSON */
-        throw new Error(`Failed to parse Gemini session: ${filePath}`);
-    }
-    const messages = session.messages || [];
-    const events = [];
-    events.push({
-        type: 'init',
-        agent: 'gemini',
-        timestamp: session.startTime || new Date().toISOString(),
-        content: `Gemini session ${session.sessionId || ''}`.trim(),
-    });
-    for (const msg of messages) {
-        const timestamp = msg.timestamp || session.startTime || new Date().toISOString();
-        if (msg.type === 'user') {
-            const text = extractGeminiContent(msg.content);
-            if (text) {
-                events.push({
-                    type: 'message',
-                    agent: 'gemini',
-                    timestamp,
-                    role: 'user',
-                    content: text,
-                });
-            }
-        }
-        else if (msg.type === 'gemini') {
-            // Reasoning thoughts
-            if (Array.isArray(msg.thoughts)) {
-                for (const thought of msg.thoughts) {
-                    const text = thought.description || thought.subject || '';
-                    if (text.trim()) {
-                        const subject = thought.subject ? `**${thought.subject}**: ` : '';
-                        events.push({
-                            type: 'thinking',
-                            agent: 'gemini',
-                            timestamp: thought.timestamp || timestamp,
-                            content: `${subject}${thought.description || ''}`.trim(),
-                        });
-                    }
-                }
-            }
-            // Assistant text
-            const text = extractGeminiContent(msg.content);
-            if (text) {
-                events.push({
-                    type: 'message',
-                    agent: 'gemini',
-                    timestamp,
-                    role: 'assistant',
-                    content: text,
-                });
-            }
-            // Tool calls (Gemini inlines call + result on the same message)
-            if (Array.isArray(msg.toolCalls)) {
-                for (const tc of msg.toolCalls) {
-                    const toolName = tc.name || 'unknown';
-                    const args = tc.args || {};
-                    events.push({
-                        type: 'tool_use',
-                        agent: 'gemini',
-                        timestamp: tc.timestamp || timestamp,
-                        tool: toolName,
-                        callId: typeof tc.id === 'string' ? tc.id : undefined,
-                        args,
-                        command: ['run_shell_command', 'shell', 'bash'].includes(toolName) ? args.command : undefined,
-                        path: args.file_path || args.path || undefined,
-                    });
-                    // Inline result
-                    if (tc.result || tc.status) {
-                        let output = '';
-                        if (Array.isArray(tc.result)) {
-                            for (const r of tc.result) {
-                                const resp = r?.functionResponse?.response;
-                                if (resp?.output) {
-                                    output += String(resp.output);
-                                }
-                            }
-                        }
-                        else if (typeof tc.result === 'string') {
-                            output = tc.result;
-                        }
-                        events.push({
-                            type: 'tool_result',
-                            agent: 'gemini',
-                            timestamp: tc.timestamp || timestamp,
-                            tool: toolName,
-                            callId: typeof tc.id === 'string' ? tc.id : undefined,
-                            success: tc.status === 'success',
-                            output,
-                        });
-                    }
-                }
-            }
-        }
-    }
-    return events;
-}
-/**
- * Extract text content from Gemini's content field,
- * which can be a string or an array of {text: string} parts.
- */
-function extractGeminiContent(content) {
-    if (typeof content === 'string')
-        return content.trim();
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (typeof part === 'string')
-                return part;
-            if (typeof part?.text === 'string')
-                return part.text;
-            return '';
-        })
-            .join('\n')
-            .trim();
-    }
-    return '';
-}
 /** Read a base-128 varint from `b` at offset `i`; returns [value, nextOffset]. */
 function readVarint(b, i) {
     let shift = 0;

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

@@ -58,8 +58,10 @@ export interface PidSessionEntry {
         startTime?: string;
     };
 }
+/** ps lstart fields can differ in padding or date formatting between invocations. */
+export declare function processStartTimesMatch(recorded: string | undefined, observed: string | undefined): boolean | undefined;
 /** Read-only identity proof for exact joins. Unknown is never a positive match. */
-export declare function pidSessionEntryMatchesLiveProcess(entry: PidSessionEntry): boolean | undefined;
+export declare function pidSessionEntryMatchesLiveProcess(entry: PidSessionEntry, startTime?: string): boolean | undefined;
 export declare function isSessionIdShape(value: string): boolean;
 export declare function extractSessionIdArg(args: string[]): string | undefined;
 /**
@@ -86,8 +88,9 @@ export declare function sessionIdFromLivePid(pid: number): string | undefined;
 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;
-/** Live consumers require identity proof; raw history is not a PID binding. */
-export declare function readLivePidSessionEntry(pid: number): PidSessionEntry | undefined;
+/** Live consumers require identity proof; raw history is not a PID binding.
+ * A shared process snapshot may supply lstart to avoid a per-pid ps probe. */
+export declare function readLivePidSessionEntry(pid: number, startTime?: string): PidSessionEntry | undefined;
 /**
  * Every recorded launch, one entry per live-or-dead pid. Used to index launches
  * by their `tmuxPane` so the authoritative tmux source can attribute a pane it did

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

@@ -55,16 +55,25 @@ function darwinStartTime(pid) {
         return undefined;
     }
 }
+function processStartTimeMs(value) {
+    return typeof value === 'string' ? Date.parse(value.trim().replace(/\s+/g, ' ')) : NaN;
+}
+/** ps lstart fields can differ in padding or date formatting between invocations. */
+export function processStartTimesMatch(recorded, observed) {
+    const recordedMs = processStartTimeMs(recorded);
+    const observedMs = processStartTimeMs(observed);
+    return Number.isFinite(recordedMs) && Number.isFinite(observedMs) ? recordedMs === observedMs : undefined;
+}
 /** Read-only identity proof for exact joins. Unknown is never a positive match. */
-export function pidSessionEntryMatchesLiveProcess(entry) {
+export function pidSessionEntryMatchesLiveProcess(entry, startTime) {
     if (!Number.isInteger(entry.pid) || entry.pid < 1)
         return undefined;
     if (process.platform === 'darwin') {
         const exists = pidExists(entry.pid);
         if (exists !== true)
             return exists;
-        const start = darwinStartTime(entry.pid);
-        return start && entry.processIdentity?.startTime ? start === entry.processIdentity.startTime : undefined;
+        const start = startTime ?? darwinStartTime(entry.pid);
+        return processStartTimesMatch(entry.processIdentity?.startTime, start);
     }
     if (process.platform !== 'linux')
         return undefined;
@@ -233,8 +242,9 @@ export function readPidSessionEntry(pid) {
     }
     return undefined;
 }
-/** Live consumers require identity proof; raw history is not a PID binding. */
-export function readLivePidSessionEntry(pid) {
+/** Live consumers require identity proof; raw history is not a PID binding.
+ * A shared process snapshot may supply lstart to avoid a per-pid ps probe. */
+export function readLivePidSessionEntry(pid, startTime) {
     const entry = readPidSessionEntry(pid);
     if (!entry || !hostProcessView())
         return undefined;
@@ -244,8 +254,8 @@ export function readLivePidSessionEntry(pid) {
         // Upgrade a native legacy launch only after the home namespace is proven,
         // and the actual process start excludes a recycled PID. Hook timestamps may
         // be later than process start, but cannot predate this process incarnation.
-        const start = darwinStartTime(pid);
-        const startMs = start ? Date.parse(start) : NaN;
+        const start = startTime ?? darwinStartTime(pid);
+        const startMs = processStartTimeMs(start);
         if (Number.isFinite(startMs) && entry.startedAtMs >= startMs - 1000 && entry.startedAtMs <= Date.now()) {
             const scope = hostProcessView();
             entry.processIdentity = process.platform === 'linux'
@@ -257,7 +267,7 @@ export function readLivePidSessionEntry(pid) {
             catch { /* read remains useful */ }
         }
     }
-    return pidSessionEntryMatchesLiveProcess(entry) === true ? entry : undefined;
+    return pidSessionEntryMatchesLiveProcess(entry, startTime) === true ? entry : undefined;
 }
 /**
  * Every recorded launch, one entry per live-or-dead pid. Used to index launches

package/dist/lib/session/remote/watch.d.ts

@@ -88,7 +88,7 @@ export declare function sessionWatchRowKey(scope: string, row: ActiveSession): s
 export declare function toSessionWatchRow(scope: string, row: ActiveSession): SessionWatchRow;
 /** Project one durable indexed session into the same canonical watch contract
  * as live sessions. This is the only history backfill consumed by AGI EXT. */
-export declare function toPreviousSessionWatchRow(scope: string, session: SessionMeta): SessionWatchRow;
+export declare function toPreviousSessionWatchRow(scope: string, session: SessionMeta, accounts?: import("../../account-registry.js").NativeAccount[]): SessionWatchRow;
 /** Stream-local sequencer and convergent row diff. */
 export declare class SessionWatchState {
     readonly streamId: string;

package/dist/lib/session/remote/watch.js

@@ -8,7 +8,9 @@ import { machineId, normalizeHost } from '../../machine-id.js';
 import { shellQuote } from '../../ssh-exec.js';
 import { streamFromPeer } from './peer-stream.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../../hosts/remote-cmd.js';
-import { isReapableOrphan } from '../active.js';
+import { isReapableOrphan, sessionAccountLabel } from '../active.js';
+import { listNativeAccounts } from '../../account-registry.js';
+import { readMeta } from '../../state.js';
 import { querySessions, readSessionSummaryAny, readSessionTimelineAny } from '../db.js';
 import { linearIssueUrl } from '../linear.js';
 import { sessionAgentSupportsResume } from '../recovery.js';
@@ -79,7 +81,7 @@ function previousRowTitle(session, foldedHeadline) {
 }
 /** Project one durable indexed session into the same canonical watch contract
  * as live sessions. This is the only history backfill consumed by AGI EXT. */
-export function toPreviousSessionWatchRow(scope, session) {
+export function toPreviousSessionWatchRow(scope, session, accounts = listNativeAccounts(readMeta())) {
     const resumable = sessionAgentSupportsResume(session.agent);
     const sourceDevice = normalizeHost(session.machine ?? scope);
     const startedAtMs = epochMs(session.timestamp);
@@ -125,6 +127,7 @@ export function toPreviousSessionWatchRow(scope, session) {
         ...(session.firstUserMessage ? { firstUserMessage: session.firstUserMessage } : {}),
         ...(session.version ? { version: session.version } : {}),
         ...(session.account ? { account: session.account } : {}),
+        accountLabel: sessionAccountLabel(session.agent, session, accounts),
         ...(session.prUrl ? { pr: { url: session.prUrl, number: session.prNumber } } : {}),
         ...(worktree ? { worktree } : {}),
         ...(session.gitBranch ? { branch: session.gitBranch } : {}),
@@ -226,10 +229,11 @@ export class SessionWatchState {
         const liveRows = sourceRows.map((row) => toSessionWatchRow(scope, row));
         const sourceIds = new Set(liveRows.map((row) => row.sessionId).filter((id) => Boolean(id)));
         const rows = new Map(liveRows.map((row) => [row.rowKey, row]));
+        const accounts = indexedRows.length ? listNativeAccounts(readMeta()) : [];
         for (const indexed of indexedRows) {
             if (sourceIds.has(indexed.id))
                 continue;
-            const row = toPreviousSessionWatchRow(scope, indexed);
+            const row = toPreviousSessionWatchRow(scope, indexed, accounts);
             rows.set(row.rowKey, row);
         }
         this.prunePrevious(scope, rows);

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

@@ -8,7 +8,7 @@
  * straight off `agents sessions --active --json` instead (issue #741).
  */
 /** Agents whose transcript formats report per-turn output-token usage. */
-type ThroughputAgent = 'claude' | 'codex' | 'gemini';
+type ThroughputAgent = 'claude' | 'codex';
 /**
  * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
  *
@@ -22,8 +22,6 @@ type ThroughputAgent = 'claude' | 'codex' | 'gemini';
  *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
  *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
  *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
- *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
- *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
  */
 export declare function computeTokPerSec(sessionContent: string, agent: ThroughputAgent, windowSec?: number, now?: number): number;
 export {};

package/dist/lib/session/throughput.js

@@ -22,30 +22,10 @@ const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
  *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
  *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
  *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
- *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
- *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
  */
 export function computeTokPerSec(sessionContent, agent, windowSec = DEFAULT_THROUGHPUT_WINDOW_SEC, now = Date.now()) {
     const cutoff = now - windowSec * 1000;
     let total = 0;
-    if (agent === 'gemini') {
-        try {
-            const d = JSON.parse(sessionContent);
-            const messages = Array.isArray(d?.messages) ? d.messages : [];
-            for (const m of messages) {
-                if (m?.type !== 'gemini')
-                    continue;
-                const ts = typeof m.timestamp === 'string' ? Date.parse(m.timestamp) : 0;
-                if (!ts || ts < cutoff)
-                    continue;
-                const out = typeof m?.tokens?.output === 'number' ? m.tokens.output : 0;
-                const thoughts = typeof m?.tokens?.thoughts === 'number' ? m.tokens.thoughts : 0;
-                total += out + thoughts;
-            }
-        }
-        catch { /* malformed gemini file → 0 */ }
-        return total / windowSec;
-    }
     const lines = sessionContent.split(/\r?\n/);
     for (let i = lines.length - 1; i >= 0; i--) {
         const line = lines[i];

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

@@ -2,12 +2,12 @@
  * Session data model.
  *
  * Normalized types that unify the different session storage formats used by
- * Claude (JSONL), Codex (JSONL events), Gemini (single JSON), and OpenCode.
+ * Claude (JSONL), Codex (JSONL events), and OpenCode.
  * Everything in the session pipeline -- discovery, parsing, rendering --
  * speaks these types.
  */
 /** Agents that store session data on disk and can be discovered by `agents sessions`. */
-export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'antigravity' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid' | 'cursor' | 'muse';
+export type SessionAgentId = 'claude' | 'codex' | 'antigravity' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid' | 'cursor' | 'muse';
 /** Effective permissions mode used to launch a managed agent session. */
 export type SessionRunMode = 'plan' | 'edit' | 'auto' | 'skip';
 /** All agents with session discovery support, in display order. */

package/dist/lib/session/types.js

@@ -2,12 +2,12 @@
  * Session data model.
  *
  * Normalized types that unify the different session storage formats used by
- * Claude (JSONL), Codex (JSONL events), Gemini (single JSON), and OpenCode.
+ * Claude (JSONL), Codex (JSONL events), and OpenCode.
  * Everything in the session pipeline -- discovery, parsing, rendering --
  * speaks these types.
  */
 /** All agents with session discovery support, in display order. */
-export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'antigravity', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid', 'cursor', 'muse'];
+export const SESSION_AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid', 'cursor', 'muse'];
 /**
  * True when `agent` stores session data `agents sessions` can discover (a member
  * of {@link SESSION_AGENTS}). The single predicate every session-index writer

package/dist/lib/sessions-client.d.ts

@@ -7,7 +7,66 @@ export declare function invocation(bin: string): {
     command: string;
     prefix: string[];
 };
-export declare function isReadQuery(args: string[]): boolean;
+/** True if any 0.2.0-only filter flag is present — one case that needs the version probe. */
+export declare function usesFilterFlags(args: string[]): boolean;
+/**
+ * True if the 0.2.1 point-to-one remote read flag `--host <value>` (or `--host=value`)
+ * is present — the other case that needs the version probe, gated on its own floor.
+ */
+export declare function usesHostFlag(args: string[]): boolean;
+/**
+ * Whether the resolved `sessions` binary is at or above `minVersion`. A probe
+ * failure or an unparseable version reads as unsupported — the safe direction
+ * (in-repo engine handles it), never a mis-route to an old binary.
+ */
+export declare function sessionsBinSupports(bin: string, minVersion: string): boolean;
+/** Whether the resolved `sessions` binary is new enough for the 0.2.0 filters. */
+export declare function sessionsBinSupportsFilters(bin: string): boolean;
+/** Whether the resolved `sessions` binary is new enough for the 0.2.1 `--host` flag. */
+export declare function sessionsBinSupportsHost(bin: string): boolean;
+export declare function isReadQuery(args: string[], opts?: {
+    filters?: boolean;
+    host?: boolean;
+}): boolean;
+/**
+ * Plan the rewrite of a `sessions` READ query that names EXACTLY ONE device via
+ * `--device <name>` (and no explicit `--host`) into the standalone's
+ * point-to-one remote read: the caller resolves the device to an ssh target and
+ * appends `--host ssh://<target>` to `readArgs`, forwarding it to the LOCAL
+ * standalone (which owns the ssh hop). This is the local-orchestration collapse
+ * (secrets-cli model): `sessions` owns the remote read, replacing the in-repo
+ * `--device` peer fan-out — WHEN it is safe (the caller gates on the LOCAL
+ * standalone supporting `--host`, >=0.2.1, and falls through to the in-repo
+ * fan-out if the PEER lacks the standalone).
+ *
+ * `sessions --host` is point-to-one, so ONLY a single unambiguous device may
+ * collapse; a multi-device query MUST stay on the in-repo fan-out, which parses
+ * commander's variadic `--device` correctly. Returns null (→ in-repo path,
+ * unchanged) when the query is not a single-device read:
+ *   - no `--device`/`-D`, or a missing/flag-shaped value;
+ *   - `--device`/`-D` appears more than once (`--device box --device mac-mini`);
+ *   - the value is a fan-out sentinel `all`/`fleet` (case-insensitive);
+ *   - a bare token immediately follows the value (`--device box mac-mini`) —
+ *     commander's variadic would take it as a second device, so this is
+ *     multi-device too;
+ *   - an explicit `--host` is already on the argv — it wins, matching `secrets`'
+ *     `rewriteDeviceToHost`, so we never add a second `--host`;
+ *   - the remaining query (with `--device` stripped) is not a read — a lifecycle
+ *     `--device` (resume/watch/inject/focus/…) keeps its in-repo/`runOnPeer`
+ *     behavior exactly.
+ *
+ * Pure and argv-only: fleet resolution (device → ssh target, via
+ * `resolveRemoteDevice`) and the version gate live in the caller so this is unit
+ * testable with real inputs. `filters` mirrors the caller's version gate for the
+ * 0.2.0 filter flags (the `--device` token is not a filter flag, so it is
+ * computed identically on the original argv and on `readArgs`).
+ */
+export declare function planDeviceHostRead(args: string[], opts?: {
+    filters?: boolean;
+}): {
+    device: string;
+    readArgs: string[];
+} | null;
 /** Test seam: drop the memoized bin so PATH fixtures can re-resolve. */
 export declare function _resetSessionsClientForTest(): void;
 export declare const SESSIONS_INSTALL_HINT = "npm i -g @phnx-labs/sessions-cli";