cli-jaw 2.0.5 → 2.0.6

package/dist/src/agent/spawn.js

@@ -1,11 +1,11 @@
 // ─── Agent Spawn + Kill/Steer/Queue ──────────────────
 import fs from 'fs';
 import os from 'os';
-import crypto from 'node:crypto';
 import { join } from 'path';
-import { spawn, execFileSync } from 'child_process';
+import { spawn } from 'child_process';
 import { broadcast } from '../core/bus.js';
-import { settings, UPLOADS_DIR, detectCli, normalizeModelForCli } from '../core/config.js';
+import { settings, UPLOADS_DIR, detectCli } from '../core/config.js';
+import { migrateLegacyClaudeValue } from '../cli/claude-models.js';
 import { stripUndefined } from '../core/strip-undefined.js';
 import { clearEmployeeSession, getSession, insertMessage, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, getSessionBucket, clearSessionBucket, } from '../core/db.js';
 import { getSystemPrompt, regenerateB } from '../prompt/builder.js';
@@ -14,7 +14,6 @@ import { detectSmokeResponse } from './smoke-detector.js';
 import { saveUpload as _saveUpload, buildMediaPrompt, buildMediaPromptMany } from '../../lib/upload.js';
 import { resolveMainCli, consumePendingBootstrapPrompt } from '../core/main-session.js';
 import { getSessionOwnershipGeneration, persistMainSession, } from './session-persistence.js';
-import { groupQueueKey } from '../messaging/session-key.js';
 import { isCompactMarkerRow } from '../core/compact.js';
 import { isRuntimeSettingsMutationInFlight, waitForRuntimeSettingsIdle } from '../core/runtime-settings-gate.js';
 import { hasBlockingWorkers, hasPendingWorkerReplays, getActiveWorkers, clearAllWorkers } from '../orchestrator/worker-registry.js';
