tide-commander 1.148.0 → 1.150.0

package/dist/src/packages/server/services/grok-usage-service.js

@@ -0,0 +1,374 @@
+/**
+ * Grok Usage Service
+ *
+ * Surfaces the same plan-limit gauges the Grok CLI's `/usage` command shows,
+ * using the CLI chat-proxy billing endpoints with the OAuth token in
+ * `~/.grok/auth.json`:
+ *
+ *   - `GET /v1/billing?format=credits` — subscription usage percent +
+ *     current weekly/monthly period (what the CLI logs as
+ *     "billing: fetched credits config")
+ *   - `GET /v1/billing` — calendar-month spend/credit allotment
+ *     (`used` / `monthlyLimit`) when the credits payload is weekly-only
+ *
+ * When both are available the snapshot exposes **weekly** and **monthly**
+ * gauges side-by-side, matching the terminal `/usage` panel.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('GrokUsage');
+const AUTH_PATH = path.join(os.homedir(), '.grok', 'auth.json');
+const DEFAULT_BILLING_BASE = 'https://cli-chat-proxy.grok.com/v1/billing';
+const BILLING_TIMEOUT_MS = 5_000;
+// Account-wide gauges — one cache line serves every Grok agent/client poll.
+const RATE_LIMIT_CACHE_TTL_MS = 60_000;
+const RATE_LIMIT_429_BACKOFF_MS = 5 * 60_000;
+const RATE_LIMIT_ERROR_BACKOFF_MS = 30_000;
+function billingBaseUrl() {
+    const base = process.env.GROK_CLI_CHAT_PROXY_BASE_URL?.trim();
+    if (base) {
+        return `${base.replace(/\/+$/, '')}/billing`;
+    }
+    return DEFAULT_BILLING_BASE;
+}
+function readGrokAccessToken() {
+    try {
+        if (!fs.existsSync(AUTH_PATH)) {
+            return { error: 'No Grok CLI credentials found — run `grok login`' };
+        }
+        const raw = JSON.parse(fs.readFileSync(AUTH_PATH, 'utf-8'));
+        // auth.json is keyed by issuer::client_id; pick the first entry with a token.
+        for (const entry of Object.values(raw)) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const token = entry.key;
+            if (typeof token !== 'string' || token === '')
+                continue;
+            const expiresRaw = entry.expires_at ?? entry.expiresAt;
+            if (typeof expiresRaw === 'string' || typeof expiresRaw === 'number') {
+                const expiresMs = typeof expiresRaw === 'number' ? expiresRaw : Date.parse(expiresRaw);
+                if (Number.isFinite(expiresMs) && expiresMs <= Date.now()) {
+                    return {
+                        error: 'Grok CLI OAuth token has expired — run `grok login` or any Grok session to refresh it',
+                    };
+                }
+            }
+            return { token };
+        }
+        return { error: 'Grok CLI credentials are missing an OAuth token' };
+    }
+    catch (err) {
+        log.warn(`Failed to read Grok credentials at ${AUTH_PATH}: ${err}`);
+        return { error: 'Failed to read Grok CLI credentials' };
+    }
+}
+function unwrapVal(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (value && typeof value === 'object' && 'val' in value) {
+        const inner = value.val;
+        if (typeof inner === 'number' && Number.isFinite(inner))
+            return inner;
+    }
+    return null;
+}
+function parseIso(value) {
+    if (typeof value !== 'string' || value.trim() === '')
+        return null;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, value));
+}
+/** Map API period type strings / date span → weekly | monthly | period. */
+export function classifyPeriodType(typeRaw, startIso, endIso) {
+    if (typeof typeRaw === 'string') {
+        const t = typeRaw.toUpperCase();
+        if (t.includes('WEEK'))
+            return 'weekly';
+        if (t.includes('MONTH'))
+            return 'monthly';
+    }
+    if (!startIso || !endIso)
+        return 'period';
+    const start = Date.parse(startIso);
+    const end = Date.parse(endIso);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start)
+        return 'period';
+    const days = (end - start) / (24 * 60 * 60 * 1000);
+    if (days >= 5 && days <= 10)
+        return 'weekly';
+    if (days >= 25 && days <= 35)
+        return 'monthly';
+    return 'period';
+}
+/** @deprecated use classifyPeriodType — kept for existing tests. */
+export function classifyBillingPeriod(startIso, endIso) {
+    return classifyPeriodType(null, startIso, endIso);
+}
+function parseRetryAfterMs(headerValue) {
+    if (!headerValue)
+        return undefined;
+    const seconds = Number(headerValue);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const dateMs = Date.parse(headerValue);
+    if (Number.isFinite(dateMs))
+        return Math.max(0, dateMs - Date.now());
+    return undefined;
+}
+async function fetchBillingJson(url, token) {
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+            'x-grok-client-version': '0.2.93',
+        },
+        signal: AbortSignal.timeout(BILLING_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        return {
+            ok: false,
+            status: response.status,
+            error: `Grok billing endpoint returned ${response.status}`,
+            retryAfterMs: parseRetryAfterMs(response.headers.get('retry-after')),
+        };
+    }
+    const body = (await response.json());
+    return {
+        ok: true,
+        status: response.status,
+        config: body?.config ?? {},
+        retryAfterMs: parseRetryAfterMs(response.headers.get('retry-after')),
+    };
+}
+/**
+ * Parse `/billing?format=credits` — the payload the CLI uses for the
+ * Weekly/Monthly percent gauges in `/usage`.
+ */
+export function parseCreditsConfig(config) {
+    let weekly = null;
+    let monthly = null;
+    let onDemand = null;
+    const percentRaw = config.creditUsagePercent;
+    const percent = typeof percentRaw === 'number' && Number.isFinite(percentRaw)
+        ? clampPercent(percentRaw)
+        : null;
+    const currentPeriod = config.currentPeriod && typeof config.currentPeriod === 'object'
+        ? config.currentPeriod
+        : null;
+    const periodStart = parseIso(currentPeriod?.start) ?? parseIso(config.billingPeriodStart);
+    const periodEnd = parseIso(currentPeriod?.end) ?? parseIso(config.billingPeriodEnd);
+    const kind = classifyPeriodType(currentPeriod?.type, periodStart, periodEnd);
+    if (percent != null && periodEnd) {
+        const window = {
+            utilization: percent,
+            resetsAt: periodEnd,
+        };
+        if (kind === 'weekly')
+            weekly = window;
+        else if (kind === 'monthly')
+            monthly = window;
+        else {
+            // Unknown period type — prefer weekly label when span is short-ish.
+            if (kind === 'period' && periodStart && periodEnd) {
+                const days = (Date.parse(periodEnd) - Date.parse(periodStart)) / (24 * 60 * 60 * 1000);
+                if (days <= 14)
+                    weekly = window;
+                else
+                    monthly = window;
+            }
+            else {
+                weekly = window;
+            }
+        }
+    }
+    // productUsage[] can carry per-product percents (e.g. GrokBuild) — prefer the
+    // primary creditUsagePercent above, but fall back if it was missing.
+    if (percent == null && Array.isArray(config.productUsage)) {
+        for (const entry of config.productUsage) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const p = entry.usagePercent;
+            if (typeof p === 'number' && Number.isFinite(p) && periodEnd) {
+                const window = {
+                    utilization: clampPercent(p),
+                    resetsAt: periodEnd,
+                };
+                if (kind === 'monthly')
+                    monthly = window;
+                else
+                    weekly = window;
+                break;
+            }
+        }
+    }
+    const onDemandCap = unwrapVal(config.onDemandCap);
+    const onDemandUsed = unwrapVal(config.onDemandUsed) ?? 0;
+    if (onDemandCap != null && onDemandCap > 0) {
+        onDemand = {
+            utilization: clampPercent((onDemandUsed / onDemandCap) * 100),
+            resetsAt: periodEnd ?? parseIso(config.billingPeriodEnd) ?? new Date().toISOString(),
+            used: onDemandUsed,
+            limit: onDemandCap,
+        };
+    }
+    return { weekly, monthly, onDemand };
+}
+/**
+ * Parse default `/billing` — absolute used/monthlyLimit spend-style cap.
+ * Used to fill the monthly gauge when the credits payload only has weekly.
+ */
+export function parseSpendConfig(config) {
+    const used = unwrapVal(config.used) ?? unwrapVal(config.includedUsed);
+    const limit = unwrapVal(config.monthlyLimit);
+    const periodEnd = parseIso(config.billingPeriodEnd);
+    if (used == null || limit == null || limit <= 0 || !periodEnd)
+        return null;
+    return {
+        utilization: clampPercent((used / limit) * 100),
+        resetsAt: periodEnd,
+        used,
+        limit,
+    };
+}
+/**
+ * Raw network calls to the CLI chat-proxy billing endpoints. Prefer
+ * `getGrokRateLimits()` which caches + single-flights.
+ */
+async function fetchGrokBillingFromApi() {
+    const creds = readGrokAccessToken();
+    if ('error' in creds) {
+        return { rateLimits: null, error: creds.error };
+    }
+    const base = billingBaseUrl();
+    try {
+        // Parallel: credits format (CLI /usage) + default spend allotment.
+        const [creditsResult, spendResult] = await Promise.all([
+            fetchBillingJson(`${base}?format=credits`, creds.token),
+            fetchBillingJson(base, creds.token),
+        ]);
+        // Prefer status/retry from credits (primary); fall back to spend.
+        if (!creditsResult.ok && !spendResult.ok) {
+            return {
+                rateLimits: null,
+                error: creditsResult.error,
+                status: creditsResult.status,
+                retryAfterMs: creditsResult.retryAfterMs ?? spendResult.retryAfterMs,
+            };
+        }
+        let weekly = null;
+        let monthly = null;
+        let onDemand = null;
+        if (creditsResult.ok) {
+            const parsed = parseCreditsConfig(creditsResult.config);
+            weekly = parsed.weekly;
+            monthly = parsed.monthly;
+            onDemand = parsed.onDemand;
+        }
+        // Fill monthly from spend allotment when credits only gave weekly (the
+        // SuperGrok dual-gauge layout in the CLI /usage panel).
+        if (spendResult.ok) {
+            const spendMonthly = parseSpendConfig(spendResult.config);
+            if (spendMonthly && !monthly) {
+                monthly = spendMonthly;
+            }
+            // On-demand may only appear on the default payload.
+            if (!onDemand) {
+                const onDemandCap = unwrapVal(spendResult.config.onDemandCap);
+                const onDemandUsed = unwrapVal(spendResult.config.onDemandUsed) ?? 0;
+                const periodEnd = parseIso(spendResult.config.billingPeriodEnd);
+                if (onDemandCap != null && onDemandCap > 0 && periodEnd) {
+                    onDemand = {
+                        utilization: clampPercent((onDemandUsed / onDemandCap) * 100),
+                        resetsAt: periodEnd,
+                        used: onDemandUsed,
+                        limit: onDemandCap,
+                    };
+                }
+            }
+        }
+        if (!weekly && !monthly && !onDemand) {
+            return {
+                rateLimits: null,
+                error: creditsResult.ok
+                    ? 'Grok billing response had no usable usage limits'
+                    : creditsResult.error,
+                status: creditsResult.ok ? creditsResult.status : creditsResult.status,
+            };
+        }
+        return {
+            rateLimits: { weekly, monthly, onDemand },
+            error: null,
+            status: creditsResult.ok ? creditsResult.status : spendResult.status,
+        };
+    }
+    catch (err) {
+        log.warn(`Failed to fetch Grok billing: ${err}`);
+        const reason = err?.name === 'TimeoutError' ? 'request timed out' : (err?.message ?? 'request failed');
+        return { rateLimits: null, error: `Could not reach Grok billing endpoint (${reason})` };
+    }
+}
+let rateLimitCache = null;
+let lastGoodRateLimits = null;
+let rateLimitInFlight = null;
+async function getGrokRateLimits() {
+    const now = Date.now();
+    if (rateLimitCache && now < rateLimitCache.validUntil) {
+        return { rateLimits: rateLimitCache.rateLimits, error: rateLimitCache.error };
+    }
+    if (rateLimitInFlight)
+        return rateLimitInFlight;
+    rateLimitInFlight = (async () => {
+        const result = await fetchGrokBillingFromApi();
+        let ttl = RATE_LIMIT_CACHE_TTL_MS;
+        if (result.rateLimits) {
+            lastGoodRateLimits = result.rateLimits;
+        }
+        else if (result.status === 429) {
+            ttl = Math.max(result.retryAfterMs ?? RATE_LIMIT_429_BACKOFF_MS, RATE_LIMIT_CACHE_TTL_MS);
+        }
+        else {
+            ttl = RATE_LIMIT_ERROR_BACKOFF_MS;
+        }
+        const entry = {
+            rateLimits: result.rateLimits ?? lastGoodRateLimits,
+            error: result.error,
+            validUntil: Date.now() + ttl,
+        };
+        rateLimitCache = entry;
+        return { rateLimits: entry.rateLimits, error: entry.error };
+    })();
+    try {
+        return await rateLimitInFlight;
+    }
+    finally {
+        rateLimitInFlight = null;
+    }
+}
+/** Test helper: drop the cached billing result and backoff state. */
+export function resetGrokRateLimitCache() {
+    rateLimitCache = null;
+    lastGoodRateLimits = null;
+    rateLimitInFlight = null;
+}
+export async function buildGrokUsageSnapshot(agent) {
+    const { rateLimits, error: rateLimitsError } = await getGrokRateLimits();
+    return {
+        provider: 'grok',
+        fetchedAt: Date.now(),
+        session: {
+            tokensUsed: agent.tokensUsed ?? 0,
+            contextUsed: agent.contextUsed ?? 0,
+            contextLimit: agent.contextLimit ?? 500_000,
+            taskCount: agent.taskCount ?? 0,
+            lastActivity: agent.lastActivity ?? 0,
+        },
+        rateLimits,
+        rateLimitsError,
+        cliHint: "Run /usage inside this agent's terminal to see live weekly and monthly usage limits.",
+    };
+}

