claude-simple 0.2.27 → 0.2.30

package/src/agents/models.js

@@ -11,12 +11,12 @@ import { pickAllowedEnv, loadAgentEnvFile, readSettingsJsonEnv } from '../agent-
 /** Static fallbacks when local cache/config is missing. */
 export const FALLBACK_MODELS = {
   claude: {
-    model: 'claude-sonnet-4-5',
+    model: 'sonnet',
     models: [
-      { value: 'claude-sonnet-4-5', label: 'sonnet-4-5' },
-      { value: 'claude-sonnet-4-6', label: 'sonnet-4-6' },
-      { value: 'claude-opus-4-5', label: 'opus-4-5' },
-      { value: 'claude-haiku-4-5', label: 'haiku-4-5' },
+      { value: 'fable', label: 'fable' },
+      { value: 'opus', label: 'opus' },
+      { value: 'sonnet', label: 'sonnet' },
+      { value: 'haiku', label: 'haiku' },
     ],
   },
   codex: {
@@ -228,14 +228,22 @@ async function discoverClaude(claudeConfigDirs = []) {
     }
   }
 
-  let models = uniqModels(found);
-  let source = 'fallback';
-  if (models.length) {
-    source = envMerged.ANTHROPIC_BASE_URL ? 'anthropic-compat' : 'settings';
-    // Custom gateway / third-party models: list only what is configured
+  // Third-party gateways only have the models named in env/settings.
+  // Official Claude Code accepts session aliases (fable, opus, sonnet, haiku)
+  // or a full model id; settings.model stays the default, not the whole list.
+  const customGateway = !!envMerged.ANTHROPIC_BASE_URL;
+  let models;
+  let source;
+  if (customGateway && found.length) {
+    models = uniqModels(found);
+    source = 'anthropic-compat';
   } else {
-    models = FALLBACK_MODELS.claude.models.map(m => ({ ...m }));
-    defaultModel = FALLBACK_MODELS.claude.model;
+    models = uniqModels([
+      ...FALLBACK_MODELS.claude.models.map(m => ({ ...m })),
+      ...found,
+    ]);
+    source = found.length ? 'alias+settings' : 'alias';
+    if (!defaultModel) defaultModel = FALLBACK_MODELS.claude.model;
   }
 
   if (!defaultModel) defaultModel = models[0]?.value || FALLBACK_MODELS.claude.model;
@@ -381,6 +389,7 @@ async function listAgyModels(cliPath) {
   // agy renders its model picker through a TTY. `script` supplies a tiny
   // pseudo-terminal while keeping this request non-interactive.
   const command = cliPath || 'agy';
+  if (process.platform === 'win32') return [];
   const scriptArgs = process.platform === 'darwin'
     ? ['-q', '/dev/null', command, 'models']
     : ['-q', '-c', `${command} models`, '/dev/null'];

package/src/agents/sessions.js

@@ -4,6 +4,7 @@ import readline from 'readline';
 import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
+import { pathsEqual } from '../platform.js';
 
 // ─── Claude ───────────────────────────────────────────────────────────────────
 
@@ -105,7 +106,7 @@ async function scanClaudeConfigDir(configDir, nameMap, filterCwd) {
       const filePath = path.join(projectDir, fileEntry.name);
       try {
         const [stat, meta] = await Promise.all([fs.stat(filePath), readClaudeSessionMeta(filePath)]);
-        if (filterCwd && meta.cwd !== filterCwd) return;
+        if (filterCwd && !pathsEqual(meta.cwd, filterCwd)) return;
         const sessionId = meta.sessionId || fileEntry.name.replace('.jsonl', '');
         const firstMsg = await readClaudeFirstMessage(filePath);
         sessions.push({
@@ -286,13 +287,20 @@ async function findCodexRollouts(codexHome) {
   return files;
 }
 
+const codexMetadata = new Map();
 async function readCodexMeta(filePath) {
+  const stat = await fs.stat(filePath);
+  const cached = codexMetadata.get(filePath);
+  if (cached?.size === stat.size && cached?.mtimeMs === stat.mtimeMs) return cached.meta;
   let id = null, cwd = null, ts = null, turnCount = 0;
   try {
     // Full scan: meta is early; turnCount needs whole file
     const stream = fsSync.createReadStream(filePath);
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
     for await (const line of rl) {
+      const head = line.slice(0, 400);
+      if (!/"type"\s*:\s*"(?:session_meta|turn_context)"/.test(head) &&
+          !/"(?:role|type)"\s*:\s*"(?:user|user_message)"/.test(head)) continue;
       try {
         const d = JSON.parse(line);
         if (d.type === 'session_meta' && d.payload) {
@@ -316,7 +324,10 @@ async function readCodexMeta(filePath) {
     const m = path.basename(filePath).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
     if (m) id = m[1];
   }
-  return { id, cwd, ts, turnCount };
+  const meta = { id, cwd, ts, turnCount };
+  codexMetadata.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, meta });
+  while (codexMetadata.size > 2000) codexMetadata.delete(codexMetadata.keys().next().value);
+  return meta;
 }
 
 export async function scanCodexSessions(codexHome, filterCwd = null) {
@@ -325,25 +336,27 @@ export async function scanCodexSessions(codexHome, filterCwd = null) {
   const rollouts = await findCodexRollouts(home);
   const sessions = [];
 
-  await Promise.all(rollouts.map(async filePath => {
-    try {
-      const [stat, meta] = await Promise.all([fs.stat(filePath), readCodexMeta(filePath)]);
-      if (!meta.id) return;
-      if (filterCwd && meta.cwd && meta.cwd !== filterCwd) return;
-      const idx = index.get(meta.id);
-      sessions.push({
-        sessionId: meta.id,
-        agent: 'codex',
-        cwd: meta.cwd || null,
-        configDir: home,
-        display: idx?.thread_name || meta.id.slice(0, 8),
-        updatedAt: stat.mtimeMs,
-        hasMemory: false,
-        filePath,
-        turnCount: meta.turnCount || 0,
-      });
-    } catch {}
-  }));
+  for (let offset = 0; offset < rollouts.length; offset += 8) {
+    await Promise.all(rollouts.slice(offset, offset + 8).map(async filePath => {
+      try {
+        const [stat, meta] = await Promise.all([fs.stat(filePath), readCodexMeta(filePath)]);
+        if (!meta.id) return;
+        if (filterCwd && meta.cwd && !pathsEqual(meta.cwd, filterCwd)) return;
+        const idx = index.get(meta.id);
+        sessions.push({
+          sessionId: meta.id,
+          agent: 'codex',
+          cwd: meta.cwd || null,
+          configDir: home,
+          display: idx?.thread_name || meta.id.slice(0, 8),
+          updatedAt: stat.mtimeMs,
+          hasMemory: false,
+          filePath,
+          turnCount: meta.turnCount || 0,
+        });
+      } catch {}
+    }));
+  }
   return sessions;
 }
 
@@ -361,12 +374,36 @@ export async function findCodexSessionFile(sessionId, codexHome) {
   return null;
 }
 
+const codexTranscripts = new Map();
+
 export async function parseCodexMessages(filePath) {
-  const messages = [];
+  const stat = await fs.stat(filePath);
+  let entry = codexTranscripts.get(filePath);
+  if (entry?.loading) {
+    await entry.loading;
+    return parseCodexMessages(filePath);
+  }
+  if (!entry || entry.ino !== stat.ino || stat.size < entry.size ||
+      (stat.size === entry.size && stat.mtimeMs !== entry.mtimeMs)) {
+    entry = { ino: stat.ino, size: 0, offset: 0, messages: [], seenAssistant: new Set(), seenCalls: new Set() };
+    codexTranscripts.set(filePath, entry);
+  }
+  codexTranscripts.delete(filePath);
+  codexTranscripts.set(filePath, entry);
+  while (codexTranscripts.size > 8) codexTranscripts.delete(codexTranscripts.keys().next().value);
+  if (entry.size === stat.size && entry.mtimeMs === stat.mtimeMs) return entry.messages;
+  const loading = updateCodexTranscript(filePath, entry, stat);
+  entry.loading = loading;
+  try { await loading; } finally { entry.loading = null; }
+  return entry.messages;
+}
+
+async function updateCodexTranscript(filePath, entry, stat) {
+  const messages = entry.messages;
   // Codex writes the same assistant turn twice:
   //   response_item (message/assistant)  AND  event_msg (agent_message)
   // Prefer response_item; only use event_msg when that text wasn't already seen.
-  const seenAssistant = new Set();
+  const seenAssistant = entry.seenAssistant;
 
   const assistantKey = (text, ts) => {
     const t = String(text || '').trim();
@@ -389,54 +426,81 @@ export async function parseCodexMessages(filePath) {
   };
 
   try {
-    const stream = fsSync.createReadStream(filePath);
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    for await (const line of rl) {
-      let d;
-      try { d = JSON.parse(line); } catch { continue; }
-
-      if (d.type === 'response_item' && d.payload) {
-        const p = d.payload;
-        if (p.type === 'message' && p.role === 'user') {
-          const texts = (p.content || [])
-            .filter(c => c.type === 'input_text' || c.type === 'text')
-            .map(c => c.text || '')
-            .filter(Boolean);
-          const text = texts.join('\n').trim();
-          // skip huge injected system/env blobs
-          if (text && !text.startsWith('# AGENTS.md') && !text.startsWith('<environment_context')
-              && !text.startsWith('<permissions') && text.length < 2000) {
-            messages.push({ role: 'user', type: 'text', content: text, ts: d.timestamp });
+    if (stat.size <= entry.offset) return;
+    const stream = fsSync.createReadStream(filePath, { start: entry.offset, end: stat.size - 1 });
+    let pending = Buffer.alloc(0);
+    for await (const chunk of stream) {
+      pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+      let start = 0;
+      let end;
+      while ((end = pending.indexOf(10, start)) !== -1) {
+        const line = pending.subarray(start, end).toString('utf8');
+        entry.offset += end - start + 1;
+        start = end + 1;
+        // Reasoning and tool outputs dominate large rollouts. Do not JSON-parse
+        // their multi-megabyte payloads when building the visible transcript.
+        const head = line.slice(0, 400);
+        if (!/"type"\s*:\s*"(?:response_item|event_msg)"/.test(head) ||
+            !/"type"\s*:\s*"(?:message|agent_message|function_call|command_execution|custom_tool_call)"/.test(head)) continue;
+        let d;
+        try { d = JSON.parse(line); } catch { continue; }
+
+        if (d.type === 'response_item' && d.payload) {
+          const p = d.payload;
+          if (p.type === 'message' && p.role === 'user') {
+            const texts = (p.content || [])
+              .filter(c => c.type === 'input_text' || c.type === 'text')
+              .map(c => c.text || '')
+              .filter(Boolean);
+            const text = texts.join('\n').trim();
+            // skip huge injected system/env blobs
+            if (text && !text.startsWith('# AGENTS.md') && !text.startsWith('<environment_context')
+                && !text.startsWith('<permissions')) {
+              seenAssistant.clear();
+              messages.push({ role: 'user', type: 'text', content: text, ts: d.timestamp });
+            }
+          } else if (p.type === 'message' && p.role === 'assistant') {
+            const texts = (p.content || [])
+              .filter(c => c.type === 'output_text' || c.type === 'text')
+              .map(c => c.text || '')
+              .filter(Boolean);
+            pushAssistant(texts.join('\n'), d.timestamp);
+          } else if (p.type === 'function_call') {
+            if (p.call_id && entry.seenCalls.has(p.call_id)) continue;
+            if (p.call_id) entry.seenCalls.add(p.call_id);
+            let input = p.arguments;
+            try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch {}
+            messages.push({ role: 'tool', type: 'tool_use', name: p.name || 'function', id: p.call_id, input: input ?? {}, ts: d.timestamp });
+          } else if (p.type === 'command_execution' || p.type === 'custom_tool_call') {
+            if (p.call_id && entry.seenCalls.has(p.call_id)) continue;
+            if (p.call_id) entry.seenCalls.add(p.call_id);
+            let input = p.input;
+            try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch {}
+            messages.push({
+              role: 'tool',
+              type: 'tool_use',
+              name: p.type === 'command_execution' ? 'Bash' : (p.name || 'tool'),
+              id: p.call_id,
+              input: p.type === 'command_execution' ? { command: p.command || '' } : (input ?? {}),
+              ts: d.timestamp,
+            });
           }
-        } else if (p.type === 'message' && p.role === 'assistant') {
-          const texts = (p.content || [])
-            .filter(c => c.type === 'output_text' || c.type === 'text')
-            .map(c => c.text || '')
-            .filter(Boolean);
-          pushAssistant(texts.join('\n'), d.timestamp);
-        } else if (p.type === 'function_call') {
-          let input = p.arguments;
-          try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch {}
-          messages.push({ role: 'tool', type: 'tool_use', name: p.name || 'function', input: input ?? {}, ts: d.timestamp });
-        } else if (p.type === 'command_execution' || p.type === 'custom_tool_call') {
-          messages.push({
-            role: 'tool',
-            type: 'tool_use',
-            name: p.type === 'command_execution' ? 'Bash' : (p.name || 'tool'),
-            input: { command: p.command || p.input || '' },
-            ts: d.timestamp,
-          });
         }
-      }
 
-      // Secondary channel — skip if response_item already recorded the same body
-      if (d.type === 'event_msg' && d.payload?.type === 'agent_message') {
-        const text = d.payload.message || d.payload.text;
-        pushAssistant(text, d.timestamp);
+        // Secondary channel — skip if response_item already recorded the same body
+        if (d.type === 'event_msg' && d.payload?.type === 'agent_message') {
+          const text = d.payload.message || d.payload.text;
+          pushAssistant(text, d.timestamp);
+        }
       }
+      pending = pending.subarray(start);
     }
-  } catch {}
-  return messages;
+    entry.size = stat.size;
+    entry.mtimeMs = stat.mtimeMs;
+  } catch (error) {
+    codexTranscripts.delete(filePath);
+    throw error;
+  }
 }
 
 function replaceSessionId(value, sourceSessionId, targetSessionId) {
@@ -496,6 +560,105 @@ async function forkCodexNativeSession(sourceSessionId, targetSessionId, codexHom
   return targetFile;
 }
 
+function grokAssistantText(record) {
+  if (record?.type !== 'assistant') return '';
+  return extractGrokText(record.content).trim();
+}
+
+function grokUpdateKind(record) {
+  const update = record?.params?.update || record?.update || {};
+  return update.sessionUpdate || update.type || '';
+}
+
+function grokUpdateText(record) {
+  const update = record?.params?.update || record?.update || {};
+  return extractGrokText(update.content).trim();
+}
+
+/**
+ * Grok resumes from a session directory, not a synthetic chat transcript.
+ * Fork by cloning the native files and cutting both journals at the selected
+ * assistant reply so tool results and encrypted reasoning stay intact.
+ */
+async function forkGrokNativeSession(sourceSessionId, targetSessionId, grokHome, assistantText, occurrence) {
+  const sourceDir = await findGrokSessionDir(sourceSessionId, grokHome);
+  if (!sourceDir) throw new Error('Grok source session was not found');
+
+  const sourceHistory = await fs.readFile(path.join(sourceDir, 'chat_history.jsonl'), 'utf8');
+  const historyOut = [];
+  let foundForkPoint = false;
+  let seenMatches = 0;
+  for (const line of sourceHistory.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { continue; }
+    historyOut.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+    const text = grokAssistantText(record);
+    if (text && text === assistantText && ++seenMatches === occurrence) {
+      foundForkPoint = true;
+      break;
+    }
+  }
+  if (!foundForkPoint) {
+    throw new Error('Selected Grok assistant message was not found in the native transcript');
+  }
+
+  const targetDir = path.join(path.dirname(sourceDir), targetSessionId);
+  await fs.mkdir(targetDir, { recursive: true });
+  const histTmp = path.join(targetDir, `chat_history.jsonl.tmp-${crypto.randomUUID()}`);
+  await fs.writeFile(histTmp, `${historyOut.join('\n')}\n`, 'utf8');
+  await fs.rename(histTmp, path.join(targetDir, 'chat_history.jsonl'));
+
+  try {
+    const sourceUpdates = await fs.readFile(path.join(sourceDir, 'updates.jsonl'), 'utf8');
+    const updatesOut = [];
+    let acc = '';
+    let seenUpdateMatches = 0;
+    let matched = false;
+    for (const line of sourceUpdates.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      let record;
+      try { record = JSON.parse(line); } catch { continue; }
+      const kind = grokUpdateKind(record);
+      if (matched && (kind === 'user_message_chunk' || kind === 'agent_message_chunk')) break;
+      updatesOut.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+      if (kind === 'agent_message_chunk') {
+        acc = `${acc}${grokUpdateText(record)}`;
+        if (acc.trim() === assistantText && ++seenUpdateMatches === occurrence) matched = true;
+      } else if (kind === 'user_message_chunk' || kind === 'turn_completed') {
+        acc = '';
+      }
+    }
+    const updTmp = path.join(targetDir, `updates.jsonl.tmp-${crypto.randomUUID()}`);
+    await fs.writeFile(updTmp, updatesOut.length ? `${updatesOut.join('\n')}\n` : '', 'utf8');
+    await fs.rename(updTmp, path.join(targetDir, 'updates.jsonl'));
+  } catch {}
+
+  const copyNames = ['system_prompt.txt', 'prompt_context.json', 'resources_state.json', 'announcement_state.json', 'signals.json'];
+  for (const name of copyNames) {
+    try {
+      const raw = await fs.readFile(path.join(sourceDir, name), 'utf8');
+      let out = raw;
+      if (name.endsWith('.json')) {
+        try { out = JSON.stringify(replaceSessionId(JSON.parse(raw), sourceSessionId, targetSessionId), null, 2); }
+        catch { out = raw.replaceAll(sourceSessionId, targetSessionId); }
+      }
+      await fs.writeFile(path.join(targetDir, name), out, 'utf8');
+    } catch {}
+  }
+
+  try {
+    const summaryRaw = await fs.readFile(path.join(sourceDir, 'summary.json'), 'utf8');
+    const summary = replaceSessionId(JSON.parse(summaryRaw), sourceSessionId, targetSessionId);
+    if (summary.info && typeof summary.info === 'object') summary.info.id = targetSessionId;
+    else summary.info = { ...(summary.info || {}), id: targetSessionId };
+    summary.updated_at = new Date().toISOString();
+    await fs.writeFile(path.join(targetDir, 'summary.json'), JSON.stringify(summary, null, 2), 'utf8');
+  } catch {}
+
+  return targetDir;
+}
+
 // ─── Grok ─────────────────────────────────────────────────────────────────────
 
 export async function scanGrokSessions(grokHome, filterCwd = null) {
@@ -512,7 +675,7 @@ export async function scanGrokSessions(grokHome, filterCwd = null) {
     // dir name is encodeURIComponent(cwd)
     let cwd;
     try { cwd = decodeURIComponent(dirEntry.name); } catch { cwd = dirEntry.name; }
-    if (filterCwd && cwd !== filterCwd) return;
+    if (filterCwd && !pathsEqual(cwd, filterCwd)) return;
 
     const projectDir = path.join(sessionsRoot, dirEntry.name);
     let sessionDirs;
@@ -1092,7 +1255,7 @@ export async function scanGeminiSessions(geminiHome, filterCwd = null) {
       records.set(sessionId, existing);
     }));
   } catch {}
-  return [...records.values()].filter(s => !filterCwd || s.cwd === filterCwd);
+  return [...records.values()].filter(s => !filterCwd || pathsEqual(s.cwd, filterCwd));
 }
 
 export async function parseGeminiMessages(filePath) {
@@ -1230,7 +1393,7 @@ export async function scanCursorSessions(cursorHome, filterCwd = null) {
       });
     }));
   } catch {}
-  return sessions.filter(s => !filterCwd || s.cwd === filterCwd);
+  return sessions.filter(s => !filterCwd || pathsEqual(s.cwd, filterCwd));
 }
 
 async function loadCursorContext(sessionId, cursorHome) {
@@ -1654,10 +1817,10 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
 }
 
 /** Return bounded raw JSONL for a particular agent session, for Meta Agent analysis. */
-export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500 } = {}) {
+export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500, tail = false, maxChars = 24000 } = {}) {
   if (!agent) {
     for (const candidate of ['claude', 'codex', 'grok', 'gemini', 'cursor']) {
-      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines });
+      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines, tail, maxChars });
       if (found) return found;
     }
     return null;
@@ -1673,20 +1836,35 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
     file = dir ? path.join(dir, 'chat_history.jsonl') : null;
   } else file = await findClaudeSessionFile(sessionId, claudeConfigDirs);
   if (!file) return null;
-  const start = Math.max(0, Number(offset) || 0);
-  const limit = Math.min(Math.max(1, Number(maxLines) || 500), 2000);
+  const start = Math.max(0, Math.floor(Number(offset) || 0));
+  const limit = Math.min(Math.max(1, Math.floor(Number(maxLines) || 100)), 500);
+  const budget = Math.min(Math.max(1000, Number(maxChars) || 24000), 64000);
   const lines = [];
-  let n = 0;
-  let hasMore = false;
+  let n = 0, chars = 0, hasMore = false, clipped = false;
   const stream = fsSync.createReadStream(file, { encoding: 'utf8' });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const line of rl) {
-    if (n++ < start) continue;
-    if (lines.length >= limit) { hasMore = true; rl.close(); stream.destroy(); break; }
-    lines.push(line);
-  }
+  try {
+    for await (const line of rl) {
+      const index = n++;
+      if (!tail && index < start) continue;
+      if (!tail && (lines.length >= limit || chars >= budget)) { hasMore = true; break; }
+      // Bound huge tool output rows as well as total response size. Clipping
+      // is explicit: a clipped line must not be mistaken for complete JSON.
+      const cap = tail ? budget : budget - chars;
+      const text = line.slice(0, cap);
+      if (text.length < line.length) clipped = true;
+      lines.push(text); chars += text.length;
+      if (tail) while (lines.length > limit || (chars > budget && lines.length > 1)) {
+        chars -= lines.shift().length;
+      }
+    }
+  } finally { rl.close(); stream.destroy(); }
   const stat = await fs.stat(file).catch(() => null);
-  return { agent: a, fileName: path.basename(file), offset: start, lines, nextOffset: start + lines.length, truncated: hasMore, size: stat?.size || 0 };
+  const actualOffset = tail ? Math.max(0, n - lines.length) : start;
+  return { agent: a, fileName: path.basename(file), offset: actualOffset, lines,
+    nextOffset: actualOffset + lines.length, truncated: hasMore, clipped,
+    tail, size: stat?.size || 0, updatedAt: stat?.mtimeMs || null };
+
 }
 
 export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
@@ -1796,6 +1974,17 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
     } catch {}
     return { targetSessionId };
   }
+
+  if (ta === 'grok' && sourceAgent.toLowerCase() === 'grok' && Number.isInteger(upTo)) {
+    const selected = messages[messages.length - 1];
+    if (selected?.role !== 'assistant' || !selected.content?.trim()) {
+      throw new Error('A Grok fork must end at a persisted assistant message');
+    }
+    const occurrence = messages.filter(message => message.role === 'assistant'
+      && message.content?.trim() === selected.content.trim()).length;
+    await forkGrokNativeSession(sourceSessionId, targetSessionId, grokHome, selected.content.trim(), occurrence);
+    return { targetSessionId };
+  }
   
   if (ta === 'claude') {
     const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');