@@ -27,6 +26,7 @@ import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPe
 import { attachWatchdog } from './watchdog.js';
 import { buildOpencodeRuntimeSnapshot, buildOpencodeSpawnAudit, pushOpencodeRawEvent, resolveOpencodeBinary, } from './opencode-diagnostics.js';
 import { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
+import { isJawRuntimeEvent, handleJawRuntimeEvent } from './claude-e-runtime.js';
 import { appendTraceEvent, stampTraceTool, startTraceRun } from '../trace/store.js';
 // ─── State ───────────────────────────────────────────
 export let activeProcess = null;
@@ -38,33 +38,26 @@ export function getCurrentMainMeta() {
 export function setCurrentMainMeta(meta) {
     currentMainMeta = meta;
 }
-/**
- * Recursively kill a process tree using pgrep -P.
- * Codex sub-agents spawn children with separate PGIDs,
- * so process.kill(-pid) won't reach them.
- */
-function killProcessTree(pid, signal = 'SIGTERM') {
-    if (process.platform === 'win32') {
-        try {
-            execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
-        }
-        catch { /* best effort */ }
-        return;
-    }
-    let childPids = [];
-    try {
-        const out = execFileSync('pgrep', ['-P', String(pid)], { encoding: 'utf8', timeout: 3000 });
-        childPids = out.trim().split('\n').filter(Boolean).map(Number).filter(n => n > 0);
-    }
-    catch { /* no children or pgrep failed */ }
-    for (const cpid of childPids) {
-        killProcessTree(cpid, signal);
-    }
-    try {
-        process.kill(pid, signal);
-    }
-    catch { /* already dead */ }
+export function buildAiERuntimeStatusMeta(cli, provider, model) {
+    if (cli !== 'ai-e')
+        return {};
+    const mode = provider === 'claude' ? 'pty' : 'headless';
+    return {
+        selector: 'ai-e',
+        provider,
+        effectiveProvider: provider,
+        model,
+        mode,
+        runtime: {
+            cli,
+            selector: 'ai-e',
+            provider,
+            model,
+            mode,
+        },
+    };
 }
+import { killProcessTree } from './spawn/process-kill.js';
 export function killAgentById(agentId) {
     const proc = activeProcesses.get(agentId);
     if (!proc)
@@ -97,92 +90,50 @@ export function killAgentById(agentId) {
     }
 }
 export { memoryFlushCounter, flushCycleCount } from './memory-flush-controller.js';
-function normalizeQueueItem(row) {
-    try {
-        const parsed = JSON.parse(row.payload);
-        if (typeof parsed?.id !== 'string' || typeof parsed?.prompt !== 'string' || typeof parsed?.source !== 'string') {
-            return [];
-        }
-        return [stripUndefined({
-                id: parsed.id,
-                prompt: parsed.prompt,
-                source: parsed.source,
-                scope: 'default',
-                target: parsed.target,
-                chatId: parsed.chatId,
-                requestId: parsed.requestId,
-                ts: typeof parsed.ts === 'number' ? parsed.ts : Date.now(),
-            })];
-    }
-    catch {
-        return [];
-    }
-}
-function loadPersistedQueue() {
-    return listQueuedMessages.all().flatMap(normalizeQueueItem);
-}
-export const messageQueue = loadPersistedQueue();
-if (messageQueue.length > 0) {
-    console.log(`[queue] recovered ${messageQueue.length} persisted message(s) from previous session`);
-}
-let queueProcessing = false;
-// ─── 429 Retry Timer State ──────────────────────────
-// INVARIANT: single-main — 동시에 1개의 main spawnAgent만 존재한다고 가정.
-// 멀티 main task 도입 시 request-id 키 맵으로 전환 필요.
-let retryPendingTimer = null;
-let retryPendingResolve = null;
-let retryPendingOrigin = null;
-let retryPendingIsEmployee = false;
+const queueCtrl = createQueueController({
+    isSpawnBusy: () => Boolean(activeProcess) || mainSpawnStarting || queueCtrl.isRetryPending(),
+    hasBlockingWorkers,
+    hasPendingWorkerReplays,
+    insertMessage,
+    insertQueuedMessage,
+    deleteQueuedMessage,
+    listQueuedMessages: listQueuedMessages,
+    broadcast,
+    importPipeline: () => import('../orchestrator/pipeline.js'),
+    getWorkingDir: () => settings["workingDir"] || null,
+});
+export const { messageQueue, enqueueMessage, removeQueuedMessage, processQueue, setQueueHold, clearQueueHold, getQueueHoldId, clearRetryTimer, resetFallbackState, getFallbackState, getQueuedMessageSnapshotForScope, } = queueCtrl;
 let mainSpawnStarting = false;
 let cancelPendingMainSpawn = null;
-/** busy = process alive OR retry timer pending OR main spawn waiting on settings gate */
 export function isAgentBusy() {
-    return !!activeProcess || !!retryPendingTimer || mainSpawnStarting;
-}
-/**
- * Cancel pending retry timer AND resolve the dangling Promise.
- *
- * @param resumeQueue - true: 취소 후 대기 메시지 실행 (settings 변경 등)
- *                      false: 큐도 중단 (stop/steer 의도)
- *
- * 취소 규약: broadcast agent_done(error:true) → collect.ts L39가 수집함.
- */
-export function clearRetryTimer(resumeQueue = true) {
-    if (retryPendingTimer) {
-        clearTimeout(retryPendingTimer);
-        retryPendingTimer = null;
-        console.log('[jaw:retry] timer cancelled');
-        if (retryPendingResolve) {
-            broadcast('agent_done', {
-                text: '⏹️ 재시도 취소됨',
-                error: true,
-                origin: retryPendingOrigin || 'web',
-                ...(retryPendingIsEmployee ? { isEmployee: true } : {}),
-            }, retryPendingIsEmployee ? 'internal' : 'public');
-            retryPendingResolve({ text: '', code: -1 });
-            retryPendingResolve = null;
-            retryPendingOrigin = null;
-            retryPendingIsEmployee = false;
-        }
-        if (resumeQueue)
-            processQueue();
-    }
-}
-// ─── Fallback Retry State ────────────────────────────
-// key: originalCli, value: { fallbackCli, retriesLeft }
-const FALLBACK_MAX_RETRIES = 3;
-const fallbackState = new Map();
-export function resetFallbackState() {
-    clearRetryTimer(true); // settings 변경 = 큐 재개 OK
-    fallbackState.clear();
-    console.log('[jaw:fallback] state reset');
-}
-export function getFallbackState() {
-    return Object.fromEntries(fallbackState);
+    return !!activeProcess || queueCtrl.isRetryPending() || mainSpawnStarting;
 }
 // ─── Kill / Steer ────────────────────────────────────
 // [I2] Per-process kill reason map (replaces global variable to avoid cross-process confusion)
 const killReasons = new Map();
+const DEFAULT_STEER_WAIT_MS = 3_000;
+const DEFAULT_KILL_ESCALATION_MS = 2_000;
+const CLAUDE_E_STEER_WAIT_MS = 30_000;
+const CLAUDE_E_STEER_KILL_ESCALATION_MS = 8_000;
+function getActiveMainCli() {
+    return typeof currentMainMeta?.cli === 'string' ? currentMainMeta.cli : null;
+}
+function getActiveEffectiveProvider() {
+    return typeof currentMainMeta?.effectiveProvider === 'string' ? currentMainMeta.effectiveProvider : null;
+}
+function isActiveClaudePtyRuntime() {
+    const cli = getActiveMainCli();
+    return cli === 'claude-e' || (cli === 'ai-e' && getActiveEffectiveProvider() === 'claude');
+}
+function getKillPolicy(reason) {
+    if (reason === 'steer' && isActiveClaudePtyRuntime()) {
+        return { signal: 'SIGINT', escalationMs: CLAUDE_E_STEER_KILL_ESCALATION_MS };
+    }
+    return { signal: 'SIGTERM', escalationMs: DEFAULT_KILL_ESCALATION_MS };
+}
+export function getSteerWaitMsForActiveAgent() {
+    return isActiveClaudePtyRuntime() ? CLAUDE_E_STEER_WAIT_MS : DEFAULT_STEER_WAIT_MS;
+}
 /** Get kill reason for a process (by PID), consuming it */
 function consumeKillReason(pid) {
     if (!pid)
@@ -197,19 +148,6 @@ function consumeKillReason(pid) {
  * 모두 폐기한다. exit handler의 processQueue() 자동 드레인이 stop 직후 잔존
  * 메시지를 "스스로 steer" 처럼 실행하던 회귀를 차단.
  */
-function purgeQueueOnStop(reason) {
-    if (messageQueue.length === 0)
-        return;
-    const dropped = messageQueue.length;
-    for (const item of messageQueue.splice(0)) {
-        try {
-            deleteQueuedMessage.run(item.id);
-        }
-        catch { /* best-effort */ }
-    }
-    console.log(`[jaw:stop] cleared ${dropped} pending message(s) (reason=${reason})`);
-    broadcast('queue_update', { pending: 0 });
-}
 /**
  * Fix C2: 사용자 stop 시 worker-registry 도 비운다.
  * gateway.submitMessage가 isAgentBusy() 외에 hasBlockingWorkers()/hasPendingWorkerReplays()
@@ -224,25 +162,26 @@ function clearWorkerSlotsOnStop(reason) {
     console.log(`[jaw:stop] cleared worker registry (active=${active}, reason=${reason})`);
 }
 export function killActiveAgent(reason = 'user') {
-    const hadTimer = !!retryPendingTimer;
+    const hadTimer = queueCtrl.isRetryPending();
     const cancelledPendingMain = cancelPendingMainSpawn ? (cancelPendingMainSpawn(reason), true) : false;
     clearRetryTimer(false); // stop 의도: 큐 재개 안 함
     // Fix A: 사용자 stop은 큐도 폐기. steer/internal kill은 큐 보존.
     // Fix C2: worker registry 도 비워서 hasBlockingWorkers/hasPendingWorkerReplays가 즉시 false.
     if (reason === 'api' || reason === 'user') {
-        purgeQueueOnStop(reason);
+        queueCtrl.purgeQueueOnStop(reason);
         clearWorkerSlotsOnStop(reason);
     }
     if (!activeProcess)
         return hadTimer || cancelledPendingMain; // timer/gated spawn 취소도 "killed" 취급
-    console.log(`[jaw:kill] reason=${reason}`);
+    const policy = getKillPolicy(reason);
+    console.log(`[jaw:kill] reason=${reason} cli=${getActiveMainCli() || 'unknown'} signal=${policy.signal} escalationMs=${policy.escalationMs}`);
     if (activeProcess.pid)
         killReasons.set(activeProcess.pid, reason);
     try {
-        activeProcess.kill('SIGTERM');
+        activeProcess.kill(policy.signal);
     }
     catch (e) {
-        console.warn('[agent:kill] SIGTERM failed', { pid: activeProcess?.pid, error: e.message });
+        console.warn(`[agent:kill] ${policy.signal} failed`, { pid: activeProcess?.pid, error: e.message });
     }
     const proc = activeProcess;
     setTimeout(() => {
@@ -253,7 +192,7 @@ export function killActiveAgent(reason = 'user') {
         catch (e) {
             console.warn('[agent:kill] SIGKILL failed', { pid: proc?.pid, error: e.message });
         }
-    }, 2000);
+    }, policy.escalationMs);
     // Fix C1: 사용자 stop 시 isAgentBusy()가 즉시 false가 되도록 참조를 동기 해제.
     // 실제 child 종료는 위 setTimeout SIGKILL이 백그라운드에서 마무리.
     // exit handler의 setActiveProcess(null) / activeProcesses.delete 는 idempotent.
@@ -263,12 +202,12 @@ export function killActiveAgent(reason = 'user') {
     return true;
 }
 export function killAllAgents(reason = 'user') {
-    const hadTimer = !!retryPendingTimer;
+    const hadTimer = queueCtrl.isRetryPending();
     const cancelledPendingMain = cancelPendingMainSpawn ? (cancelPendingMainSpawn(reason), true) : false;
     clearRetryTimer(false); // stop 의도: 큐 재개 안 함
     // Fix A: 사용자 stop은 큐도 폐기. Fix C2: worker 슬롯도 비움.
     if (reason === 'api' || reason === 'user') {
-        purgeQueueOnStop(reason);
+        queueCtrl.purgeQueueOnStop(reason);
         clearWorkerSlotsOnStop(reason);
     }
     let killed = 0;
@@ -331,9 +270,10 @@ export function waitForProcessEnd(timeoutMs = 3000) {
     });
 }
 export async function steerAgent(newPrompt, source) {
+    const steerWaitMs = getSteerWaitMsForActiveAgent();
     const wasRunning = killActiveAgent('steer');
     if (wasRunning)
-        await waitForProcessEnd(3000);
+        await waitForProcessEnd(steerWaitMs);
     insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null);
     broadcast('new_message', { role: 'user', content: newPrompt, source });
     const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
@@ -348,150 +288,6 @@ export async function steerAgent(newPrompt, source) {
         broadcast('orchestrate_done', { text: `[error] ${err.message}`, error: true, origin });
     });
 }
-// ─── Message Queue ───────────────────────────────────
-export function getQueuedMessageSnapshotForScope(scope) {
-    return messageQueue
-        .filter(item => item.scope === scope)
-        .map(item => ({
-        id: item.id,
-        prompt: item.prompt,
-        source: item.source,
-        ts: item.ts,
-    }));
-}
-export function removeQueuedMessage(id) {
-    const idx = messageQueue.findIndex(item => item.id === id);
-    if (idx === -1)
-        return { removed: null, pending: messageQueue.length };
-    const [removed] = messageQueue.splice(idx, 1);
-    try {
-        deleteQueuedMessage.run(id);
-    }
-    catch (err) {
-        console.warn(`[queue] DB delete failed for ${id}:`, err.message);
-    }
-    console.log(`[queue] -1 (${messageQueue.length} pending) removed=${id}`);
-    broadcast('queue_update', { pending: messageQueue.length });
-    return { removed: removed, pending: messageQueue.length };
-}
-export function enqueueMessage(prompt, source, meta) {
-    const item = stripUndefined({
-        id: crypto.randomUUID(),
-        prompt,
-        source,
-        scope: meta?.scope || 'default',
-        target: meta?.target,
-        chatId: meta?.chatId,
-        requestId: meta?.requestId,
-        ts: Date.now(),
-    });
-    insertQueuedMessage.run(item.id, JSON.stringify(item));
-    messageQueue.push(item);
-    console.log(`[queue] +1 (${messageQueue.length} pending)`);
-    broadcast('queue_update', { pending: messageQueue.length });
-    processQueue();
-    return item.id;
-}
-export async function processQueue() {
-    if (queueProcessing)
-        return;
-    // Auto-drain pending worker replays when Boss is idle. Covers the case where
-    // Boss died after the dispatch client disconnected — the result was stuck in
-    // pendingReplay and nothing was triggering drainPendingReplays. Dynamic
-    // import avoids circular dep (pipeline.ts imports from this module).
-    if (!activeProcess && !retryPendingTimer && !mainSpawnStarting && !hasBlockingWorkers() && hasPendingWorkerReplays()) {
-        queueMicrotask(() => {
-            import('../orchestrator/pipeline.js')
-                .then(({ drainPendingReplays }) => drainPendingReplays({ origin: 'system' }))
-                .catch(err => console.error('[processQueue:drain]', err.message));
-        });
-        // Fall through: if messageQueue has entries, we still process them below.
-        // orchestrate() inside drain will also drain — idempotent via claimWorkerReplay.
-    }
-    if (activeProcess
-        || retryPendingTimer
-        || mainSpawnStarting
-        || hasBlockingWorkers()
-        || messageQueue.length === 0)
-        return;
-    // NOTE: hasPendingWorkerReplays() is intentionally NOT gated here —
-    // orchestrate() drains pending replays at entry (pipeline.ts drainPendingReplays),
-    // so the queued user message still arrives AFTER the worker result. Keeping this
-    // gate caused a deadlock (see devlog/_plan/260417_message_duplication/02_*).
-    queueProcessing = true;
-    // Group by source+target — only process the first group, leave rest in queue
-    const first = messageQueue[0];
-    const groupKey = groupQueueKey(first.source, first.target);
-    const batch = [];
-    const remaining = [];
-    for (const m of messageQueue) {
-        const key = groupQueueKey(m.source, m.target);
-        if (key === groupKey)
-            batch.push(m);
-        else
-            remaining.push(m);
-    }
-    // Replace queue with remaining items + unprocessed batch tail
-    // 📋 Queue policy: "fair" — 다른 chatId 메시지 우선 소비, 같은 chatId tail은 뒤로.
-    //    "chatId-first" 정책이 필요하면 push 순서를 (batch.slice(1), ...remaining)으로 변경.
-    messageQueue.length = 0;
-    if (batch.length > 1) {
-        // 🔑 batch 분리: 첫 메시지만 처리
-        // remaining(다른 chatId) 먼저 → batch tail(같은 chatId) 뒤 → chatId 독점 방지
-        messageQueue.push(...remaining, ...batch.slice(1));
-    }
-    else {
-        messageQueue.push(...remaining);
-    }
-    const item = batch[0];
-    const combined = item.prompt;
-    const source = item.source;
-    const target = item.target;
-    const chatId = item.chatId;
-    const requestId = item.requestId;
-    const origin = source || 'web';
-    console.log(`[queue] processing 1/${batch.length} message(s) for ${groupKey}, ${messageQueue.length} remaining`);
-    let inserted = false;
-    try {
-        insertMessage.run('user', combined, source, '', settings["workingDir"] || null);
-        deleteQueuedMessage.run(item.id);
-        inserted = true;
-        // Broadcast WITH fromQueue=true so the web client renders the user bubble
-        // now (not at enqueue time). gateway.ts:130 also broadcasts at enqueue,
-        // but the web client ignores that one — it only acts on fromQueue.
-        broadcast('new_message', { role: 'user', content: combined, source, fromQueue: true });
-        broadcast('queue_update', { pending: messageQueue.length });
-        const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
-        const task = isResetIntent(combined)
-            ? orchestrateReset({ origin, target, chatId, requestId, _skipInsert: true })
-            : isContinueIntent(combined)
-                ? orchestrateContinue({ origin, target, chatId, requestId, _skipInsert: true })
-                : orchestrate(combined, { origin, target, chatId, requestId, _skipInsert: true });
-        try {
-            await task;
-        }
-        catch (err) {
-            const msg = err.message;
-            console.error('[queue:orchestrate]', msg);
-            broadcast('orchestrate_done', { text: `[error] ${msg}`, error: true, origin, chatId, target, requestId });
-        }
-    }
-    catch (setupErr) {
-        console.error('[queue:setup]', setupErr);
-        if (!inserted) {
-            // insertMessage hasn't run yet — safe to requeue
-            messageQueue.unshift(item);
-        }
-        else {
-            // Message is already in DB — broadcast error, don't requeue (would cause duplicate)
-            broadcast('orchestrate_done', { text: `[error] setup failed: ${setupErr.message}`, error: true, origin, chatId, target, requestId });
-        }
-    }
-    finally {
-        queueProcessing = false;
-        queueMicrotask(() => processQueue());
-    }
-}
 // ─── Helpers ─────────────────────────────────────────
 function makeCleanEnv(extraEnv = {}) {
     const env = { ...process.env };
@@ -588,68 +384,20 @@ function withHistoryPrompt(prompt, historyBlock) {
         return body;
     return `${historyBlock}\n\n---\n[Current Message]\n${body}`;
 }
-import { buildArgs, buildResumeArgs, resolveSessionBucket } from './args.js';
-export { buildArgs, buildResumeArgs, resolveSessionBucket };
+import { buildArgs, buildResumeArgs, resolveAiEProvider, resolveSessionBucket } from './args.js';
+export { buildArgs, buildResumeArgs, resolveAiEProvider, resolveSessionBucket };
 // ─── Upload wrapper ──────────────────────────────────
 export const saveUpload = (buffer, originalName, options) => _saveUpload(UPLOADS_DIR, Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer), originalName, options);
 export { buildMediaPrompt, buildMediaPromptMany };
 // ─── Spawn Agent ─────────────────────────────────────
 import { AcpClient } from '../cli/acp-client.js';
-// ─── ACP Heartbeat Helper ────────────────────────────
-// Pure function for conditional heartbeat gating.
-// "visible" = WebUI + Telegram common baseline. 💭 is WebUI-only
-// (bot.ts:337 hides it), so it's NOT counted as visible.
-const DEFAULT_HEARTBEAT_GATE_MS = 20_000;
-export function shouldEmitHeartbeat(lastVisibleTs, heartbeatSent, gateMs = DEFAULT_HEARTBEAT_GATE_MS, now = Date.now()) {
-    if (heartbeatSent)
-        return false;
-    return (now - lastVisibleTs) > gateMs;
-}
-export function shouldResumeBucketSession(cli, requestedModel, bucketModel, requestedResumeKey, bucketResumeKey, bucketUpdatedAt, nowMs = Date.now()) {
-    if (cli === 'gemini') {
-        if (!bucketModel)
-            return false;
-        if (isExpiredBucket(bucketUpdatedAt, GEMINI_RESUME_TTL_MS, nowMs))
-            return false;
-        const requested = normalizeGeminiResumeModel(requestedModel);
-        const bucket = normalizeGeminiResumeModel(bucketModel);
-        if (!requested || !bucket)
-            return false;
-        return requested === bucket;
-    }
-    if (cli === 'copilot' && bucketModel) {
-        return normalizeModelForCli(cli, requestedModel) === normalizeModelForCli(cli, bucketModel);
-    }
-    if (cli === 'opencode' && requestedResumeKey) {
-        return requestedResumeKey === (bucketResumeKey ?? null);
-    }
-    return true;
-}
-export const GEMINI_RESUME_TTL_MS = 72 * 60 * 60 * 1000;
+import { CodexAppClient } from './codex-app-client.js';
+import { extractFromCodexAppEvent } from './codex-app-events.js';
+import { shouldEmitHeartbeat, shouldResumeBucketSession, GEMINI_RESUME_TTL_MS } from './spawn/resume.js';
+export { shouldEmitHeartbeat, shouldResumeBucketSession, GEMINI_RESUME_TTL_MS };
+import { createQueueController, FALLBACK_MAX_RETRIES } from './spawn/queue.js';
 const GEMINI_HISTORY_MAX_SESSIONS = 4;
 const GEMINI_HISTORY_MAX_CHARS = 3000;
-function normalizeGeminiResumeModel(model) {
-    const normalized = String(model || '').trim().toLowerCase();
-    if (!normalized || normalized === 'default' || normalized === 'auto')
-        return '';
-    return normalized;
-}
-function parseBucketUpdatedAt(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value < 10_000_000_000 ? value * 1000 : value;
-    }
-    const text = String(value || '').trim();
-    if (!text)
-        return null;
-    const parsed = Date.parse(text.includes('T') ? text : `${text.replace(' ', 'T')}Z`);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function isExpiredBucket(value, ttlMs, nowMs) {
-    const updatedAtMs = parseBucketUpdatedAt(value);
-    if (updatedAtMs === null)
-        return true;
-    return nowMs - updatedAtMs > ttlMs;
-}
 function cleanupEmployeeTmpDir(cwd, workingDir, label) {
     if (cwd !== workingDir) {
         try {
@@ -669,7 +417,7 @@ export function spawnAgent(prompt, opts = {}) {
     const isEmployee = !mainManaged;
     const empTag = isEmployee ? { isEmployee: true } : {};
     if (gateEligibleMain && !opts._settingsGateWaited && isRuntimeSettingsMutationInFlight()) {
-        if (activeProcess || retryPendingTimer || mainSpawnStarting) {
+        if (activeProcess || queueCtrl.isRetryPending() || mainSpawnStarting) {
             console.log('[jaw] Agent already running, skipping');
             return { child: null, promise: Promise.resolve({ text: '', code: -1 }) };
         }
@@ -733,7 +481,7 @@ export function spawnAgent(prompt, opts = {}) {
     // instead of the legacy `isResumeGuess` heuristic. See comment near line 762.
     // ─── Fallback retry: skip to fallback if retries exhausted ───
     if (!opts._isFallback && !opts.internal) {
-        const st = fallbackState.get(cli);
+        const st = queueCtrl.fallbackState.get(cli);
         if (st && st.retriesLeft <= 0) {
             const fbAvail = detectCli(st.fallbackCli)?.available;
             if (fbAvail) {
@@ -751,8 +499,30 @@ export function spawnAgent(prompt, opts = {}) {
     }
     const cfg = settings["perCli"]?.[cli] || {};
     const ao = settings["activeOverrides"]?.[cli] || {};
-    const model = opts.model || ao.model || cfg.model || 'default';
+    const requestedModel = opts.model || ao.model || cfg.model || 'default';
     const effort = opts.effort || ao.effort || cfg.effort || '';
+    const effectiveProvider = cli === 'ai-e'
+        ? resolveAiEProvider(typeof cfg.provider === 'string'
+            ? cfg.provider
+            : typeof ao.provider === 'string'
+                ? ao.provider
+                : undefined, requestedModel)
+        : cli;
+    const model = cli === 'ai-e' && effectiveProvider === 'claude'
+        ? migrateLegacyClaudeValue(requestedModel)
+        : requestedModel;
+    if (mainManaged) {
+        setCurrentMainMeta(stripUndefined({
+            origin,
+            target: opts.target,
+            chatId: opts.chatId,
+            requestId: opts.requestId,
+            scopeId: liveScope,
+            cli,
+            model,
+            effectiveProvider,
+        }));
+    }
     const includeDirectories = Array.isArray(cfg.includeDirectories)
         ? cfg.includeDirectories.filter((dir) => typeof dir === 'string' && dir.trim().length > 0)
         : [];
@@ -762,7 +532,7 @@ export function spawnAgent(prompt, opts = {}) {
     // Bucket-aware resume: codex-spark is kept in its own session bucket so
     // cross-model resume (gpt-5.4 ↔ gpt-5.3-codex-spark) doesn't send a
     // mismatched session_id to the server.
-    const currentBucket = resolveSessionBucket(cli, model);
+    const currentBucket = resolveSessionBucket(cli, model, effectiveProvider);
     const cliEnv = applyCliEnvDefaults(cli, opts.env);
     const spawnEnv = makeCleanEnv(cliEnv);
     const bucketRow = currentBucket ? getSessionBucket.get(currentBucket) : null;
@@ -771,10 +541,12 @@ export function spawnAgent(prompt, opts = {}) {
     const bucketResumeKey = typeof bucketRow?.resume_key === 'string' ? bucketRow.resume_key : null;
     const bucketUpdatedAt = bucketRow?.updated_at ?? null;
     const resumeKey = buildSessionResumeKey(cli, spawnEnv);
+    const providerSupportsResume = !(cli === 'ai-e' && effectiveProvider !== 'claude');
     const canResumeBucketSession = !bucketSessionId || shouldResumeBucketSession(cli, model, bucketModel, resumeKey, bucketResumeKey, bucketUpdatedAt);
     const isResume = empSid
         ? true
-        : (!opts._skipResume && !forceNew && !!bucketSessionId && canResumeBucketSession);
+        : (providerSupportsResume && !opts._skipResume && !forceNew && !!bucketSessionId && canResumeBucketSession);
+    const runtimeStatusMeta = buildAiERuntimeStatusMeta(cli, effectiveProvider, model);
     // ─── Bootstrap compact 1-shot injection (Phase 52: bucket-aware) ───
     // Vendor-agnostic: compact handler reset session_id and stored bootstrap in DB.
     // Inject only on fresh main spawns (not employee/fallback/internal/resume).
@@ -820,17 +592,27 @@ export function spawnAgent(prompt, opts = {}) {
     const historyBlock = !isResume && !opts._skipHistory
         ? buildHistoryBlock(prompt, settings["workingDir"], cli === 'gemini' ? GEMINI_HISTORY_MAX_SESSIONS : 10, cli === 'gemini' ? GEMINI_HISTORY_MAX_CHARS : 8000)
         : '';
-    const promptForArgs = (cli === 'gemini' || cli === 'opencode')
+    const promptForArgs = (cli === 'gemini' || cli === 'grok' || cli === 'opencode')
         ? withHistoryPrompt(prompt, historyBlock)
         : prompt;
+    const claudeBin = (cli === 'claude-e' || (cli === 'ai-e' && effectiveProvider === 'claude'))
+        ? detectCli('claude').path
+        : null;
+    const argOptions = {
+        fastMode: cfg.fastMode,
+        sysPrompt,
+        includeDirectories,
+        aiEProvider: effectiveProvider,
+        ...(claudeBin ? { claudeBin } : {}),
+    };
     let args;
     if (isResume) {
         const sid = resumeSessionId || '';
         console.log(`[jaw:resume] ${cli} session=${sid.slice(0, 12)}...`);
-        args = buildResumeArgs(cli, model, effort, sid, prompt, permissions, { fastMode: cfg.fastMode, sysPrompt, includeDirectories });
+        args = buildResumeArgs(cli, model, effort, sid, prompt, permissions, argOptions);
     }
     else {
-        args = buildArgs(cli, model, effort, promptForArgs, sysPrompt, permissions, { fastMode: cfg.fastMode, includeDirectories });
+        args = buildArgs(cli, model, effort, promptForArgs, sysPrompt, permissions, argOptions);
     }
     const agentLabel = agentId || 'main';
     const traceAudience = (opts.internal || isEmployee) ? 'internal' : 'public';
@@ -886,6 +668,8 @@ export function spawnAgent(prompt, opts = {}) {
     }
     else {
         console.log(`[jaw:${agentLabel}] Spawning: ${cli} ${args.join(' ').slice(0, 120)}...`);
+        if (cli === 'claude-e')
+            console.log(`[jaw:${agentLabel}:args] ${JSON.stringify(args)}`);
     }
     if (cli === 'gemini' && sysPrompt) {
         const tmpSysFile = join(os.tmpdir(), `jaw-gemini-sys-${agentLabel}.md`);
@@ -1199,16 +983,8 @@ export function spawnAgent(prompt, opts = {}) {
                 resolve: resolve,
                 activeProcesses,
                 setActiveProcess: (v) => { activeProcess = v; },
-                retryState: {
-                    timer: retryPendingTimer,
-                    resolve: retryPendingResolve,
-                    origin: retryPendingOrigin,
-                    setTimer: (t) => { retryPendingTimer = t; },
-                    setResolve: (r) => { retryPendingResolve = r; },
-                    setOrigin: (o) => { retryPendingOrigin = o; },
-                    setIsEmployee: (v) => { retryPendingIsEmployee = v; },
-                },
-                fallbackState,
+                retryState: queueCtrl.retryState,
+                fallbackState: queueCtrl.fallbackState,
                 fallbackMaxRetries: FALLBACK_MAX_RETRIES,
                 processQueue,
             }).catch((err) => {
@@ -1217,11 +993,284 @@ export function spawnAgent(prompt, opts = {}) {
         });
         return { child, promise: resultPromise };
     }
+    // ─── Codex AppServer branch ────────────────────
+    if (cli === 'codex-app') {
+        const appClient = new CodexAppClient({
+            binary: detected.path || 'codex',
+            workDir: spawnCwd,
+            env: spawnEnv,
+            model,
+            effort,
+        });
+        appClient.spawn();
+        const child = appClient.proc;
+        if (!child) {
+            throw new Error('Codex AppServer process was not created');
+        }
+        if (mainManaged)
+            activeProcess = child;
+        if (activeProcesses.has(agentLabel)) {
+            console.warn(`[spawn:dup] activeProcesses already has child for ${agentLabel} — orphaning previous reference`);
+        }
+        activeProcesses.set(agentLabel, child);
+        if (!opts.internal)
+            broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
+        if (mainManaged && !opts.internal)
+            beginLiveRun(liveScope, cli);
+        let codexAppSettled = false;
+        appClient.on('error', (err) => {
+            if (codexAppSettled)
+                return;
+            codexAppSettled = true;
+            appClient.cleanup();
+            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
+            opts.lifecycle?.onExit?.(null);
+            const msg = `Codex AppServer spawn failed: ${err.message}`;
+            console.error(`[codex-app:error] ${msg}`);
+            activeProcesses.delete(agentLabel);
+            if (mainManaged) {
+                activeProcess = null;
+                clearLiveRun(liveScope);
+                broadcast('agent_status', { running: false, agentId: agentLabel });
+            }
+            broadcast('agent_done', { text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
+            resolve({ text: '', code: 1 });
+            if (mainManaged)
+                processQueue();
+        });
+        if (mainManaged && !opts.internal && !opts._skipInsert) {
+            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null);
+        }
+        if (!opts.internal)
+            broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
+        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
+        const ctx = {
+            fullText: '', traceLog: [], toolLog: [], seenToolKeys: new Set(),
+            hasClaudeStreamEvents: false, sessionId: null, cost: null,
+            turns: null, duration: null, tokens: null, stderrBuf: '',
+            thinkingBuf: '',
+            liveScope: effectiveLiveScope,
+            parentLiveScope: parentLiveScopeForChild,
+            traceRunId,
+            traceAudience,
+        };
+        function flushCodexAppThinking() {
+            if (!ctx.thinkingBuf)
+                return;
+            const merged = ctx.thinkingBuf.trim();
+            if (merged) {
+                const singleLine = merged.replace(/\s+/g, ' ').trim();
+                const label = singleLine.length > 120 ? `${singleLine.slice(0, 119)}…` : singleLine;
+                console.log(`  💭 ${label}`);
+                const tool = { icon: '💭', label, toolType: 'thinking', detail: merged };
+                stampTraceTool(tool, ctx, 'thinking');
+                ctx.toolLog.push(tool);
+                if (ctx.liveScope)
+                    replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
+                if (ctx.parentLiveScope)
+                    appendLiveRunTool(ctx.parentLiveScope, { ...tool, isEmployee: true });
+                broadcast('agent_tool', { agentId: agentLabel, ...tool, ...empTag }, traceAudience);
+            }
+            ctx.thinkingBuf = '';
+        }
+        let lastVisibleBroadcastTs = Date.now();
+        let heartbeatSent = false;
+        appClient.on('notification', (method, params) => {
+            if (method === 'turn/completed' || method === 'turn/started' || method === 'error') {
+                console.log(`[codex-app:notify] ${method}`);
+            }
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'codex_app_raw', eventType: method, raw: params });
+            const parsed = extractFromCodexAppEvent(method, params, ctx);
+            if (!parsed)
+                return;
+            if (parsed.flushThinking) {
+                flushCodexAppThinking();
+            }
+            if (parsed.tool) {
+                const parsedTool = parsed.tool;
+                if (parsedTool.icon === '💭') {
+                    ctx.thinkingBuf += parsedTool.detail || parsedTool.label;
+                    return;
+                }
+                flushCodexAppThinking();
+                const key = `${parsedTool.icon}:${parsedTool.label}:${parsedTool.stepRef || ''}:${parsedTool.status || ''}`;
+                if (!ctx.seenToolKeys.has(key)) {
+                    ctx.seenToolKeys.add(key);
+                    stampTraceTool(parsedTool, ctx, parsedTool.toolType || 'tool');
+                    ctx.toolLog.push(parsedTool);
+                    if (ctx.liveScope)
+                        replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
+                    if (ctx.parentLiveScope)
+                        appendLiveRunTool(ctx.parentLiveScope, { ...parsedTool, isEmployee: true });
+                    broadcast('agent_tool', { agentId: agentLabel, ...parsedTool, ...empTag }, traceAudience);
+                    lastVisibleBroadcastTs = Date.now();
+                    heartbeatSent = false;
+                }
+            }
+            if (parsed.text) {
+                flushCodexAppThinking();
+                ctx.fullText += parsed.text;
+                if (ctx.liveScope)
+                    appendLiveRunText(ctx.liveScope, parsed.text);
+            }
+            if (parsed.sessionId && !ctx.sessionId) {
+                ctx.sessionId = parsed.sessionId;
+            }
+            if (parsed.tokens) {
+                ctx.tokens = parsed.tokens;
+            }
+            if (parsed.turnStatus && parsed.turnStatus !== 'completed') {
+                console.warn(`[codex-app:turn] final status: ${parsed.turnStatus}`);
+                turnCompleted = false;
+            }
+            opts.lifecycle?.onActivity?.('codex-app');
+        });
+        appClient.on('stderr', (text) => {
+            appendTraceEvent({ runId: ctx.traceRunId, source: 'stderr', eventType: 'stderr', raw: text });
+            if (ctx.stderrBuf.length < 4000) {
+                ctx.stderrBuf += text + '\n';
+            }
+            opts.lifecycle?.onActivity?.('stderr');
+            if (shouldEmitHeartbeat(lastVisibleBroadcastTs, heartbeatSent)) {
+                heartbeatSent = true;
+                const elapsed = Math.round((Date.now() - lastVisibleBroadcastTs) / 1000);
+                console.log(`  ⏳ agent active (no visible event for ${elapsed}s)`);
+                broadcast('agent_tool', {
+                    agentId: agentLabel,
+                    icon: '⏳',
+                    label: 'working... (no visible progress)',
+                    ...empTag,
+                }, traceAudience);
+            }
+        });
+        let turnCompleted = false;
+        (async () => {
+            try {
+                const initResult = await appClient.initialize();
+                if (process.env["DEBUG"])
+                    console.log('[codex-app:init]', JSON.stringify(initResult).slice(0, 200));
+                if (isResume && resumeSessionId) {
+                    try {
+                        await appClient.resumeThread(resumeSessionId);
+                        console.log(`[codex-app:session] resumeThread OK: ${resumeSessionId.slice(0, 12)}...`);
+                    }
+                    catch (resumeErr) {
+                        console.warn(`[codex-app:session] resumeThread FAILED: ${resumeErr.message} — starting new thread`);
+                        if (empSid && opts.agentId) {
+                            clearEmployeeSession.run(opts.agentId);
+                        }
+                        await appClient.startThread({ instructions: sysPrompt, cwd: spawnCwd });
+                    }
+                }
+                else {
+                    await appClient.startThread({ instructions: sysPrompt, cwd: spawnCwd });
+                }
+                ctx.sessionId = appClient.threadId;
+                const useNativeResume = isResume && Boolean(resumeSessionId);
+                const codexAppPrompt = (!useNativeResume && historyBlock)
+                    ? `${historyBlock}\n\n[User Message]\n${prompt}`
+                    : prompt;
+                const turnDone = new Promise((resolveTurn, rejectTurn) => {
+                    appClient.once('turn/completed', () => {
+                        appClient.removeListener('error', rejectTurn);
+                        resolveTurn();
+                    });
+                    appClient.once('error', rejectTurn);
+                });
+                await appClient.startTurn(codexAppPrompt);
+                try {
+                    await turnDone;
+                    turnCompleted = true;
+                }
+                catch (turnErr) {
+                    console.warn(`[codex-app:turn] error during turn: ${turnErr.message}`);
+                }
+                flushCodexAppThinking();
+                const persistedThreadId = appClient.threadId;
+                if (persistedThreadId && persistMainSession(stripUndefined({
+                    ownerGeneration,
+                    forceNew,
+                    employeeSessionId: empSid,
+                    sessionId: persistedThreadId,
+                    isFallback: opts._isFallback,
+                    cli,
+                    model,
+                    resumeKey,
+                    effort: cfg.effort || '',
+                    skipSessionPersist: opts._skipSessionPersist === true,
+                }))) {
+                    console.log(`[jaw:session] saved ${cli} session=${persistedThreadId.slice(0, 12)}... (pre-shutdown)`);
+                }
+                if (!codexAppSettled) {
+                    codexAppSettled = true;
+                    const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, 0, cli);
+                    handleAgentExit({
+                        ctx, code: turnCompleted ? 0 : 1, cli, model, agentLabel, mainManaged, origin,
+                        resumeKey,
+                        prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                        isResume, wasKilled: false, wasSteer: false, smokeResult,
+                        effortDefault: '', costLine: '',
+                        resolve: resolve,
+                        activeProcesses,
+                        setActiveProcess: (v) => { activeProcess = v; },
+                        retryState: queueCtrl.retryState,
+                        fallbackState: queueCtrl.fallbackState,
+                        fallbackMaxRetries: FALLBACK_MAX_RETRIES,
+                        processQueue,
+                    }).catch((err) => {
+                        console.error(`[codex-app:handleAgentExit] ${err.message}`);
+                    });
+                }
+                await appClient.closeGracefully();
+            }
+            catch (err) {
+                console.error(`[codex-app:error] ${err.message}`);
+                ctx.stderrBuf += err.message;
+                appClient.kill();
+            }
+        })();
+        appClient.on('exit', (code, signal) => {
+            if (codexAppSettled)
+                return;
+            codexAppSettled = true;
+            appClient.cleanup();
+            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
+            opts.lifecycle?.onExit?.(code ?? null);
+            const killReason = consumeKillReason(appClient.proc?.pid);
+            if (code !== 0 && !killReason) {
+                console.warn(`[codex-app:unexpected-exit] code=${code} signal=${signal} threadId=${ctx.sessionId || 'none'}`);
+            }
+            const wasKilled = !!killReason;
+            const wasSteer = killReason === 'steer';
+            flushCodexAppThinking();
+            const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, code, cli);
+            const codexAppCode = turnCompleted ? 0 : (code ?? 1);
+            handleAgentExit({
+                ctx, code: codexAppCode, cli, model, agentLabel, mainManaged, origin,
+                resumeKey,
+                prompt, opts, cfg, ownerGeneration, forceNew, empSid,
+                isResume, wasKilled, wasSteer, smokeResult,
+                effortDefault: '', costLine: '',
+                resolve: resolve,
+                activeProcesses,
+                setActiveProcess: (v) => { activeProcess = v; },
+                retryState: queueCtrl.retryState,
+                fallbackState: queueCtrl.fallbackState,
+                fallbackMaxRetries: FALLBACK_MAX_RETRIES,
+                processQueue,
+            }).catch((err) => {
+                console.error('[jaw:lifecycle] handleAgentExit failed (codex-app):', err.message);
+            });
+        });
+        return { child, promise: resultPromise };
+    }
     // ─── Standard CLI branch (claude/codex/gemini/opencode) ──────
-    // DIFF-B: Windows needs shell:true to resolve .cmd shims (npm global installs)
+    // DIFF-B: Windows needs shell:true only when falling back to .cmd shims.
     const spawnCommand = cli === 'opencode' && process.platform !== 'win32'
         ? (resolvedOpencodeBinary || detected.path || cli)
-        : (process.platform === 'win32' ? cli : (detected.path || cli));
+        : (detected.path || cli);
+    const windowsSpawnUsesShell = process.platform === 'win32'
+        && !spawnCommand.toLowerCase().endsWith('.exe');
     const opencodeSpawnAudit = cli === 'opencode'
         ? buildOpencodeSpawnAudit({ args, cwd: spawnCwd, env: spawnEnv, binary: spawnCommand })
         : undefined;
@@ -1232,7 +1281,7 @@ export function spawnAgent(prompt, opts = {}) {
         cwd: spawnCwd,
         env: spawnEnv,
         stdio: ['pipe', 'pipe', 'pipe'],
-        ...(process.platform === 'win32' ? { shell: true } : {}),
+        ...(windowsSpawnUsesShell ? { shell: true } : {}),
     });
     if (mainManaged)
         activeProcess = child;
@@ -1242,7 +1291,7 @@ export function spawnAgent(prompt, opts = {}) {
     }
     activeProcesses.set(agentLabel, child);
     if (!opts.internal)
-        broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
+        broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...runtimeStatusMeta, ...empTag });
     if (mainManaged && !opts.internal)
         beginLiveRun(liveScope, cli);
     // ─── DIFF-A: error guard — prevent uncaught ENOENT crash ───
@@ -1285,6 +1334,9 @@ export function spawnAgent(prompt, opts = {}) {
     if (cli === 'claude') {
         child.stdin.write(withHistoryPrompt(prompt, historyBlock));
     }
+    else if (cli === 'claude-e' || cli === 'ai-e') {
+        child.stdin.write(isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
+    }
     else if (cli === 'codex' && !isResume) {
         const codexStdin = historyBlock
             ? `${historyBlock}\n\n[User Message]\n${prompt}`
@@ -1293,7 +1345,7 @@ export function spawnAgent(prompt, opts = {}) {
     }
     child.stdin.end();
     if (!opts.internal)
-        broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
+        broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...runtimeStatusMeta, ...empTag }, traceAudience);
     const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
     const ctx = {
         fullText: '',
@@ -1310,6 +1362,7 @@ export function spawnAgent(prompt, opts = {}) {
         hasActiveSubAgent: false,
         showReasoning: settings["showReasoning"] === true,
         outputTextStarted: false,
+        effectiveProvider,
         liveScope: effectiveLiveScope,
         parentLiveScope: parentLiveScopeForChild,
         traceRunId,
@@ -1367,10 +1420,29 @@ export function spawnAgent(prompt, opts = {}) {
             eventType: fieldString(asCliEventRecord(raw).type, '<no-type>'),
             raw,
         });
-        const event = discriminate(cli, raw);
+        // claude-e / ai-e Claude: intercept jaw_runtime events BEFORE discriminator
+        if ((cli === 'claude-e' || cli === 'ai-e') && isJawRuntimeEvent(raw)) {
+            const rtEvt = raw;
+            handleJawRuntimeEvent(rtEvt, agentLabel);
+            // Extract sessionId from session_started or interrupted
+            const evtName = rtEvt['event'];
+            if ((evtName === 'session_started' || evtName === 'interrupted') && typeof rtEvt['sessionId'] === 'string') {
+                ctx.sessionId = rtEvt['sessionId'];
+            }
+            if (evtName === 'error' && typeof rtEvt['message'] === 'string') {
+                const message = `[jaw:${cli}:error] ${rtEvt['message']}`;
+                ctx.stderrBuf = ctx.stderrBuf ? `${ctx.stderrBuf}\n${message}` : message;
+                ctx.traceLog.push(message);
+            }
+            return;
+        }
+        const dispatchCli = cli === 'ai-e'
+            ? (ctx.effectiveProvider === 'claude' ? 'claude-e' : (ctx.effectiveProvider || 'ai-e'))
+            : cli;
+        const event = discriminate(dispatchCli, raw);
         if (!event) {
             const type = fieldString(asCliEventRecord(raw).type, '<no-type>');
-            ctx.traceLog.push(`[cli:unknown-event] cli=${cli} type=${type} preview=${JSON.stringify(raw).slice(0, 200)}`);
+            ctx.traceLog.push(`[cli:unknown-event] cli=${cli} provider=${dispatchCli} type=${type} preview=${JSON.stringify(raw).slice(0, 200)}`);
             return;
         }
         recordOpencodeEvent(line, event);
@@ -1378,10 +1450,10 @@ export function spawnAgent(prompt, opts = {}) {
             console.log(`[jaw:event:${agentLabel}] ${cli} type=${event.type}`);
             console.log(`[jaw:raw:${agentLabel}] ${line.slice(0, 300)}`);
         }
-        logEventSummary(agentLabel, cli, event, ctx);
+        logEventSummary(agentLabel, dispatchCli, event, ctx);
         if (!ctx.sessionId)
-            ctx.sessionId = extractSessionId(cli, event);
-        extractFromEvent(cli, event, ctx, agentLabel, empTag);
+            ctx.sessionId = extractSessionId(dispatchCli, event);
+        extractFromEvent(dispatchCli, event, ctx, agentLabel, empTag);
         // Gemini watchdog: AFTER extractFromEvent sets geminiResultSeen
         if (cli === 'gemini' && ctx.geminiResultSeen && !geminiWatchdog) {
             geminiWatchdog = setTimeout(() => {
@@ -1396,7 +1468,7 @@ export function spawnAgent(prompt, opts = {}) {
         if (ctx.hasActiveSubAgent) {
             opts.lifecycle?.onActivity?.('heartbeat');
         }
-        const outputChunk = extractOutputChunk(cli, event, ctx);
+        const outputChunk = extractOutputChunk(dispatchCli, event, ctx);
         if (outputChunk) {
             if (ctx.liveScope)
                 appendLiveRunText(ctx.liveScope, outputChunk);
@@ -1478,24 +1550,16 @@ export function spawnAgent(prompt, opts = {}) {
         //   - error: code !== 0 && !wasKilled → classifyExitError
         //   - trace: if (traceText) traceText = `⏹️ [interrupted]…`
         handleAgentExit({
-            ctx, code, cli, model, agentLabel, mainManaged, origin,
+            ctx, code, cli, model, effectiveProvider, agentLabel, mainManaged, origin,
             resumeKey,
             prompt, opts, cfg, ownerGeneration, forceNew, empSid,
             isResume, wasKilled, wasSteer, smokeResult,
-            effortDefault: 'medium', costLine,
+            effortDefault: cli === 'grok' ? '' : 'medium', costLine,
             resolve: resolve,
             activeProcesses,
             setActiveProcess: (v) => { activeProcess = v; },
-            retryState: {
-                timer: retryPendingTimer,
-                resolve: retryPendingResolve,
-                origin: retryPendingOrigin,
-                setTimer: (t) => { retryPendingTimer = t; },
-                setResolve: (r) => { retryPendingResolve = r; },
-                setOrigin: (o) => { retryPendingOrigin = o; },
-                setIsEmployee: (v) => { retryPendingIsEmployee = v; },
-            },
-            fallbackState,
+            retryState: queueCtrl.retryState,
+            fallbackState: queueCtrl.fallbackState,
             fallbackMaxRetries: FALLBACK_MAX_RETRIES,
             processQueue,
         }).catch((err) => {