tide-commander 1.147.1 → 1.149.0

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

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { CLAUDE_MODELS as CLAUDE_MODEL_METADATA } from '../../shared/agent-types.js';
+import { CLAUDE_MODELS as CLAUDE_MODEL_METADATA, GROK_MODELS, DEFAULT_GROK_MODEL } from '../../shared/agent-types.js';
 import { loadAgents, saveAgents, saveAgentsAsync, getDataDir, loadAreas, saveAreas, loadSessionHistory, saveSessionHistory, addSessionHistoryEntry, getSessionHistoryForAgent } from '../data/index.js';
 import { listSessions, getSessionSummary, getProjectDir, loadSession, loadToolHistory, searchSession, } from '../claude/session-loader.js';
 import { loadSubagentHistory } from '../claude/subagent-history-loader.js';
@@ -16,11 +16,19 @@ const VALID_CLAUDE_MODELS = new Set(Object.keys(CLAUDE_MODEL_METADATA));
 const DEFAULT_CLAUDE_CONTEXT_LIMIT = 200000;
 const DEFAULT_CODEX_CONTEXT_LIMIT = 258400;
 const DEFAULT_OPENCODE_CONTEXT_LIMIT = 200000;
-function getDefaultContextLimit(provider, model) {
+/** Matches live Grok Build signals.json contextWindowTokens (catalog may list 2M). */
+const DEFAULT_GROK_CONTEXT_LIMIT = 500000;
+function getDefaultContextLimit(provider, model, grokModel) {
     if (provider === 'codex')
         return DEFAULT_CODEX_CONTEXT_LIMIT;
     if (provider === 'opencode')
         return DEFAULT_OPENCODE_CONTEXT_LIMIT;
+    if (provider === 'grok') {
+        if (grokModel && GROK_MODELS[grokModel]?.contextWindow) {
+            return GROK_MODELS[grokModel].contextWindow;
+        }
+        return DEFAULT_GROK_CONTEXT_LIMIT;
+    }
     if (model && CLAUDE_MODEL_METADATA[model]) {
         return CLAUDE_MODEL_METADATA[model].contextWindow;
     }
@@ -61,6 +69,12 @@ export function sanitizeOpencodeModel(model) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+export function sanitizeGrokModel(model) {
+    if (typeof model !== 'string')
+        return undefined;
+    const trimmed = model.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 function findFileRecursively(rootDir, pattern) {
     if (!fs.existsSync(rootDir))
         return null;
@@ -215,6 +229,7 @@ export function initAgents() {
                 codexModel: sanitizeCodexModel(stored.codexModel),
                 codexConfig: stored.codexConfig,
                 opencodeModel: sanitizeOpencodeModel(stored.opencodeModel),
+                grokModel: sanitizeGrokModel(stored.grokModel),
                 // Boss field - fallback to checking class for backward compatibility
                 isBoss: stored.isBoss ?? stored.class === 'boss',
             };
@@ -278,7 +293,7 @@ export function getAgent(id) {
 export function getAllAgents() {
     return Array.from(agents.values());
 }
-export async function createAgent(name, agentClass, cwd, position, sessionId, useChrome, permissionMode = 'bypass', initialSkillIds, isBoss, model, codexModel, customInstructions, provider = 'claude', codexConfig, effort, opencodeModel) {
+export async function createAgent(name, agentClass, cwd, position, sessionId, useChrome, permissionMode = 'bypass', initialSkillIds, isBoss, model, codexModel, customInstructions, provider = 'claude', codexConfig, effort, opencodeModel, grokModel) {
     log.log('🎆 [CREATE_AGENT] Starting agent creation:', {
         name,
         agentClass,
@@ -290,6 +305,8 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         model,
         codexModel,
         codexConfig,
+        opencodeModel,
+        grokModel,
         customInstructions: customInstructions ? `${customInstructions.length} chars` : undefined,
     });
     const id = generateId();
@@ -301,6 +318,9 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         throw new Error(`Directory does not exist: ${cwd}`);
     }
     log.log(`  ✅ Directory exists`);
+    const sanitizedGrokModel = provider === 'grok'
+        ? (sanitizeGrokModel(grokModel) || DEFAULT_GROK_MODEL)
+        : undefined;
     // Create agent object
     // SessionId can be provided to link to an existing Claude session
     const agent = {
@@ -318,13 +338,14 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         useChrome,
         permissionMode,
         model: sanitizeModelForProvider(provider, model),
-        effort: provider === 'claude' ? effort : undefined,
+        effort: provider === 'claude' || provider === 'grok' ? effort : undefined,
         codexModel: provider === 'codex' ? sanitizeCodexModel(codexModel) : undefined,
         codexConfig,
         opencodeModel: provider === 'opencode' ? sanitizeOpencodeModel(opencodeModel) : undefined,
+        grokModel: sanitizedGrokModel,
         tokensUsed: 0,
         contextUsed: 0,
-        contextLimit: getDefaultContextLimit(provider, sanitizeModelForProvider(provider, model)),
+        contextLimit: getDefaultContextLimit(provider, sanitizeModelForProvider(provider, model), sanitizedGrokModel),
         taskCount: 0, // Initialize task counter
         createdAt: Date.now(),
         lastActivity: Date.now(),

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:

package/dist/src/packages/server/websocket/handlers/agent-handler.js

@@ -9,6 +9,7 @@ import { agentService, runtimeService, skillService, customClassService, bossSer
 import { markInstructionsDirty } from '../../services/instruction-refresh.js';
 import { createLogger } from '../../utils/index.js';
 import { ClaudeBackend, parseContextOutput } from '../../claude/backend.js';
+import { getGrokSessionDir, readGrokSignalsUsage } from '../../grok/session-watcher.js';
 const log = createLogger('AgentHandler');
 const claudeBackend = new ClaudeBackend();
 // Test change: Server restart validation - if you see this log, the server restarted successfully
@@ -58,12 +59,14 @@ export async function handleSpawnAgent(ctx, payload) {
         position: payload.position,
         initialSkillIds: payload.initialSkillIds,
         model: payload.model,
+        opencodeModel: payload.opencodeModel,
+        grokModel: payload.grokModel,
         customInstructions: payload.customInstructions ? `${payload.customInstructions.length} chars` : undefined,
     });
     try {
         const agent = await agentService.createAgent(payload.name, payload.class, payload.cwd, payload.position, payload.sessionId, payload.useChrome, payload.permissionMode, undefined, // initialSkillIds handled separately below
         undefined, // isBoss
-        payload.model, payload.codexModel, payload.customInstructions, payload.provider, payload.codexConfig, payload.effort);
+        payload.model, payload.codexModel, payload.customInstructions, payload.provider, payload.codexConfig, payload.effort, payload.opencodeModel, payload.grokModel);
         log.log('Agent created successfully:', {
             id: agent.id,
             name: agent.name,
@@ -119,7 +122,7 @@ async function duplicateAgentConfig(source, name, position) {
         .map((skill) => skill.id);
     const agent = await agentService.createAgent(name, source.class, source.cwd, position, undefined, // sessionId - never share the source's; clone=fresh, fork=set below
     source.useChrome, source.permissionMode, undefined, // initialSkillIds handled separately below
-    source.isBoss, source.model, source.codexModel, source.customInstructions, source.provider, source.codexConfig, source.effort, source.opencodeModel);
+    source.isBoss, source.model, source.codexModel, source.customInstructions, source.provider, source.codexConfig, source.effort, source.opencodeModel, source.grokModel);
     // Re-apply skills: copied direct assignments + class defaults.
     const classDefaultSkills = customClassService.getClassDefaultSkillIds(agent.class);
     const allSkillIds = [...new Set([...directSkillIds, ...classDefaultSkills])];
@@ -135,7 +138,7 @@ function duplicateOffset(source) {
 // Providers whose conversation history can be forked (resume + native fork flag).
 // Codex is intentionally excluded for now (no headless fork; would need rollout
 // duplication) — forking a Codex agent gracefully degrades to a plain clone.
-const FORKABLE_PROVIDERS = new Set(['claude', 'opencode']);
+const FORKABLE_PROVIDERS = new Set(['claude', 'opencode', 'grok']);
 /**
  * Handle clone_agent message - duplicates an existing agent's configuration
  * into a brand-new agent (fresh session, no inherited context/memory).
@@ -614,8 +617,11 @@ function buildStatsFromTrackedData(agent) {
     // Do NOT prefer agent.contextStats here — those can become stale when previous
     // fallback calls save their (potentially wrong) output back to agent.contextStats
     // via broadcastContextStats, creating a self-reinforcing feedback loop.
-    const defaultContextLimit = (agent.provider ?? 'claude') === 'codex' ? 258400
-        : (agent.provider ?? 'claude') === 'opencode' ? 200000 : 200000;
+    const provider = agent.provider ?? 'claude';
+    const defaultContextLimit = provider === 'codex' ? 258400
+        : provider === 'opencode' ? 200000
+            : provider === 'grok' ? 500000
+                : 200000;
     const contextLimit = Math.max(1, Math.round(agent.contextLimit || defaultContextLimit));
     const rawContextUsed = Math.max(0, Math.round(agent.contextUsed || 0));
     // Guard: contextUsed can never exceed contextLimit. Values above the limit are
@@ -629,7 +635,7 @@ function buildStatsFromTrackedData(agent) {
     }
     const usedPercent = Math.min(100, Math.round((contextUsed / contextLimit) * 100));
     const freeTokens = Math.max(0, contextLimit - contextUsed);
-    const model = agent.model || agent.codexModel || agent.opencodeModel || 'unknown';
+    const model = agent.model || agent.codexModel || agent.opencodeModel || agent.grokModel || 'unknown';
     return {
         model,
         contextWindow: contextLimit,
@@ -748,12 +754,47 @@ export async function handleRequestContextStats(ctx, payload) {
             return;
         }
     }
+    // Grok: streaming-json has no usage events. Read signals.json from the session dir.
+    const isGrokProvider = (agent.provider ?? 'claude') === 'grok';
+    if (isGrokProvider && agent.sessionId && agent.cwd) {
+        try {
+            const sessionDir = getGrokSessionDir(agent.cwd, agent.sessionId);
+            const usage = readGrokSignalsUsage(sessionDir);
+            if (usage) {
+                const contextLimit = Math.max(1, usage.contextWindowTokens);
+                const contextUsed = Math.max(0, Math.min(usage.contextTokensUsed, contextLimit));
+                const usedPercent = Math.min(100, Math.round(usage.contextWindowUsage ?? (contextUsed / contextLimit) * 100));
+                const freeTokens = Math.max(0, contextLimit - contextUsed);
+                const stats = {
+                    model: agent.grokModel || agent.model || 'grok',
+                    contextWindow: contextLimit,
+                    totalTokens: contextUsed,
+                    usedPercent,
+                    categories: {
+                        systemPrompt: { tokens: 0, percent: 0 },
+                        systemTools: { tokens: 0, percent: 0 },
+                        messages: { tokens: contextUsed, percent: Number(((contextUsed / contextLimit) * 100).toFixed(1)) },
+                        freeSpace: { tokens: freeTokens, percent: Number(((freeTokens / contextLimit) * 100).toFixed(1)) },
+                        autocompactBuffer: { tokens: 0, percent: 0 },
+                    },
+                    lastUpdated: Date.now(),
+                };
+                log.log(`[contextStats] Grok signals.json for ${agent.name}: ${contextUsed}/${contextLimit}`);
+                broadcastContextStats(ctx, payload.agentId, stats, 'from Grok signals.json');
+                return;
+            }
+            log.warn(`[contextStats] Grok signals.json missing/unreadable for ${agent.name} session=${agent.sessionId}`);
+        }
+        catch (err) {
+            log.error(`[contextStats] Grok signals read failed: ${err}`);
+        }
+    }
     // Fallback: generate from tracked data
     const latestAgent = agentService.getAgent(payload.agentId) || agent;
     const stats = buildStatsFromTrackedData(latestAgent);
-    const label = latestAgent.provider === 'codex' ? 'estimated from turn usage'
-        : latestAgent.provider === 'opencode' ? 'estimated from turn usage'
-            : 'tracked from token usage';
+    const label = latestAgent.provider === 'codex' || latestAgent.provider === 'opencode' || latestAgent.provider === 'grok'
+        ? 'estimated from turn usage'
+        : 'tracked from token usage';
     broadcastContextStats(ctx, payload.agentId, stats, label);
 }
 /**
@@ -813,10 +854,14 @@ export async function handleUpdateAgentProperties(ctx, payload) {
     const normalizedUpdatedOpencodeModel = updates.opencodeModel !== undefined
         ? agentService.sanitizeOpencodeModel(updates.opencodeModel)
         : undefined;
+    const normalizedUpdatedGrokModel = updates.grokModel !== undefined
+        ? agentService.sanitizeGrokModel(updates.grokModel)
+        : undefined;
     // Track if model changed (requires hot restart to apply new model while preserving context)
     const modelChanged = updates.model !== undefined && normalizedUpdatedModel !== agent.model;
     const codexModelChanged = updates.codexModel !== undefined && normalizedUpdatedCodexModel !== agent.codexModel;
     const opencodeModelChanged = updates.opencodeModel !== undefined && normalizedUpdatedOpencodeModel !== agent.opencodeModel;
+    const grokModelChanged = updates.grokModel !== undefined && normalizedUpdatedGrokModel !== agent.grokModel;
     const providerChanged = updates.provider !== undefined && updates.provider !== agent.provider;
     const classChanged = updates.class !== undefined && updates.class !== agent.class;
     const codexConfigChanged = updates.codexConfig !== undefined
@@ -878,6 +923,9 @@ export async function handleUpdateAgentProperties(ctx, payload) {
     if (updates.opencodeModel !== undefined) {
         agentUpdates.opencodeModel = normalizedUpdatedOpencodeModel;
     }
+    if (updates.grokModel !== undefined) {
+        agentUpdates.grokModel = normalizedUpdatedGrokModel;
+    }
     if (updates.effort !== undefined) {
         agentUpdates.effort = updates.effort;
     }
@@ -920,7 +968,8 @@ export async function handleUpdateAgentProperties(ctx, payload) {
     }
     // If model changed, do a hot restart: stop process, resume with new model
     // This preserves context by using --resume with the existing sessionId
-    if ((modelChanged || codexModelChanged || opencodeModelChanged || providerChanged || codexConfigChanged || classChanged) && sessionId) {
+    const modelLikeChanged = modelChanged || codexModelChanged || opencodeModelChanged || grokModelChanged || providerChanged || codexConfigChanged || classChanged;
+    if (modelLikeChanged && sessionId) {
         const reason = providerChanged
             ? `runtime changed to ${updates.provider}`
             : classChanged
@@ -931,7 +980,9 @@ export async function handleUpdateAgentProperties(ctx, payload) {
                         ? `Codex model changed to ${updates.codexModel}`
                         : opencodeModelChanged
                             ? `OpenCode model changed to ${updates.opencodeModel}`
-                            : `model changed to ${updates.model}`;
+                            : grokModelChanged
+                                ? `Grok model changed to ${updates.grokModel}`
+                                : `model changed to ${updates.model}`;
         log.log(`Agent ${agent.name}: ${reason}, hot restarting with --resume to preserve context`);
         try {
             await runtimeService.stopAgent(agentId);
@@ -946,7 +997,7 @@ export async function handleUpdateAgentProperties(ctx, payload) {
             log.error(`Failed to hot restart agent ${agent.name} after runtime config change:`, err);
         }
     }
-    else if ((modelChanged || codexModelChanged || opencodeModelChanged || providerChanged || codexConfigChanged || classChanged) && !sessionId) {
+    else if (modelLikeChanged && !sessionId) {
         const reason = providerChanged
             ? `runtime changed to ${updates.provider}`
             : classChanged
@@ -957,12 +1008,14 @@ export async function handleUpdateAgentProperties(ctx, payload) {
                         ? `Codex model changed to ${updates.codexModel}`
                         : opencodeModelChanged
                             ? `OpenCode model changed to ${updates.opencodeModel}`
-                            : `model changed to ${updates.model}`;
+                            : grokModelChanged
+                                ? `Grok model changed to ${updates.grokModel}`
+                                : `model changed to ${updates.model}`;
         log.log(`Agent ${agent.name}: ${reason}, will apply on next session start`);
     }
     // If Chrome flag changed, do a hot restart to add/remove --chrome flag
     // Only restart if model didn't already trigger a restart
-    if (useChromeChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !providerChanged && !codexConfigChanged && sessionId) {
+    if (useChromeChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !grokModelChanged && !providerChanged && !codexConfigChanged && sessionId) {
         const chromeStatus = updates.useChrome ? 'enabled' : 'disabled';
         log.log(`Agent ${agent.name}: Chrome ${chromeStatus}, hot restarting with --resume to apply change`);
         try {
@@ -982,13 +1035,13 @@ export async function handleUpdateAgentProperties(ctx, payload) {
             log.error(`Failed to hot restart agent ${agent.name} after Chrome change:`, err);
         }
     }
-    else if (useChromeChanged && !providerChanged && !codexConfigChanged && !codexModelChanged && !opencodeModelChanged && !sessionId) {
+    else if (useChromeChanged && !providerChanged && !codexConfigChanged && !codexModelChanged && !opencodeModelChanged && !grokModelChanged && !sessionId) {
         // No existing session, chrome flag will apply on next start
         const chromeStatus = updates.useChrome ? 'enabled' : 'disabled';
         log.log(`Agent ${agent.name}: Chrome ${chromeStatus}, will apply on next session start`);
     }
     // If effort changed, hot restart to apply new --effort flag
-    if (effortChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !providerChanged && !codexConfigChanged && !classChanged && !useChromeChanged && sessionId) {
+    if (effortChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !grokModelChanged && !providerChanged && !codexConfigChanged && !classChanged && !useChromeChanged && sessionId) {
         const effortLabel = updates.effort || 'default';
         log.log(`Agent ${agent.name}: effort changed to ${effortLabel}, hot restarting with --resume to apply change`);
         try {
@@ -1052,7 +1105,7 @@ export async function handleUpdateAgentProperties(ctx, payload) {
         }
         // If skills changed and we didn't already hot restart for model/chrome/cwd change, do it now
         // Skills are injected into the system prompt, so we need to restart to apply them
-        if (skillsChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !providerChanged && !codexConfigChanged && !classChanged && !useChromeChanged && !cwdChanged && sessionId) {
+        if (skillsChanged && !modelChanged && !codexModelChanged && !opencodeModelChanged && !grokModelChanged && !providerChanged && !codexConfigChanged && !classChanged && !useChromeChanged && !cwdChanged && sessionId) {
             log.log(`Agent ${agent.name}: Skills changed, hot restarting with --resume to apply new system prompt`);
             try {
                 // Stop the current Claude process