@phnx-labs/agents-cli 1.19.1 → 1.20.0

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

@@ -155,7 +155,13 @@ export declare function getRowCount(): {
     sessions: number;
     textRows: number;
 };
-/** Count sessions older than the given timestamp (for dry-run previews). */
-export declare function countSessionsOlderThan(cutoffMs: number): number;
-/** Delete sessions older than the given timestamp. Returns the number of rows deleted. */
-export declare function deleteSessionsOlderThan(cutoffMs: number): number;
+/**
+ * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
+ * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
+ * entries so they are re-indexed from the new location on the next scan.
+ *
+ * Used by removeVersion after soft-deleting a version directory to trash, so
+ * that session reads (transcript view, /continue) still work from the trash path.
+ * Returns the number of session rows updated.
+ */
+export declare function updateSessionFilePaths(oldPrefix: string, newPrefix: string): number;

package/dist/lib/session/db.js

@@ -742,27 +742,27 @@ export function getRowCount() {
     const textRows = db.prepare(`SELECT COUNT(*) AS c FROM session_text`).get().c;
     return { sessions, textRows };
 }
-/** Count sessions older than the given timestamp (for dry-run previews). */
-export function countSessionsOlderThan(cutoffMs) {
-    const db = getDB();
-    const cutoffIso = new Date(cutoffMs).toISOString();
-    const row = db.prepare(`SELECT COUNT(*) AS n FROM sessions WHERE timestamp < ?`).get(cutoffIso);
-    return row.n;
-}
-/** Delete sessions older than the given timestamp. Returns the number of rows deleted. */
-export function deleteSessionsOlderThan(cutoffMs) {
+/**
+ * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
+ * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
+ * entries so they are re-indexed from the new location on the next scan.
+ *
+ * Used by removeVersion after soft-deleting a version directory to trash, so
+ * that session reads (transcript view, /continue) still work from the trash path.
+ * Returns the number of session rows updated.
+ */
+export function updateSessionFilePaths(oldPrefix, newPrefix) {
     const db = getDB();
-    const cutoffIso = new Date(cutoffMs).toISOString();
-    const rows = db.prepare(`SELECT id, file_path FROM sessions WHERE timestamp < ?`).all(cutoffIso);
+    const rows = db
+        .prepare(`SELECT id, file_path FROM sessions WHERE file_path LIKE ?`)
+        .all(oldPrefix + '%');
     if (rows.length === 0)
         return 0;
     const txn = db.transaction(() => {
         for (const { id, file_path } of rows) {
-            db.prepare(`DELETE FROM session_text WHERE session_id = ?`).run(id);
-            db.prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
-            if (file_path) {
-                db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`).run(canonicalLedgerKey(file_path));
-            }
+            const newPath = newPrefix + file_path.slice(oldPrefix.length);
+            db.prepare(`UPDATE sessions SET file_path = ? WHERE id = ?`).run(newPath, id);
+            db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`).run(canonicalLedgerKey(file_path));
         }
     });
     txn();

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

@@ -43,6 +43,7 @@ export declare function parseGemini(filePath: string): SessionEvent[];
  * Messages have role (user/assistant) and metadata.
  * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
  */
+export declare function parseGrok(filePath: string): SessionEvent[];
 export declare function parseOpenCode(filePath: string): SessionEvent[];
 /** Parse a Rush JSONL session file into normalized events. */
 export declare function parseRush(filePath: string): SessionEvent[];

package/dist/lib/session/parse.js

@@ -93,6 +93,9 @@ export function parseSession(filePath, agent) {
         case 'opencode':
             events = parseOpenCode(filePath);
             break;
+        case 'grok':
+            events = parseGrok(filePath);
+            break;
         case 'rush':
             events = parseRush(filePath);
             break;
@@ -118,6 +121,8 @@ export function detectAgent(filePath) {
         return 'codex';
     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\\'))
         return 'rush';
     if (filePath.includes('/.hermes/') || filePath.includes('\\.hermes\\'))
@@ -645,6 +650,45 @@ function extractGeminiContent(content) {
  * Messages have role (user/assistant) and metadata.
  * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
  */
+export function parseGrok(filePath) {
+    // Grok sessions are rich (summary.json + events.jsonl + chat_history.jsonl + updates.jsonl)
+    // This is a minimal stub for now so grok appears in `agents sessions`.
+    // Full parser (with subagents, tool calls, etc.) can be expanded later.
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // If it's a summary.json, create a basic event
+        if (filePath.endsWith('summary.json')) {
+            const summary = JSON.parse(content);
+            return [{
+                    timestamp: summary.created_at || new Date().toISOString(),
+                    type: 'session_start',
+                    content: summary.session_summary || 'Grok session',
+                    agent: 'grok',
+                    metadata: { sessionId: summary.id, cwd: summary.cwd },
+                }];
+        }
+        // For JSONL files (events, chat_history, updates), return basic parsed lines
+        if (filePath.endsWith('.jsonl')) {
+            const lines = content.trim().split('\n').filter(Boolean);
+            return lines.slice(0, 50).map((line, i) => {
+                try {
+                    const obj = JSON.parse(line);
+                    return {
+                        timestamp: obj.timestamp || obj.ts || new Date().toISOString(),
+                        type: obj.type || obj.method || 'grok_event',
+                        content: typeof obj.content === 'string' ? obj.content : JSON.stringify(obj).slice(0, 200),
+                        agent: 'grok',
+                    };
+                }
+                catch {
+                    return { timestamp: new Date().toISOString(), type: 'raw', content: line.slice(0, 200), agent: 'grok' };
+                }
+            });
+        }
+    }
+    catch { }
+    return [];
+}
 export function parseOpenCode(filePath) {
     const [dbPath, sessionId] = filePath.split('#');
     if (!dbPath || !sessionId)

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

@@ -7,7 +7,7 @@
  * speaks these types.
  */
 /** Agents that store session data on disk and can be discovered by `agents sessions`. */
-export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'opencode' | 'openclaw' | 'rush' | 'hermes';
+export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok';
 /** All agents with session discovery support, in display order. */
 export declare const SESSION_AGENTS: SessionAgentId[];
 /** A single normalized event within a session (message, tool call, thinking, etc.). */

package/dist/lib/session/types.js

@@ -7,4 +7,4 @@
  * speaks these types.
  */
 /** All agents with session discovery support, in display order. */
-export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'opencode', 'openclaw', 'rush', 'hermes'];
+export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'opencode', 'openclaw', 'rush', 'hermes', 'grok'];

package/dist/lib/shims.d.ts

@@ -55,8 +55,12 @@ export interface ConflictInfo {
  *   v12 — helper calls inside generated shims use the absolute agents-cli
  *         entrypoint instead of PATH-resolved `agents`.
  *   v13 — validate agents.yaml version strings before constructing binary paths.
+ *   v14 — derive `configDirName` from `agentConfig.configDir` relative to $HOME
+ *         instead of hardcoding `.${agent}`. Backwards-compatible for every
+ *         existing agent (their configDir is `~/.{agent}`); enables nested
+ *         layouts like Antigravity's `~/.gemini/antigravity-cli/`.
  */
-export declare const SHIM_SCHEMA_VERSION = 13;
+export declare const SHIM_SCHEMA_VERSION = 14;
 /**
  * Generate the full bash shim script for the given agent. The returned string
  * is written to ~/.agents/shims/{cliCommand} and made executable.
@@ -209,7 +213,7 @@ export declare function getPathShadowingExecutable(agent: AgentId): string | nul
  * Delete the legacy ~/.agents/shims/<cli> file if it exists, returning whether
  * anything was removed. Pre-split installs put shims under ~/.agents/shims/;
  * the new layout uses ~/.agents-system/shims/. The leftover file causes the
- * repair-prompt loop reported in EXAMPLE-664 — `getPathShadowingExecutable` flags
+ * repair-prompt loop reported in PROJ-789 — `getPathShadowingExecutable` flags
  * it as a shadow but `addShimsToPath` only edits rc files, never the file
  * itself. Removing it ends the loop.
  */

package/dist/lib/shims.js

@@ -179,8 +179,12 @@ async function promptConflictStrategy(conflictInfos) {
  *   v12 — helper calls inside generated shims use the absolute agents-cli
  *         entrypoint instead of PATH-resolved `agents`.
  *   v13 — validate agents.yaml version strings before constructing binary paths.
+ *   v14 — derive `configDirName` from `agentConfig.configDir` relative to $HOME
+ *         instead of hardcoding `.${agent}`. Backwards-compatible for every
+ *         existing agent (their configDir is `~/.{agent}`); enables nested
+ *         layouts like Antigravity's `~/.gemini/antigravity-cli/`.
  */
-export const SHIM_SCHEMA_VERSION = 13;
+export const SHIM_SCHEMA_VERSION = 14;
 /** Internal marker string used to embed the schema version in shim scripts. */
 const SHIM_VERSION_MARKER = 'agents-shim-version:';
 function shellQuote(value) {
@@ -196,7 +200,11 @@ function getAgentsBinForGeneratedShim() {
 export function generateShimScript(agent) {
     const agentConfig = AGENTS[agent];
     const cliCommand = agentConfig.cliCommand;
-    const configDirName = `.${agent}`;
+    // Derive the relative config-dir path from the registry. For most agents
+    // this is just `.${agent}` (e.g., `.claude`, `.codex`); for nested layouts
+    // like Antigravity (`~/.gemini/antigravity-cli`) it carries the full
+    // subpath so per-version HOME symlinks reach the right place.
+    const configDirName = path.relative(os.homedir(), agentConfig.configDir);
     const agentsBin = shellQuote(getAgentsBinForGeneratedShim());
     const managedEnv = agent === 'claude'
         ? `
@@ -218,7 +226,22 @@ fi
 # written by agents-cli actually take effect.
 export CODEX_HOME="$VERSION_DIR/home/${configDirName}"
 `
-            : '';
+            : agent === 'copilot'
+                ? `
+# GitHub Copilot CLI honors COPILOT_HOME to relocate its config and state
+# (settings.json, mcp-config.json, session-state/, logs/, plugins/). Point
+# it at the versioned home so MCP servers, custom agents, and session
+# history are isolated per copilot version.
+export COPILOT_HOME="$VERSION_DIR/home/${configDirName}"
+`
+                : agent === 'grok'
+                    ? `
+# Grok Build uses GROK_HOME to isolate its entire configuration tree
+# (skills, hooks, plugins, agents, memory, sessions, config.toml, MCP, etc.).
+# This gives agents-cli full versioned isolation + resource sync for grok.
+export GROK_HOME="$VERSION_DIR/home/.grok"
+`
+                    : '';
     // Agents that don't natively resolve @-imports in their rules file need
     // agents-cli to recompile when the user edits a rule/preset file. The
     // check is fast (sha256 of ~8 small files) and skips the recompile when
@@ -368,7 +391,27 @@ if [[ ! "$VERSION" =~ ^(latest|[A-Za-z0-9._+-]{1,64})$ || "$VERSION" == *..* ]];
 fi
 
 VERSION_DIR="$AGENTS_USER_DIR/.history/versions/$AGENT/$VERSION"
-BINARY="$VERSION_DIR/node_modules/.bin/$CLI_COMMAND"
+
+# Grok special case: binary lives in ~/.grok/downloads/, not node_modules.
+# We still use the agents-cli version dir purely for GROK_HOME isolation.
+if [ "$AGENT" = "grok" ]; then
+  # Try to find a matching binary for the pinned version in the global grok downloads dir.
+  GROK_DOWNLOADS="$HOME/.grok/downloads"
+  if [ -d "$GROK_DOWNLOADS" ]; then
+    # Prefer a binary whose filename contains the exact version
+    BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | grep -i "$VERSION" | head -1)
+    if [ -z "$BINARY" ]; then
+      # Fallback to the "current" grok binary (symlink or latest)
+      BINARY=$(ls "$GROK_DOWNLOADS"/grok-* 2>/dev/null | head -1)
+    fi
+  fi
+  if [ -z "$BINARY" ] || [ ! -x "$BINARY" ]; then
+    # Last resort: whatever is on PATH (user may have installed grok globally)
+    BINARY=$(command -v grok 2>/dev/null || echo "")
+  fi
+else
+  BINARY="$VERSION_DIR/node_modules/.bin/$CLI_COMMAND"
+fi
 
 # Auto-install if not present
 if [ ! -x "$BINARY" ]; then
@@ -504,7 +547,9 @@ function assertSafeVersion(version) {
 export function generateVersionedAliasScript(agent, version) {
     assertSafeVersion(version);
     const agentConfig = AGENTS[agent];
-    const configDirName = `.${agent}`;
+    // Same derivation as `generateShimScript` so nested layouts (e.g.,
+    // Antigravity's `~/.gemini/antigravity-cli`) land in the right place.
+    const configDirName = path.relative(os.homedir(), agentConfig.configDir);
     const managedEnv = agent === 'claude'
         ? `
 # Claude stores OAuth credentials in the macOS keychain. Scope them to this
@@ -518,7 +563,14 @@ export CLAUDE_CONFIG_DIR="$HOME/.agents/.history/versions/${agent}/${version}/ho
 # and rules written by agents-cli actually take effect.
 export CODEX_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home/${configDirName}"
 `
-            : '';
+            : agent === 'copilot'
+                ? `
+# Copilot honors COPILOT_HOME to relocate ~/.copilot (settings, mcp-config.json,
+# session-state, logs). Point direct aliases at the versioned home so per-
+# version MCP and session state are isolated.
+export COPILOT_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home/${configDirName}"
+`
+                : '';
     const launchArgs = agent === 'codex' ? ' -c check_for_update_on_startup=false' : '';
     return `#!/bin/bash
 # Auto-generated by agents-cli - do not edit
@@ -637,7 +689,9 @@ function getAgentConfigPath(agent) {
 function getVersionConfigPath(agent, version) {
     const agentConfig = AGENTS[agent];
     const versionsDir = getVersionsDir();
-    const configDirName = `.${agent}`; // .claude, .codex, etc.
+    // Carry the agent's full configDir subpath so nested layouts work.
+    // e.g., antigravity → `.gemini/antigravity-cli`, claude → `.claude`.
+    const configDirName = path.relative(os.homedir(), agentConfig.configDir);
     return path.join(versionsDir, agent, version, 'home', configDirName);
 }
 /**
@@ -707,8 +761,29 @@ export async function switchConfigSymlink(agent, version) {
                 // Already pointing to correct target, no-op
                 return { success: true };
             }
+            // openclaw mixes user data (openclaw.json, openclaw.db, per-agent
+            // workspaces under ~/.openclaw/{agentId}/, memory/) with the version
+            // home — silently swapping the symlink to a fresh version home strips
+            // every running agent's config + workspace + memory. Carry the user
+            // data forward into the new version home before flipping the symlink
+            // (keep-dest preserves anything the new version already shipped).
+            // Other agents (Claude, Codex, etc.) keep user data outside the
+            // version-home dir, so this is openclaw-only by design.
+            if (agent === 'openclaw') {
+                try {
+                    if (fs.existsSync(resolvedCurrent) && fs.statSync(resolvedCurrent).isDirectory()) {
+                        await copyDirContents(resolvedCurrent, versionConfigPath, 'keep-dest');
+                    }
+                }
+                catch (migrationErr) {
+                    console.error(`Warning: openclaw data migration from ${resolvedCurrent} -> ${versionConfigPath} ` +
+                        `failed: ${migrationErr.message}. The previous version's data is intact ` +
+                        `at the old path; you can copy it manually if needed.`);
+                }
+            }
             // Different target - update it
             fs.unlinkSync(configPath);
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
             fs.symlinkSync(versionConfigPath, configPath);
             return { success: true };
         }
@@ -721,7 +796,7 @@ export async function switchConfigSymlink(agent, version) {
             const finalBackupPath = path.join(agentBackupDir, String(timestamp));
             fs.mkdirSync(agentBackupDir, { recursive: true });
             fs.renameSync(configPath, finalBackupPath);
-            // Create symlink
+            // Create symlink (parent already exists since the dir we just moved was here)
             fs.symlinkSync(versionConfigPath, configPath);
             return { success: true, backupPath: finalBackupPath };
         }
@@ -731,7 +806,10 @@ export async function switchConfigSymlink(agent, version) {
     }
     catch (err) {
         if (err.code === 'ENOENT') {
-            // Config path doesn't exist - create symlink
+            // Config path doesn't exist - create symlink.
+            // For nested layouts (e.g., ~/.gemini/antigravity-cli) the parent dir
+            // may also be missing if the parent agent (Gemini) is not installed.
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
             fs.symlinkSync(versionConfigPath, configPath);
             return { success: true };
         }
@@ -1166,7 +1244,7 @@ export function getPathShadowingExecutable(agent) {
  * Delete the legacy ~/.agents/shims/<cli> file if it exists, returning whether
  * anything was removed. Pre-split installs put shims under ~/.agents/shims/;
  * the new layout uses ~/.agents-system/shims/. The leftover file causes the
- * repair-prompt loop reported in EXAMPLE-664 — `getPathShadowingExecutable` flags
+ * repair-prompt loop reported in PROJ-789 — `getPathShadowingExecutable` flags
  * it as a shadow but `addShimsToPath` only edits rc files, never the file
  * itself. Removing it ends the loop.
  */

package/dist/lib/state.d.ts

@@ -212,7 +212,6 @@ export declare function recordVersionResources(_agent: AgentId, _version: string
  */
 export declare function ensureVersionResourcePatterns(agent: AgentId, version: string, updates: Partial<Record<Exclude<keyof VersionResources, 'rulesPreset'>, ResourcePattern[]>>): void;
 export declare function getVersionResources(agent: AgentId, version: string): VersionResources | null;
-export declare function clearVersionResources(agent: AgentId, version: string): void;
 /** Active rules preset for an agent@version. Defaults to "default" when unset. */
 export declare function getActiveRulesPreset(agent: AgentId, version: string): string;
 /** Persist the active rules preset for an agent@version. */

package/dist/lib/state.js

@@ -74,7 +74,7 @@ const DRIVE_DIR = path.join(CACHE_DIR, 'drive');
 const TERMINALS_DIR = path.join(CACHE_DIR, 'terminals');
 const LOGS_DIR = path.join(CACHE_DIR, 'logs');
 const RUNTIME_STATE_DIR = path.join(CACHE_DIR, 'state');
-const SWARMIFY_DIR = path.join(CACHE_DIR, 'companion');
+const COMPANION_CACHE_DIR = path.join(CACHE_DIR, 'companion');
 const BROWSER_RUNTIME_DIR = path.join(CACHE_DIR, 'browser');
 const HELPERS_DIR = path.join(CACHE_DIR, 'helpers');
 const DAEMON_DIR = path.join(HELPERS_DIR, 'daemon');
@@ -294,7 +294,7 @@ export function getLogsDir() { return LOGS_DIR; }
 /** Path to per-process runtime state (~/.agents/.cache/state/). */
 export function getRuntimeStateDir() { return RUNTIME_STATE_DIR; }
 /** Path to companion-extension scratch (~/.agents/.cache/companion/). */
-export function getCompanionDir() { return SWARMIFY_DIR; }
+export function getCompanionDir() { return COMPANION_CACHE_DIR; }
 /** Path to browser runtime data — chrome-data, pids (~/.agents/.cache/browser/). */
 export function getBrowserRuntimeDir() { return BROWSER_RUNTIME_DIR; }
 /** Path to helper subprocess scratch (~/.agents/.cache/helpers/). */
@@ -626,19 +626,6 @@ export function getVersionResources(agent, version) {
     const meta = readMeta();
     return meta.versions?.[agent]?.[version] || null;
 }
-export function clearVersionResources(agent, version) {
-    const meta = readMeta();
-    if (meta.versions?.[agent]?.[version]) {
-        delete meta.versions[agent][version];
-        if (Object.keys(meta.versions[agent]).length === 0) {
-            delete meta.versions[agent];
-        }
-        if (Object.keys(meta.versions).length === 0) {
-            delete meta.versions;
-        }
-        writeMeta(meta);
-    }
-}
 /** Active rules preset for an agent@version. Defaults to "default" when unset. */
 export function getActiveRulesPreset(agent, version) {
     const meta = readMeta();

package/dist/lib/teams/agents.js

@@ -171,7 +171,7 @@ export function captureProcessStartTime(pid) {
     }
 }
 /** Agent types the team runner supports. */
-const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode'];
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode', 'grok', 'antigravity'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 

package/dist/lib/teams/parsers.d.ts

@@ -1,5 +1,5 @@
 /** Supported agent CLI types for team spawning. */
-export type AgentType = 'codex' | 'gemini' | 'cursor' | 'claude' | 'opencode';
+export type AgentType = 'codex' | 'gemini' | 'cursor' | 'claude' | 'opencode' | 'grok' | 'antigravity';
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export declare function normalizeEvents(agentType: AgentType, raw: any): any[];
 /** Normalize a raw JSON event, returning only the first unified event (convenience wrapper). */

package/dist/lib/teams/parsers.js

@@ -2,9 +2,9 @@
  * Agent event stream parsers.
  *
  * Normalizes the heterogeneous JSON event formats emitted by each agent CLI
- * (Claude, Codex, Gemini, Cursor, OpenCode) into a unified event schema
- * with consistent types: init, message, tool_use, bash, file_read, file_write,
- * file_create, file_delete, result, error, and others.
+ * (Claude, Codex, Gemini, Cursor, OpenCode, Grok, Antigravity) into a unified
+ * event schema with consistent types: init, message, tool_use, bash,
+ * file_read, file_write, file_create, file_delete, result, error, and others.
  */
 import { extractFileOpsFromBash } from './file_ops.js';
 const claudeToolUseMap = new Map();
@@ -25,6 +25,12 @@ export function normalizeEvents(agentType, raw) {
     else if (agentType === 'opencode') {
         return normalizeOpencode(raw);
     }
+    else if (agentType === 'grok') {
+        return normalizeGrok(raw);
+    }
+    else if (agentType === 'antigravity') {
+        return normalizeAntigravity(raw);
+    }
     const timestamp = new Date().toISOString();
     return [{
             type: raw.type || 'unknown',
@@ -824,6 +830,150 @@ function normalizeOpencode(raw) {
             timestamp: timestamp,
         }];
 }
+// --- Grok parsing ---
+// Grok's streaming-json mode emits one JSON object per token, with three event
+// types:
+//   {"type":"thought","data":"<chunk>"}   — reasoning tokens (many, small)
+//   {"type":"text","data":"<chunk>"}      — visible response tokens (many, small)
+//   {"type":"end","stopReason":"EndTurn","sessionId":"<uuid>","requestId":"<uuid>"}
+//
+// Tool calls are NOT exposed as separate events in this format; they appear
+// inside the `thought` text as XML-like markup. Extracting them reliably would
+// require running a streaming XML/markup parser over concatenated thought
+// chunks, which is out of scope for v1. The teams summary will show grok
+// teammates' bash/file ops as empty — known limitation, fixable later by
+// switching to grok's `agent` subcommand (richer event stream) once stable.
+//
+// Tokens are emitted as `message` events with `complete: false` so the
+// summarizer can concatenate them into a final message; `thinking` events are
+// already collapsed by the summarizer's groupAndFlattenEvents pathway.
+function normalizeGrok(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'grok',
+                raw: raw,
+                timestamp: new Date().toISOString(),
+            }];
+    }
+    const eventType = raw.type || 'unknown';
+    const timestamp = new Date().toISOString();
+    if (eventType === 'thought') {
+        const data = typeof raw.data === 'string' ? raw.data : '';
+        if (!data)
+            return [];
+        return [{
+                type: 'thinking',
+                agent: 'grok',
+                content: data,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'text') {
+        const data = typeof raw.data === 'string' ? raw.data : '';
+        if (!data)
+            return [];
+        return [{
+                type: 'message',
+                agent: 'grok',
+                content: data,
+                complete: false,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'end') {
+        const stopReason = typeof raw.stopReason === 'string' ? raw.stopReason : '';
+        const status = stopReason === 'EndTurn' || stopReason === 'StopSequence' || stopReason === ''
+            ? 'success'
+            : 'error';
+        return [{
+                type: 'result',
+                agent: 'grok',
+                status: status,
+                stop_reason: stopReason || null,
+                session_id: typeof raw.sessionId === 'string' ? raw.sessionId : null,
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'grok',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+// --- Antigravity parsing ---
+// Intentionally conservative. Antigravity's `agy` binary advertises an
+// `--output-format json` flag in its docs, but the released binary errors with
+// `flags provided but not defined: -output-format` (tracked upstream as
+// google-antigravity/antigravity-cli#7, open as of May 2026). Until JSON
+// streaming stabilizes, this parser treats agy output as a black box:
+//   - non-object input (a plain string line, or null/number) becomes a single
+//     `message` event with the full content and complete:true so the
+//     summarizer captures it without token-level concatenation
+//   - objects with a recognizable `type` field (e.g. `init`, `message`,
+//     `result`) get a minimal shape-preserving normalization
+//   - everything else falls through to the generic unknown-event shape
+// Once agy ships stable streaming JSON, replace this with proper event
+// mapping mirroring normalizeGrok / normalizeClaude.
+function normalizeAntigravity(raw) {
+    const timestamp = new Date().toISOString();
+    if (typeof raw === 'string') {
+        if (!raw)
+            return [];
+        return [{
+                type: 'message',
+                agent: 'antigravity',
+                content: raw,
+                complete: true,
+                timestamp: timestamp,
+            }];
+    }
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'antigravity',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    const eventType = raw.type || 'unknown';
+    if (eventType === 'init') {
+        return [{
+                type: 'init',
+                agent: 'antigravity',
+                session_id: typeof raw.sessionId === 'string' ? raw.sessionId : null,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'message') {
+        const content = typeof raw.content === 'string' ? raw.content : '';
+        if (!content)
+            return [];
+        return [{
+                type: 'message',
+                agent: 'antigravity',
+                content: content,
+                complete: raw.complete !== false,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'result') {
+        return [{
+                type: 'result',
+                agent: 'antigravity',
+                status: raw.status === 'error' ? 'error' : 'success',
+                session_id: typeof raw.sessionId === 'string' ? raw.sessionId : null,
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'antigravity',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
 /** Parse a single JSONL line into normalized events. Returns null if the line is not valid JSON. */
 export function parseEvent(agentType, line) {
     try {

package/dist/lib/teams/summarizer.js

@@ -159,11 +159,18 @@ export function groupAndFlattenEvents(events) {
         if (eventType === 'message' || eventType === 'thinking') {
             let count = 1;
             let combinedContent = event.content || '';
+            // Streaming token events (complete:false) get concatenated without a
+            // separator so tokens reassemble into readable prose. Whole-turn events
+            // get joined with newlines so distinct turns/thoughts stay separated.
+            const isStreaming = event.complete === false;
             let j = i + 1;
             while (j < events.length && events[j].type === eventType) {
                 count++;
                 if (events[j].content) {
-                    combinedContent += (combinedContent ? '\n' : '') + events[j].content;
+                    const sep = isStreaming || events[j].complete === false
+                        ? ''
+                        : (combinedContent ? '\n' : '');
+                    combinedContent += sep + events[j].content;
                 }
                 j++;
             }
@@ -405,7 +412,16 @@ export function summarizeEvents(agentId, agentType, status, events, duration = n
         else if (eventType === 'message') {
             const content = event.content || '';
             if (content) {
-                summary.finalMessage = content;
+                // Streaming token-by-token messages (e.g., grok) arrive as many small
+                // `message` events with complete:false; concatenate them so the final
+                // turn reads as one message. Whole-turn messages (claude, codex,
+                // gemini) keep their complete:true semantics — last one wins.
+                if (event.complete === false) {
+                    summary.finalMessage = (summary.finalMessage || '') + content;
+                }
+                else {
+                    summary.finalMessage = content;
+                }
             }
         }
         else if (eventType === 'error') {