claude-simple 0.2.8 → 0.2.9

package/dist/index.html

@@ -4,13 +4,13 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
   <title>Claude Code</title>
-  <link rel="stylesheet" href="/style.0.2.8.min.css">
+  <link rel="stylesheet" href="/style.0.2.9.min.css">
   <link rel="stylesheet" href="/highlight.min.css">
   <script src="/marked.min.js"></script>
   <script src="/highlight.min.js"></script>
 </head>
 <body class="h-dvh overflow-hidden flex flex-col bg-base-100 text-base-content">
   <div id="root" class="flex flex-col flex-1 overflow-hidden"></div>
-  <script type="module" src="/app.0.2.8.min.js"></script>
+  <script type="module" src="/app.0.2.9.min.js"></script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-simple",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "bin": {
     "claude-simple": "server.js",

package/public/chat.js

@@ -2,7 +2,7 @@
 import { watch, delegate, esc, $ } from './lib.js';
 import { ctx, isProcessing, currentProject, currentTab, currentModel, currentEffort, currentPermission,
          currentAgent, setAgent, AGENT_LABELS, getDefaultModel, getModelsForAgent, getEffortsForModel,
-         addCustomModel, setCurrentModel, chatDensity, wsStatus } from './state.js';
+         getDefaultEffort, addCustomModel, setCurrentModel, chatDensity, wsStatus } from './state.js';
 import { sendWs, api, authHeaders, flushWsQueue, clearWsQueue } from './api.js';
 import { initWakeLock, setWakeLockDesired } from './wake-lock.js';
 import { pushNotification } from './notifications.js';