package/dist/src/packages/server/services/runtime-command-execution.js

@@ -57,8 +57,10 @@ export function createRuntimeCommandExecution(deps) {
                 ? agentService.sanitizeModelForProvider(agent.provider, agent.model)
                 : agent.provider === 'opencode'
                     ? agentService.sanitizeOpencodeModel(agent.opencodeModel)
-                    : agentService.sanitizeCodexModel(agent.codexModel),
-            effort: agent.provider === 'claude' ? agent.effort : undefined,
+                    : agent.provider === 'grok'
+                        ? agentService.sanitizeGrokModel(agent.grokModel)
+                        : agentService.sanitizeCodexModel(agent.codexModel),
+            effort: agent.provider === 'claude' || agent.provider === 'grok' ? agent.effort : undefined,
             useChrome: agent.useChrome,
             permissionMode: agent.permissionMode,
             codexConfig: agent.codexConfig,

package/dist/src/packages/server/services/runtime-events.js

@@ -4,6 +4,8 @@ import { clearPendingSilentContextRefresh, consumeStepCompleteReceived, markStep
 import { addPendingBackgroundTask, clearPendingBackgroundTasks, getActiveSubagentByToolUseId, handleTaskToolResult, handleTaskToolStart, hasPendingBackgroundTasks, resolvePendingBackgroundTask, resolvePendingBackgroundTaskByTaskId, } from './runtime-subagents.js';
 const DEFAULT_CLAUDE_CONTEXT_WINDOW = 200000;
 const DEFAULT_CODEX_CONTEXT_WINDOW = 258400;
+/** Practical Grok Build window observed in session signals.json (model catalog may list 2M). */
+const DEFAULT_GROK_CONTEXT_WINDOW = 500000;
 const CODEX_ROLLING_CONTEXT_TURNS = 40;
 const CODEX_PLAUSIBLE_USAGE_MULTIPLIER = 1.2;
 const CODEX_RECOVERABLE_RESUME_ERRORS = [
@@ -41,6 +43,8 @@ function getDefaultContextWindow(provider) {
         return DEFAULT_CODEX_CONTEXT_WINDOW;
     if (provider === 'opencode')
         return DEFAULT_CLAUDE_CONTEXT_WINDOW;
+    if (provider === 'grok')
+        return DEFAULT_GROK_CONTEXT_WINDOW;
     return DEFAULT_CLAUDE_CONTEXT_WINDOW;
 }
 function updateCodexRollingContextEstimate(agentId, turnGrowth) {
@@ -232,21 +236,28 @@ export function createRuntimeEventHandlers(deps) {
                 // Real-time context tracking from streaming usage data.
                 // Context window usage = input tokens only (output tokens don't count toward the limit).
                 // total_input = cache_read + cache_creation + input_tokens (the full prompt size).
+                // Grok: session-watcher maps signals.json contextTokensUsed → tokens.input.
                 if (event.tokens) {
                     const isClaudeProvider = (agent.provider ?? 'claude') === 'claude';
                     const isOpencodeProvider = (agent.provider ?? 'claude') === 'opencode';
-                    if (isClaudeProvider || isOpencodeProvider) {
+                    const isGrokProvider = (agent.provider ?? 'claude') === 'grok';
+                    if (isClaudeProvider || isOpencodeProvider || isGrokProvider) {
                         const cacheRead = event.tokens.cacheRead || 0;
                         const cacheCreation = event.tokens.cacheCreation || 0;
                         const inputTokens = event.tokens.input || 0;
                         // Context window = input side only (system prompt + tools + messages).
                         // Output tokens are the model's response and don't count toward the limit.
+                        // For Grok, inputTokens is already the full context fill from signals.json.
                         const snapshotContextUsed = cacheRead + cacheCreation + inputTokens;
                         if (snapshotContextUsed > 0) {
-                            const effectiveLimit = agent.contextLimit || getDefaultContextWindow(agent.provider);
+                            // Grok signals also carry the authoritative window size.
+                            const modelWindow = event.modelUsage?.contextWindow;
+                            const effectiveLimit = Math.max(1, modelWindow || agent.contextLimit || getDefaultContextWindow(agent.provider));
                             // Guard against cumulative session totals: if the sum exceeds the
                             // context window, it can't represent per-request context fill.
-                            if (snapshotContextUsed > effectiveLimit) {
+                            // Grok signals can report used slightly over window during compaction —
+                            // clamp instead of skip so the bar still moves.
+                            if (snapshotContextUsed > effectiveLimit && !isGrokProvider) {
                                 log.log(`[usage_snapshot] ${agentId}: sum ${snapshotContextUsed} exceeds limit ${effectiveLimit} (likely cumulative); skipping`);
                                 // If the agent's existing contextUsed is also stale (exceeds limit),
                                 // reset it to 0 so the UI doesn't keep showing an impossible value.
@@ -256,9 +267,10 @@ export function createRuntimeEventHandlers(deps) {
                                 }
                             }
                             else {
-                                const safeContextUsed = Math.max(0, snapshotContextUsed);
+                                const safeContextUsed = Math.max(0, Math.min(snapshotContextUsed, effectiveLimit));
                                 const updates = {
                                     contextUsed: safeContextUsed,
+                                    contextLimit: effectiveLimit,
                                 };
                                 // Always keep contextStats.totalTokens in sync with contextUsed.
                                 // If authoritative stats exist (from /context), merge the new total
@@ -267,10 +279,23 @@ export function createRuntimeEventHandlers(deps) {
                                     updates.contextStats = updateContextStatsTokens(agent.contextStats, safeContextUsed, effectiveLimit);
                                 }
                                 else {
-                                    updates.contextStats = buildEstimatedContextStats(safeContextUsed, effectiveLimit, isClaudeProvider ? (agent.model || 'claude') : (agent.opencodeModel || 'opencode'));
+                                    const modelLabel = isClaudeProvider
+                                        ? (agent.model || 'claude')
+                                        : isOpencodeProvider
+                                            ? (agent.opencodeModel || 'opencode')
+                                            : (agent.grokModel || 'grok');
+                                    updates.contextStats = buildEstimatedContextStats(safeContextUsed, effectiveLimit, modelLabel);
+                                }
+                                // Lifetime tokensUsed: for Grok we don't get per-turn usage, so
+                                // keep the high-water mark of context fill as a lower bound on work done.
+                                if (isGrokProvider) {
+                                    const prev = agent.tokensUsed || 0;
+                                    if (safeContextUsed > prev) {
+                                        updates.tokensUsed = safeContextUsed;
+                                    }
                                 }
                                 agentService.updateAgent(agentId, updates, false);
-                                log.log(`[usage_snapshot] ${agentId}: input=${inputTokens} + cacheRead=${cacheRead} + cacheCreation=${cacheCreation} = ${snapshotContextUsed} (output=${event.tokens.output || 0}) limit=${effectiveLimit}`);
+                                log.log(`[usage_snapshot] ${agentId}: input=${inputTokens} + cacheRead=${cacheRead} + cacheCreation=${cacheCreation} = ${snapshotContextUsed} (output=${event.tokens.output || 0}) limit=${effectiveLimit}${isGrokProvider ? ' [grok]' : ''}`);
                             }
                         }
                     }
@@ -295,6 +320,7 @@ export function createRuntimeEventHandlers(deps) {
                 const isClaudeProvider = (agent.provider ?? 'claude') === 'claude';
                 const isCodexProvider = (agent.provider ?? 'claude') === 'codex';
                 const isOpencodeProvider = (agent.provider ?? 'claude') === 'opencode';
+                const isGrokProviderStep = (agent.provider ?? 'claude') === 'grok';
                 const lastTask = agent.lastAssignedTask?.trim() || '';
                 const isContextCommand = lastTask === '/context' || lastTask === '/cost' || lastTask === '/compact';
                 let contextUsed = agent.contextUsed || 0;
@@ -326,6 +352,16 @@ export function createRuntimeEventHandlers(deps) {
                     contextLimit = agent.contextLimit || getDefaultContextWindow('opencode');
                     log.log(`[step_complete] OpenCode agent ${agentId}: preserving usage_snapshot contextUsed=${contextUsed}, contextLimit=${contextLimit}`);
                 }
+                else if (isGrokProviderStep) {
+                    // Grok: streaming-json has no usage; session-watcher feeds usage_snapshot
+                    // from signals.json. Preserve those values on step_complete.
+                    contextUsed = agent.contextUsed || 0;
+                    contextLimit = agent.contextLimit || getDefaultContextWindow('grok');
+                    if (hasModelUsageData && event.modelUsage?.contextWindow) {
+                        contextLimit = event.modelUsage.contextWindow;
+                    }
+                    log.log(`[step_complete] Grok agent ${agentId}: preserving signals usage_snapshot contextUsed=${contextUsed}, contextLimit=${contextLimit}`);
+                }
                 else if (hasModelUsageData && event.modelUsage) {
                     const inputTokens = event.modelUsage.inputTokens || 0;
                     const outputTokens = event.modelUsage.outputTokens || 0;
@@ -389,13 +425,16 @@ export function createRuntimeEventHandlers(deps) {
                 // Always keep contextStats in sync. If authoritative stats exist (from
                 // /context), merge the updated totalTokens while preserving category
                 // breakdowns. Otherwise build fresh estimated stats.
+                const isGrokProvider = (agent.provider ?? 'claude') === 'grok';
                 const modelForStats = isClaudeProvider
                     ? (agent.model || 'claude')
                     : isCodexProvider
                         ? (agent.codexModel || agent.model)
                         : isOpencodeProvider
                             ? (agent.opencodeModel || 'opencode')
-                            : (agent.model || 'unknown');
+                            : isGrokProvider
+                                ? (agent.grokModel || 'grok')
+                                : (agent.model || 'unknown');
                 if (agent.contextStats && agent.contextStats.lastUpdated) {
                     updates.contextStats = updateContextStatsTokens(agent.contextStats, Math.max(0, Math.round(contextUsed)), Math.max(1, Math.round(contextLimit)));
                 }

package/dist/src/packages/server/services/runtime-service.js

@@ -2,11 +2,11 @@
  * Runtime Service
  * Manages Claude/Codex runtime runners and command execution
  */
-import { isClaudeProcessRunningInCwd, isCodexProcessRunningInCwd, isOpencodeProcessRunningInCwd, killClaudeProcessInCwd, killCodexProcessInCwd, killOpencodeProcessInCwd, findClaudeProcessPidInCwd, findCodexProcessPidInCwd, findOpencodeProcessPidInCwd, } from '../claude/session-loader.js';
+import { isClaudeProcessRunningInCwd, isCodexProcessRunningInCwd, isOpencodeProcessRunningInCwd, isGrokProcessRunningInCwd, killClaudeProcessInCwd, killCodexProcessInCwd, killOpencodeProcessInCwd, killGrokProcessInCwd, findClaudeProcessPidInCwd, findCodexProcessPidInCwd, findOpencodeProcessPidInCwd, findGrokProcessPidInCwd, } from '../claude/session-loader.js';
 import * as agentService from './agent-service.js';
 import { loadRunningProcesses, isProcessRunning } from '../data/index.js';
 import { logger } from '../utils/logger.js';
-import { createClaudeRuntimeProvider, createCodexRuntimeProvider, createOpencodeRuntimeProvider, } from '../runtime/index.js';
+import { createClaudeRuntimeProvider, createCodexRuntimeProvider, createOpencodeRuntimeProvider, createGrokRuntimeProvider, } from '../runtime/index.js';
 import { createRuntimeCommandExecution, } from './runtime-command-execution.js';
 import { createRuntimeEventHandlers } from './runtime-events.js';
 import { createRuntimeStatusSync } from './runtime-status-sync.js';
@@ -18,6 +18,7 @@ const runtimeProviders = {
     claude: createClaudeRuntimeProvider(),
     codex: createCodexRuntimeProvider(),
     opencode: createOpencodeRuntimeProvider(),
+    grok: createGrokRuntimeProvider(),
 };
 const runners = new Map();
 function getRunner(provider) {
@@ -55,6 +56,9 @@ async function isProviderProcessRunningInCwd(provider, cwd) {
     if (provider === 'opencode') {
         return isOpencodeProcessRunningInCwd(cwd);
     }
+    if (provider === 'grok') {
+        return isGrokProcessRunningInCwd(cwd);
+    }
     return isClaudeProcessRunningInCwd(cwd);
 }
 async function killDetachedProviderProcessInCwd(provider, cwd) {
@@ -64,6 +68,9 @@ async function killDetachedProviderProcessInCwd(provider, cwd) {
     if (provider === 'opencode') {
         return killOpencodeProcessInCwd(cwd);
     }
+    if (provider === 'grok') {
+        return killGrokProcessInCwd(cwd);
+    }
     return killClaudeProcessInCwd(cwd);
 }
 export function on(event, listener) {
@@ -147,6 +154,13 @@ export function init() {
         onComplete: runtimeEvents.handleComplete,
         onError: runtimeEvents.handleError,
     }));
+    runners.set('grok', runtimeProviders.grok.createRunner({
+        onEvent: runtimeEvents.handleEvent,
+        onOutput: runtimeEvents.handleOutput,
+        onSessionId: runtimeEvents.handleSessionId,
+        onComplete: runtimeEvents.handleComplete,
+        onError: runtimeEvents.handleError,
+    }));
     // Start each runner's background work (orphan recovery, persist timer,
     // watchdog). The constructor is now side-effect-free so non-canonical
     // contexts (tests, scripts, sidecars) that import the runner code don't
@@ -280,7 +294,9 @@ export async function getAgentRuntimeProcessInfo(agentId) {
             ? await findCodexProcessPidInCwd(agent.cwd)
             : provider === 'opencode'
                 ? await findOpencodeProcessPidInCwd(agent.cwd)
-                : await findClaudeProcessPidInCwd(agent.cwd);
+                : provider === 'grok'
+                    ? await findGrokProcessPidInCwd(agent.cwd)
+                    : await findClaudeProcessPidInCwd(agent.cwd);
         if (discoveredPid && isProcessRunning(discoveredPid)) {
             return {
                 pid: discoveredPid,

package/dist/src/packages/server/utils/tool-formatting.js

@@ -28,32 +28,60 @@ export function getShortPath(filePath, maxLen = 40) {
  */
 export function getToolKeyParam(toolName, input) {
     switch (toolName) {
-        case 'WebSearch':
-            return truncate(input.query, 50);
-        case 'WebFetch':
-            return truncate(input.url, 60);
+        case 'WebSearch': {
+            const query = (input.query || input.q || input.search);
+            return query ? `"${truncate(query, 40)}"` : null;
+        }
+        case 'WebFetch': {
+            const url = (input.url || input.target_url || input.targetUrl);
+            return url ? truncate(url, 60) : null;
+        }
         case 'Read':
         case 'Write':
-        case 'Edit':
-            const filePath = (input.file_path || input.path);
+        case 'Edit': {
+            // Claude: file_path; Grok: target_file
+            const filePath = (input.file_path
+                || input.filePath
+                || input.target_file
+                || input.targetFile
+                || input.path);
             return getShortPath(filePath);
+        }
+        case 'ListFiles':
+        case 'list_dir': {
+            const dir = (input.target_directory
+                || input.targetDirectory
+                || input.path
+                || input.directory);
+            return getShortPath(dir);
+        }
         case 'Bash':
-            const cmd = input.command;
-            return cmd ? truncate(cmd, 60) : null;
+        case 'ExecuteCommand': {
+            const cmd = (input.command || input.cmd);
+            if (cmd)
+                return truncate(cmd, 60);
+            const desc = input.description;
+            return desc ? truncate(desc, 60) : null;
+        }
         case 'Grep':
-            return input.pattern ? `"${truncate(input.pattern, 40)}"` : null;
+        case 'SearchFiles': {
+            const pattern = (input.pattern || input.query);
+            return pattern ? `"${truncate(pattern, 40)}"` : null;
+        }
         case 'Glob':
-            return truncate(input.pattern, 50);
+            return truncate((input.pattern || input.glob), 50);
         case 'Task':
+        case 'Agent':
             return truncate(input.description, 50);
-        case 'TodoWrite':
+        case 'TodoWrite': {
             const todos = input.todos;
             if (todos?.length) {
                 return `${todos.length} item${todos.length > 1 ? 's' : ''}`;
             }
             return null;
+        }
         case 'NotebookEdit':
-            return getFileName(input.notebook_path);
+            return getFileName((input.notebook_path || input.notebookPath || input.target_file || input.file_path));
         case 'AskUserQuestion':
             return 'clarification';
         default: