@phnx-labs/agents-cli 1.19.2 → 1.20.0

package/dist/lib/session/active.js

@@ -73,11 +73,11 @@ function readLiveTerminals() {
     if (!parsed || typeof parsed !== 'object')
         return [];
     const merged = new Map();
-    for (const slice of Object.values(parsed)) {
+    for (const [windowId, slice] of Object.entries(parsed)) {
         for (const e of (slice?.entries ?? [])) {
             if (!e?.sessionId || !isPidAlive(e.pid))
                 continue;
-            merged.set(e.sessionId, e);
+            merged.set(e.sessionId, { ...e, windowId });
         }
     }
     return Array.from(merged.values());
@@ -259,6 +259,7 @@ export async function listTerminalsActive() {
             sessionFile,
             startedAtMs: t.startedAtMs,
             status: classifyActivity(sessionFile),
+            windowId: t.windowId,
         };
     });
 }

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

@@ -155,8 +155,6 @@ 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;
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -167,5 +165,3 @@ export declare function countSessionsOlderThan(cutoffMs: number): number;
  * Returns the number of session rows updated.
  */
 export declare function updateSessionFilePaths(oldPrefix: string, newPrefix: string): number;
-/** Delete sessions older than the given timestamp. Returns the number of rows deleted. */
-export declare function deleteSessionsOlderThan(cutoffMs: number): number;

package/dist/lib/session/db.js

@@ -742,13 +742,6 @@ 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;
-}
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -775,22 +768,3 @@ export function updateSessionFilePaths(oldPrefix, newPrefix) {
     txn();
     return rows.length;
 }
-/** Delete sessions older than the given timestamp. Returns the number of rows deleted. */
-export function deleteSessionsOlderThan(cutoffMs) {
-    const db = getDB();
-    const cutoffIso = new Date(cutoffMs).toISOString();
-    const rows = db.prepare(`SELECT id, file_path FROM sessions WHERE timestamp < ?`).all(cutoffIso);
-    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));
-            }
-        }
-    });
-    txn();
-    return rows.length;
-}

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

@@ -213,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

@@ -226,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
@@ -376,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
@@ -528,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
@@ -719,6 +761,26 @@ 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 });
@@ -1182,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') {

package/dist/lib/teams/worktree.js

@@ -8,7 +8,9 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { safeJoin } from '../paths.js';
 const execFileAsync = promisify(execFile);
+const WORKTREE_NAME_RE = /^[A-Za-z0-9_-]+$/;
 export async function isGitRepo(dir) {
     try {
         await execFileAsync('git', ['rev-parse', '--git-dir'], { cwd: dir });
@@ -42,8 +44,11 @@ export async function hasUncommittedChanges(worktreePath) {
  * @returns The absolute path to the created worktree
  */
 export async function createWorktree(repoDir, worktreeName) {
+    if (!WORKTREE_NAME_RE.test(worktreeName)) {
+        throw new Error(`Invalid worktree name: ${worktreeName}`);
+    }
     const gitRoot = await getGitRoot(repoDir);
-    const worktreePath = path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+    const worktreePath = safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
     const branchName = `agents/${worktreeName}`;
     await fs.mkdir(path.dirname(worktreePath), { recursive: true });
     await execFileAsync('git', ['worktree', 'add', '-b', branchName, worktreePath, 'HEAD'], {
@@ -59,8 +64,11 @@ export async function createWorktree(repoDir, worktreeName) {
  * @param deleteBranch - Whether to delete the associated branch
  */
 export async function removeWorktree(repoDir, worktreeName, deleteBranch = true) {
+    if (!WORKTREE_NAME_RE.test(worktreeName)) {
+        throw new Error(`Invalid worktree name: ${worktreeName}`);
+    }
     const gitRoot = await getGitRoot(repoDir);
-    const worktreePath = path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+    const worktreePath = safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
     const branchName = `agents/${worktreeName}`;
     try {
         await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: gitRoot });
@@ -86,7 +94,10 @@ export async function removeWorktree(repoDir, worktreeName, deleteBranch = true)
  * Get the worktree path for a given name.
  */
 export function getWorktreePath(gitRoot, worktreeName) {
-    return path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+    if (!WORKTREE_NAME_RE.test(worktreeName)) {
+        throw new Error(`Invalid worktree name: ${worktreeName}`);
+    }
+    return safeJoin(path.join(gitRoot, '.agents', 'worktrees'), worktreeName);
 }
 /**
  * Get the branch name for a worktree.

package/dist/lib/types.d.ts

@@ -203,9 +203,12 @@ export interface RegistryConfig {
 /** Built-in registry endpoints shipped with agents-cli. */
 export declare const DEFAULT_REGISTRIES: Record<RegistryType, Record<string, RegistryConfig>>;
 /**
- * Registries that ship pre-seeded into new users' agents.yaml once, but are
- * not "defaults" — after seeding they behave like any user-added registry
- * (listable, disable-able, removable, and gone for good once removed).
+ * Third-party registries pre-seeded on first install for discoverability.
+ *
+ * These ship into new users' agents.yaml once, but are not "defaults" — after
+ * seeding they behave like any user-added registry (listable, disable-able,
+ * removable). Removed users can `agents registry remove <name>` to opt out;
+ * once removed they don't come back.
  */
 export declare const SEEDED_REGISTRIES: Record<RegistryType, Record<string, RegistryConfig>>;
 /** A single installable package within an MCP server entry. */

package/dist/lib/types.js

@@ -22,9 +22,12 @@ export const DEFAULT_REGISTRIES = {
     skill: {},
 };
 /**
- * Registries that ship pre-seeded into new users' agents.yaml once, but are
- * not "defaults" — after seeding they behave like any user-added registry
- * (listable, disable-able, removable, and gone for good once removed).
+ * Third-party registries pre-seeded on first install for discoverability.
+ *
+ * These ship into new users' agents.yaml once, but are not "defaults" — after
+ * seeding they behave like any user-added registry (listable, disable-able,
+ * removable). Removed users can `agents registry remove <name>` to opt out;
+ * once removed they don't come back.
  */
 export const SEEDED_REGISTRIES = {
     mcp: {},