@@ -773,16 +773,17 @@ export function sendMessage() {
 
   // While a turn is running, queue the next message (common Grok complaint).
   if (isProcessing.peek()) {
-    // Grok owns its queue on the edge through a long-lived ACP process. Send
-    // immediately so a page reload cannot discard this follow-up in the tab.
+    // Send immediately so a page reload cannot discard this follow-up in the
+    // tab. In hub mode the hub serializes it; standalone uses the edge queue.
     if (currentAgent.peek() === 'grok' && ctx.sessionId) {
       const agent = 'grok';
+      const effort = currentEffort.peek() || getDefaultEffort(agent, currentModel.peek()) || 'low';
       const ok = sendWs({
         type: 'command', cmd: 'turn.start', agent, command: text, sessionId: ctx.sessionId,
         options: {
           agent, cwd: currentProject.peek().path, sessionId: ctx.sessionId,
           configDir: ctx.configDir, model: currentModel.peek(),
-          ...(currentEffort.peek() && { effort: currentEffort.peek() }),
+          effort,
           ...(currentPermission.peek() && { permissionMode: currentPermission.peek() }),
           ...(currentPermission.peek() === 'bypassPermissions' && { allowDangerouslySkipPermissions: true }),
         },
@@ -831,9 +832,11 @@ export function sendMessage() {
   } else {
     flushToolBatch();
     appendMsg('user', 'You', text, { ts: now });
-    const effort     = currentEffort.peek();
-    const permission = currentPermission.peek();
     const agent      = currentAgent.peek() || 'claude';
+    const effort     = currentEffort.peek()
+      || getDefaultEffort(agent, currentModel.peek())
+      || (agent === 'grok' ? 'low' : '');
+    const permission = currentPermission.peek();
     // Existing sessions retain their own picker value. New sessions are bound
     // on the session-created event above.
     if (ctx.sessionId) setCurrentModel(currentModel.peek(), agent, ctx.sessionId);

package/public/shell/session-list.js

@@ -7,7 +7,7 @@ import {
   sidebarView, agentFilter, timeRange, activityHits, activityLoading,
   sessionMetaMap, LOW_TURN_THRESHOLD, metaKey, sessionDisplayTitle,
   hubMode, selectedMachineId, agentsMeta, currentEffort,
-  getModelsForAgent, getDefaultModel, getEffortsForModel,
+  getModelsForAgent, getDefaultModel, getEffortsForModel, getDefaultEffort,
   addCustomModel, removeCustomModel, getCustomModels, setCurrentModel, ctx,
 } from '../state.js';
 import { api, NOT_MODIFIED } from '../api.js';
@@ -174,15 +174,28 @@ export function refreshEffortSelect() {
   const agent = currentAgent.peek() || 'claude';
   const model = currentModel.peek();
   const efforts = getEffortsForModel(agent, model);
-  const cur = currentEffort.peek() || '';
+  let cur = currentEffort.peek() || '';
+  if (!cur) {
+    const def = getDefaultEffort(agent, model);
+    if (def && efforts.includes(def)) {
+      cur = def;
+      currentEffort.value = def;
+    }
+  }
   const opts = [`<option value="">effort: off</option>`]
     .concat(efforts.map(e =>
       `<option value="${esc(e)}" ${e === cur ? 'selected' : ''}>${esc(e)}</option>`
     ));
   sel.innerHTML = opts.join('');
   if (cur && !efforts.includes(cur)) {
-    currentEffort.value = '';
-    sel.value = '';
+    const def = getDefaultEffort(agent, model);
+    if (def && efforts.includes(def)) {
+      currentEffort.value = def;
+      sel.value = def;
+    } else {
+      currentEffort.value = '';
+      sel.value = '';
+    }
   } else {
     sel.value = cur;
   }

package/public/state.js

@@ -285,6 +285,18 @@ export function getEffortsForModel(agent, modelId) {
   return ['low', 'medium', 'high', 'xhigh', 'max'];
 }
 
+/** Default reasoning effort for agent/model (Grok → low). */
+export function getDefaultEffort(agent, modelId) {
+  const a = (agent || 'claude').toLowerCase();
+  const meta = agentsMeta.peek()?.defaults?.[a];
+  if (meta?.effortDefault) return String(meta.effortDefault);
+  const models = getModelsForAgent(a);
+  const m = models.find(x => x.value === modelId);
+  if (m?.defaultEffort) return String(m.defaultEffort);
+  if (a === 'grok') return 'low';
+  return '';
+}
+
 export function setAgent(agent) {
   const a = (agent || 'claude').toLowerCase();
   currentAgent.value = a;
@@ -300,6 +312,9 @@ export function setAgent(agent) {
   } else {
     setCurrentModel(getDefaultModel(a), a);
   }
+  const defEffort = getDefaultEffort(a, currentModel.peek());
+  if (defEffort) currentEffort.value = defEffort;
+  else if (a !== 'grok') currentEffort.value = '';
 }
 
 function matchesAgentFilter(s, filter) {

package/src/agents/grok.js

@@ -1,10 +1,11 @@
 import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
 import readline from 'readline';
 import crypto from 'crypto';
 
-// Grok's ACP transport is a long-lived JSON-RPC process.  Keeping it alive is
-// important: it owns the real Grok session and lets the edge, rather than an
-// individual browser tab, serialize follow-up prompts.
+// Persistent ACP (JSON-RPC over stdio). Advertise terminal+fs so Grok routes
+// shell/file tools through client RPCs instead of its own broken terminal path.
 const clients = new Map();
 const queues = new Map();
 const queueAliases = new Map();
@@ -13,6 +14,147 @@ function profileKey(options) {
   return `${options.model || ''}\u001f${options.effort || ''}`;
 }
 
+function envFromParams(envList) {
+  const env = { ...process.env };
+  if (!Array.isArray(envList)) return env;
+  for (const item of envList) {
+    if (!item || typeof item.name !== 'string') continue;
+    env[item.name] = item.value == null ? '' : String(item.value);
+  }
+  return env;
+}
+
+class TerminalHost {
+  constructor() {
+    this.terminals = new Map();
+  }
+
+  create(params = {}) {
+    const terminalId = `term_${crypto.randomUUID()}`;
+    const command = String(params.command || '');
+    const args = Array.isArray(params.args) ? params.args.map(String) : [];
+    const cwd = params.cwd || process.cwd();
+    const limit = Number.isFinite(params.outputByteLimit) && params.outputByteLimit > 0
+      ? params.outputByteLimit
+      : 1024 * 1024;
+    const env = envFromParams(params.env);
+
+    let child;
+    try {
+      child = spawn(command, args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: args.length === 0,
+      });
+    } catch (error) {
+      const err = new Error(error.message || 'Failed to start terminal');
+      err.code = -32000;
+      throw err;
+    }
+
+    const entry = {
+      id: terminalId,
+      child,
+      output: '',
+      truncated: false,
+      limit,
+      exitCode: null,
+      signal: null,
+      exited: false,
+      waiters: [],
+    };
+
+    const append = chunk => {
+      entry.output += chunk;
+      if (Buffer.byteLength(entry.output, 'utf8') > entry.limit) {
+        // Truncate from the start at a UTF-8-safe boundary.
+        let buf = Buffer.from(entry.output, 'utf8');
+        buf = buf.subarray(buf.length - entry.limit);
+        while (buf.length && (buf[0] & 0xc0) === 0x80) buf = buf.subarray(1);
+        entry.output = buf.toString('utf8');
+        entry.truncated = true;
+      }
+    };
+
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', err => {
+      append(`\n[terminal error] ${err.message}\n`);
+      if (!entry.exited) {
+        entry.exited = true;
+        entry.exitCode = 1;
+        entry.signal = null;
+        for (const resolve of entry.waiters) resolve({ exitCode: 1, signal: null });
+        entry.waiters = [];
+      }
+    });
+    child.on('close', (code, signal) => {
+      entry.exited = true;
+      entry.exitCode = code;
+      entry.signal = signal || null;
+      for (const resolve of entry.waiters) resolve({ exitCode: code, signal: signal || null });
+      entry.waiters = [];
+    });
+
+    this.terminals.set(terminalId, entry);
+    return { terminalId };
+  }
+
+  get(terminalId) {
+    const entry = this.terminals.get(terminalId);
+    if (!entry) {
+      const err = new Error(`Unknown terminal: ${terminalId}`);
+      err.code = -32000;
+      throw err;
+    }
+    return entry;
+  }
+
+  output(terminalId) {
+    const entry = this.get(terminalId);
+    const result = {
+      output: entry.output,
+      truncated: entry.truncated,
+    };
+    if (entry.exited) {
+      result.exitStatus = { exitCode: entry.exitCode, signal: entry.signal };
+    }
+    return result;
+  }
+
+  waitForExit(terminalId) {
+    const entry = this.get(terminalId);
+    if (entry.exited) return Promise.resolve({ exitCode: entry.exitCode, signal: entry.signal });
+    return new Promise(resolve => entry.waiters.push(resolve));
+  }
+
+  kill(terminalId) {
+    const entry = this.get(terminalId);
+    if (!entry.exited && entry.child?.pid) {
+      try { entry.child.kill('SIGTERM'); } catch { /* already gone */ }
+    }
+    return {};
+  }
+
+  release(terminalId) {
+    const entry = this.terminals.get(terminalId);
+    if (!entry) return {};
+    if (!entry.exited && entry.child?.pid) {
+      try { entry.child.kill('SIGTERM'); } catch { /* already gone */ }
+      setTimeout(() => {
+        if (!entry.exited && entry.child?.pid) {
+          try { entry.child.kill('SIGKILL'); } catch { /* already gone */ }
+        }
+      }, 800).unref?.();
+    }
+    this.terminals.delete(terminalId);
+    return {};
+  }
+}
+
 class GrokACPClient {
   constructor({ cliPath, model, effort }) {
     const args = ['agent', '--always-approve'];
@@ -22,13 +164,17 @@ class GrokACPClient {
     this.child = spawn(cliPath || 'grok', args, { stdio: ['pipe', 'pipe', 'pipe'] });
     this.pending = new Map();
     this.listeners = new Map();
-    this.nextID = 1;
+    // High ids avoid colliding with agent-originated request ids (often 0..N).
+    this.nextID = 100000;
+    this.terminals = new TerminalHost();
     this.ready = this.initialize();
     this.child.stderr.on('data', d => console.warn(`[grok acp] ${String(d).trim()}`));
     this.child.on('close', () => {
       for (const { reject } of this.pending.values()) reject(new Error('Grok ACP process stopped'));
       this.pending.clear();
-      for (const fn of this.listeners.values()) fn({ type: 'error', message: 'Grok ACP process stopped', agent: 'grok' });
+      for (const fn of this.listeners.values()) {
+        fn({ type: 'error', message: 'Grok ACP process stopped', agent: 'grok' });
+      }
       this.listeners.clear();
     });
     const rl = readline.createInterface({ input: this.child.stdout, crlfDelay: Infinity });
@@ -38,19 +184,82 @@ class GrokACPClient {
   async initialize() {
     const init = await this.request('initialize', {
       protocolVersion: 1,
-      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true },
-      clientInfo: { name: 'claude-simple-ui', version: '0.2.7' },
+      clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true,
+      },
+      clientInfo: { name: 'claude-simple-ui', version: '0.2.9' },
     });
     const methods = new Set((init.authMethods || []).map(x => x?.id));
     const methodId = process.env.XAI_API_KEY && methods.has('xai.api_key')
       ? 'xai.api_key'
       : (methods.has('cached_token') ? 'cached_token' : null);
     if (methodId) await this.request('authenticate', { methodId, _meta: { headless: true } });
+    return init;
+  }
+
+  async handleClientRequest(msg) {
+    const method = msg.method;
+    const params = msg.params || {};
+    try {
+      let result = {};
+      if (method === 'fs/read_text_file') {
+        const filePath = String(params.path || '');
+        const content = await fs.promises.readFile(filePath, 'utf8');
+        const limit = Number.isFinite(params.limit) ? params.limit : null;
+        const line = Number.isFinite(params.line) ? params.line : null;
+        if (line != null || limit != null) {
+          const lines = content.split('\n');
+          const start = Math.max(0, (line || 1) - 1);
+          const end = limit != null ? start + limit : lines.length;
+          result = { content: lines.slice(start, end).join('\n') };
+        } else {
+          result = { content };
+        }
+      } else if (method === 'fs/write_text_file') {
+        const filePath = String(params.path || '');
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.promises.writeFile(filePath, params.content ?? '', 'utf8');
+        result = {};
+      } else if (method === 'terminal/create') {
+        result = this.terminals.create(params);
+      } else if (method === 'terminal/output') {
+        result = this.terminals.output(params.terminalId);
+      } else if (method === 'terminal/wait_for_exit') {
+        result = await this.terminals.waitForExit(params.terminalId);
+      } else if (method === 'terminal/kill') {
+        result = this.terminals.kill(params.terminalId);
+      } else if (method === 'terminal/release') {
+        result = this.terminals.release(params.terminalId);
+      } else {
+        this.write({
+          jsonrpc: '2.0',
+          id: msg.id,
+          error: { code: -32601, message: `Unsupported client method: ${method}` },
+        });
+        return;
+      }
+      this.write({ jsonrpc: '2.0', id: msg.id, result });
+    } catch (error) {
+      this.write({
+        jsonrpc: '2.0',
+        id: msg.id,
+        error: { code: error.code || -32000, message: error.message || 'Client request failed' },
+      });
+    }
   }
 
   receive(line) {
     let msg;
     try { msg = JSON.parse(line); } catch { return; }
+
+    // Agent→client requests always carry a method. Check before pending so
+    // overlapping numeric ids cannot steal a client RPC as our response.
+    if (msg.id != null && msg.method) {
+      void this.handleClientRequest(msg);
+      return;
+    }
+
     if (msg.id != null && this.pending.has(msg.id)) {
       const pending = this.pending.get(msg.id);
       this.pending.delete(msg.id);
@@ -58,13 +267,7 @@ class GrokACPClient {
       else pending.resolve(msg.result || {});
       return;
     }
-    // Grok's documented ACP client sample does not need client-side tool RPC.
-    // Return a structured error for optional extension calls instead of leaving
-    // an agent request hanging forever.
-    if (msg.id != null && msg.method) {
-      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `Unsupported client method: ${msg.method}` } });
-      return;
-    }
+
     if (msg.method === 'session/update') {
       const sid = msg.params?.sessionId;
       const fn = sid && this.listeners.get(sid);
@@ -109,37 +312,68 @@ class GrokACPClient {
 function clientFor(options, cliPath) {
   const key = profileKey(options);
   let client = clients.get(key);
-  if (!client || client.child.exitCode != null) {
+  if (!client || client.child.exitCode != null || client.child.signalCode != null) {
     client = new GrokACPClient({ cliPath, model: options.model, effort: options.effort });
     clients.set(key, client);
   }
   return client;
 }
 
-function emitUpdate(update, send, sessionId, state) {
+function emitUpdate(update, send, state) {
   const kind = update?.sessionUpdate;
   if (kind === 'agent_message_chunk' && update.content?.text) {
-    if (!state.textOpen) { send({ type: 'assistant_stream_start', agent: 'grok', ts: Date.now() }); state.textOpen = true; }
+    if (state.thoughtOpen) {
+      send({ type: 'thought_stream_end', agent: 'grok' });
+      state.thoughtOpen = false;
+    }
+    if (!state.textOpen) {
+      send({ type: 'assistant_stream_start', agent: 'grok', ts: Date.now() });
+      state.textOpen = true;
+    }
     send({ type: 'assistant_delta', data: update.content.text, agent: 'grok' });
   } else if (kind === 'agent_thought_chunk' && update.content?.text) {
-    if (!state.thoughtOpen) { send({ type: 'thought_stream_start', agent: 'grok' }); state.thoughtOpen = true; }
+    if (!state.thoughtOpen) {
+      send({ type: 'thought_stream_start', agent: 'grok' });
+      state.thoughtOpen = true;
+    }
     send({ type: 'thought_delta', data: update.content.text, agent: 'grok' });
   } else if (kind === 'tool_call' || kind === 'tool_call_update') {
-    if (state.textOpen) { send({ type: 'assistant_stream_end', agent: 'grok' }); state.textOpen = false; }
-    if (state.thoughtOpen) { send({ type: 'thought_stream_end', agent: 'grok' }); state.thoughtOpen = false; }
+    if (state.textOpen) {
+      send({ type: 'assistant_stream_end', agent: 'grok' });
+      state.textOpen = false;
+    }
+    if (state.thoughtOpen) {
+      send({ type: 'thought_stream_end', agent: 'grok' });
+      state.thoughtOpen = false;
+    }
     if (kind === 'tool_call') {
-      send({ type: 'assistant', agent: 'grok', message: { content: [{
-        type: 'tool_use', name: update.title || update.kind || 'tool', input: update.rawInput || update.input || {},
-      }] } });
+      send({
+        type: 'assistant',
+        agent: 'grok',
+        message: {
+          content: [{
+            type: 'tool_use',
+            name: update.title || update.kind || 'tool',
+            input: update.rawInput || update.input || {},
+          }],
+        },
+      });
     }
   }
 }
 
 async function runOne(item, { cliPath, activeSessions, queueKey }) {
   const { command, options, send } = item;
-  const client = clientFor(options, cliPath);
+  const effort = options.effort || 'low';
+  const client = clientFor({ ...options, effort }, cliPath);
   const localKey = options.sessionId || crypto.randomUUID();
-  const entry = { kind: 'grok-acp', startTime: Date.now(), busy: true, key: localKey, sessionId: options.sessionId || null };
+  const entry = {
+    kind: 'grok-acp',
+    startTime: Date.now(),
+    busy: true,
+    key: localKey,
+    sessionId: options.sessionId || null,
+  };
   activeSessions.set(localKey, entry);
   const state = { textOpen: false, thoughtOpen: false };
   let sessionId = options.sessionId;
@@ -148,9 +382,14 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
     queueAliases.set(sessionId, queueKey);
     entry.sessionId = sessionId;
     activeSessions.set(sessionId, entry);
-    entry.abort = () => { client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } }); };
+    entry.abort = () => {
+      try {
+        client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+      } catch { /* process may already be gone */ }
+    };
     if (!options.sessionId) send({ type: 'session-created', sessionId, agent: 'grok' });
-    client.listeners.set(sessionId, update => emitUpdate(update, send, sessionId, state));
+    client.listeners.set(sessionId, update => emitUpdate(update, send, state));
+    send({ type: 'status', message: 'Grok ACP running…', agent: 'grok', sessionId });
     const result = await client.request('session/prompt', {
       sessionId,
       prompt: [{ type: 'text', text: command }],
@@ -158,10 +397,24 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
     if (state.textOpen) send({ type: 'assistant_stream_end', agent: 'grok' });
     if (state.thoughtOpen) send({ type: 'thought_stream_end', agent: 'grok' });
     entry.busy = false;
-    send({ type: 'result', is_error: result.stopReason === 'error', usage: result._meta?.usage || null, sessionId, agent: 'grok' });
-    send({ type: 'complete', exitCode: result.stopReason === 'cancelled' ? 130 : 0, aborted: result.stopReason === 'cancelled', sessionId, agent: 'grok' });
+    send({
+      type: 'result',
+      is_error: result.stopReason === 'error',
+      usage: result._meta?.usage || null,
+      sessionId,
+      agent: 'grok',
+    });
+    send({
+      type: 'complete',
+      exitCode: result.stopReason === 'cancelled' ? 130 : 0,
+      aborted: result.stopReason === 'cancelled',
+      sessionId,
+      agent: 'grok',
+    });
   } catch (e) {
     entry.busy = false;
+    if (state.textOpen) send({ type: 'assistant_stream_end', agent: 'grok' });
+    if (state.thoughtOpen) send({ type: 'thought_stream_end', agent: 'grok' });
     send({ type: 'error', message: e.message, sessionId, agent: 'grok' });
     send({ type: 'complete', exitCode: 1, sessionId, agent: 'grok' });
   } finally {
@@ -171,19 +424,26 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
   }
 }
 
-/** Queue all Grok follow-ups at the edge. The promise resolves after this item runs. */
+/** Queue all Grok follow-ups at the edge. Promise resolves after this item runs. */
 export function runGrok(command, options, send, { cliPath, activeSessions }) {
-  const key = (options.sessionId && queueAliases.get(options.sessionId)) || options.sessionId || `new:${options.cwd || ''}`;
+  const key = (options.sessionId && queueAliases.get(options.sessionId))
+    || options.sessionId
+    || `new:${options.cwd || ''}`;
   const queue = queues.get(key) || { items: [], running: false };
   queues.set(key, queue);
   return new Promise(resolve => {
     queue.items.push({ command, options, send, resolve });
     if (queue.running) {
-      send({ type: 'status', message: `Grok follow-up queued (${queue.items.length - 1} ahead)`, sessionId: options.sessionId, agent: 'grok' });
+      send({
+        type: 'status',
+        message: `Grok follow-up queued (${queue.items.length - 1} ahead)`,
+        sessionId: options.sessionId,
+        agent: 'grok',
+      });
       return;
     }
     queue.running = true;
-    const drain = async () => {
+    void (async () => {
       while (queue.items.length) {
         const item = queue.items.shift();
         await runOne(item, { cliPath, activeSessions, queueKey: key });
@@ -192,16 +452,19 @@ export function runGrok(command, options, send, { cliPath, activeSessions }) {
       queue.running = false;
       queues.delete(key);
       for (const [sid, alias] of queueAliases) if (alias === key) queueAliases.delete(sid);
-    };
-    void drain();
+    })();
   });
 }
 
 export async function interruptGrok(sessionId) {
   for (const client of clients.values()) {
     if (client.listeners.has(sessionId)) {
-      client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
-      return true;
+      try {
+        client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+        return true;
+      } catch {
+        return false;
+      }
     }
   }
   return false;

package/src/agents/models.js

@@ -304,7 +304,8 @@ async function discoverGrok(grokHome) {
 
   const active = models.find(m => m.value === defaultModel);
   const efforts = active?.efforts || DEFAULT_EFFORTS;
-  const effortDefault = active?.defaultEffort || tomlSectionString(cfgText, 'models', 'default_reasoning_effort') || null;
+  // This UI defaults Grok reasoning effort to low.
+  const effortDefault = 'low';
 
   return {
     model: defaultModel,

package/src/app.js

@@ -1485,8 +1485,18 @@ export function createApp() {
           }
           agentSend(data);
         };
-        await dispatchAgent(agent, cmd.command || '', options, runSend);
-        runOutbox.flush();
+        try {
+          await dispatchAgent(agent, cmd.command || '', options, runSend);
+        } finally {
+          // `complete` is a UI-facing agent event and is not a reliable
+          // scheduling boundary (an adapter may emit it early or more than
+          // once). The hub advances its Grok FIFO only after dispatchAgent has
+          // actually returned from the ACP request.
+          if (agent === 'grok') {
+            runOutbox.send({ type: 'hub-turn-finished', agent, sessionId: runSessionId });
+          }
+          runOutbox.flush();
+        }
         return;
       }