cli-jaw 2.17.62 → 2.17.63

package/dist/src/agent/spawn.js

@@ -7,7 +7,6 @@ import crypto from 'node:crypto';
 import { join } from 'path';
 import { spawn } from 'child_process';
 import { createTextStreamReader, sliceWithoutSplittingSurrogate } from './stream-text.js';
-import { userErrorText } from '../messaging/redact.js';
 import { resolveWindowsLaunchSpec, launchArgv } from '../core/windows-launch-spec.js';
 import { decideShellFallback } from '../core/windows-shell-fallback.js';
 /** Cap on retained stderr text used for error classification. */
@@ -20,17 +19,17 @@ import { publish as ssePublish } from '../core/event-bus.js';
 import { settleOnce } from '../orchestrator/request-registry.js';
 import { settings, UPLOADS_DIR, detectCli, getProjectDirs } from '../core/config.js';
 import { stripUndefined } from '../core/strip-undefined.js';
-import { clearEmployeeSession, getSession, insertMessage, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, migrateQueuedMessagesV1ToV2, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, getMaxMessageId, getSteerSalvageAfter, } from '../core/db.js';
+import { getSession, insertMessage, getRecentMessages, listQueuedMessages, insertQueuedMessage, deleteQueuedMessage, migrateQueuedMessagesV1ToV2, getSessionBucket, clearSessionBucket, setSessionBucketSnapshot, getMaxMessageId, getSteerSalvageAfter, } from '../core/db.js';
 import { buildTaskSnapshot } from '../memory/runtime.js';
 import { getActiveChatSession, getRemoteBoundSessionId } from '../core/chat-sessions.js';
 import { currentSessionScope } from '../core/session-context.js';
 import { getSystemPrompt, regenerateB } from '../prompt/builder.js';
 import { prependRemoteConversationContext } from '../prompt/conversation-context.js';
-import { extractSessionId, extractFromEvent, extractFromAcpUpdate, extractOutputChunk, logEventSummary, flushClaudeBuffers, flushOpenCodeBuffers } from './events.js';
+import { extractSessionId, extractFromEvent, extractOutputChunk, logEventSummary, flushClaudeBuffers, flushOpenCodeBuffers } from './events.js';
 import { detectSmokeResponse } from './smoke-detector.js';
 import { saveUpload as _saveUpload, buildMediaPrompt, buildMediaPromptMany } from '../../lib/upload.js';
 import { resolveMainCli, consumePendingBootstrapPrompt, peekPendingBootstrapPrompt } from '../core/main-session.js';
-import { getSessionOwnershipGeneration, isCurrentSessionOwner, persistMainSession, } from './session-persistence.js';
+import { getSessionOwnershipGeneration, isCurrentSessionOwner, } from './session-persistence.js';
 import { isCompactMarkerRow } from '../core/compact.js';
 import { isRuntimeSettingsMutationInFlight, waitForRuntimeSettingsIdle } from '../core/runtime-settings-gate.js';
 import { hasBlockingWorkers, hasPendingWorkerReplays, getActiveWorkers, clearAllWorkers, clearWorkersForScope, cancelWorker } from '../orchestrator/worker-registry.js';
@@ -38,50 +37,40 @@ import { sanitizeWorkerProgressTools } from '../orchestrator/worker-progress.js'
 import { handleAgentExit, setSpawnAgent, setMainMetaHandler } from './lifecycle-handler.js';
 import { buildServicePath } from '../core/runtime-path.js';
 import { formatCliUnavailableMessage, detectCliBinary } from '../core/cli-detect.js';
+import { claudeModelGateMessage } from '../cli/claude-default-model-boot.js';
 import { LOCAL_SESSION_SCOPE_ACTIVATION, resolveExecutionBinding } from '../orchestrator/scope.js';
 import { stripInterviewTracker } from '../orchestrator/sanitize.js';
-import { beginLiveRun, appendLiveRunText, setLiveRunTraceId, clearLiveRun, replaceLiveRunTools, appendLiveRunTool, getLiveRun } from './live-run-state.js';
+import { beginLiveRun, appendLiveRunText, setLiveRunTraceId, clearLiveRun, replaceLiveRunTools, appendLiveRunTool } from './live-run-state.js';
 import { setSpawnRef as setMemorySpawnRef, } from './memory-flush-controller.js';
 import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPermissions, mergeEnvWindowsSafe } from './spawn-env.js';
-import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt, withSteerContext, PROMPT_HISTORY_MAX_ROWS, PROMPT_HISTORY_MAX_CHARS, appendCursorAcceptedInstruction, buildCursorReplacementPrompt } from './prompt-context.js';
+import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt, withSteerContext, PROMPT_HISTORY_MAX_ROWS, PROMPT_HISTORY_MAX_CHARS, } from './prompt-context.js';
 import { attachWatchdog, DEFAULT_WATCHDOG_ABSOLUTE_HARD_CAP_MS } from './watchdog.js';
 import { buildOpencodeRuntimeSnapshot, buildOpencodeSpawnAudit, pushOpencodeRawEvent, resolveOpencodeBinary, } from './opencode-diagnostics.js';
-import { handoffRuntimeOutcome } from './runtime/outcome.js';
-import { AcpRuntimeSession } from './runtime/acp/runtime-session.js';
-import { MainReplacementOwnerMismatchError, replaceAcpMainTurn } from './runtime/replace-turn.js';
-import { AcpReplacement } from './runtime/acp/replacement.js';
+import { MainReplacementOwnerMismatchError } from './runtime/replace-turn.js';
 import { beginSteerInput, cancelSteerInputs, cancelAllSteerInputs } from './steer-input-guard.js';
-import { runNativeRuntime, NativeRunFailure } from './native-runtime-run.js';
 import { startClaudeNativeRun } from './claude-runtime-run.js';
 import { hasClaudeRuns, hasClaudeMainRuns, hasClaudeWorker, cancelClaudeWorker, cancelClaudeScope, cancelAllClaudeRuns } from './runtime/claude-run-controls.js';
-import { syncLiveTools } from './events/helpers.js';
-import { RuntimeProjection } from './runtime/projection.js';
-import { recordRuntimeEvent } from './runtime/events.js';
-import { CodexProjection } from './runtime/codex-projection.js';
-import { PiProjection } from './runtime/pi-projection.js';
-import { PiRawTrace } from './runtime/pi-raw-trace.js';
 import { createPrintActivity, finishPrintActivity } from './runtime/print-activity.js';
 import { isNativeAdapterImplemented, isNativeWorkerImplemented, isSwitchableNativeCli, resolveRuntimeTransport, runtimeSessionBucket } from './runtime/selection.js';
-import { clearNativeStartFailure, nativeStartFailure, recordNativeStartFailure } from './runtime/start-failure.js';
 import { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
 import { isRemoteTarget } from '../messaging/types.js';
 import { buildRemoteBindingKey } from '../messaging/session-key.js';
 import { runPinFields, sameRunConversation } from '../messaging/run-pin.js';
 import { isRetiredCliSelection, retiredRuntimeDiagnostic } from '../types/cli-engine.js';
 import { runBeforeSpawnChecks } from '../core/policy-hooks.js';
-import { appendTraceEvent, createTraceId, finalizeTraceRun, stampTraceTool, startTraceRun, updateTraceToolRow } from '../trace/store.js';
+import { appendTraceEvent, stampTraceTool, startTraceRun } from '../trace/store.js';
 import { AGY_COMPLETE_KILL_REASON, appendAgyFullText, classifyAgyTranscriptMode, describeAgyFinalSource, extractAgyConversationId, finalizeAgyFallbackText, AGY_PLANNER_ONLY_NOTICE, isAgyIntermediatePlannerText, formatAgyWatchdogContext, resolveAgyEmptyCloseError, formatAgyTimeoutMessage, getAgyQuietCompletionDelayMs, isAgyStaleSessionOutput, normalizeAgyCloseText, shouldFreezeAgyLiveDisplay, stripAgyPromptEchoPrefix, stripAgyResumeReplayPrefix, stripAgyResumeReplayPrefixes, } from './agy-runtime.js';
 import { detectAgyCapabilities } from './agy-capabilities.js';
 import { buildAgyBootstrapEnvelope, resolveAgyPromptOrder, } from './agy-bootstrap.js';
 import { startAgyTranscriptWatcher } from './agy-transcript-watcher.js';
-import { appendAssistantRawText, appendAssistantTextSegment, emitAgentTool, normalizeAssistantDisplayText, pushTrace, streamJsonMarksProgress } from './events/helpers.js';
+import { emitAgentTool, normalizeAssistantDisplayText, pushTrace, streamJsonMarksProgress } from './events/helpers.js';
 import { captureKiroSessionIdAfterExit, finalizeKiroFullText, flushKiroStdoutContext, isKiroPlainTextCli, isKiroStaleSessionOutput, processKiroStdoutChunk, spawnWithKiroSnapshot, } from './kiro-runtime.js';
 import { resolveCursorModelVariant } from './cursor-runtime.js';
-import { bindPiExecutionCancel, normalizePiSettings, openPiRpc } from './pi-runtime.js';
 import * as piExecutionControls from './pi-runtime.js';
-import { PiRuntimeSession } from './runtime/pi-runtime-session.js';
-import { piFailureOutcome } from './runtime/pi-turn.js';
-import { getEmployeeMcpServers } from './mcp-passthrough.js';
+import { runNativeAcpBackend } from './spawn/backend-native-acp.js';
+import { runCopilotBackend } from './spawn/backend-copilot.js';
+import { runPiBackend } from './spawn/backend-pi.js';
+import { runCodexAppBackend } from './spawn/backend-codex-app.js';
 // ─── State ───────────────────────────────────────────
 export const activeProcesses = new Map(); // agentId → child process
 export function hasActiveAgent(agentId) {
@@ -181,7 +170,6 @@ import { buildSteerStartedEvent } from './spawn/steer-event.js';
 import { armExitSettle, captureExitSettler, settleCapturedExit, settleExit, waitForExitSettled, } from './spawn/exit-settle.js';
 import { releaseChildOutputAfterExit } from './spawn/exit-drain.js';
 import { createNdjsonFramer, MAX_PENDING_LINE_CHARS } from './spawn/line-buffer.js';
-import { appendBoundedFullText } from './events/fulltext-bound.js';
 /** No provider turn was dispatched; preserve the captured cancellation receipt. */
 function stoppedBeforeStart(reason, traceRunId) {
     const stopCause = stopCauseFromKillReason(reason);
@@ -951,17 +939,10 @@ const warnedAgyCapabilityFallbacks = new Set();
 // ─── 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';
-import { CodexAppClient, CodexSteerError, isRecoverableResumeError } from './codex-app-client.js';
-import { acquireCodexAppRuntime, acquirePiRuntime, acquireCursorRuntime, acquireGrokRuntime, } from './runtime-pool.js';
-import { grokMainOptions } from './runtime/grok-main.js';
-import { acquireCodexAppLane, CodexHostGenerationStaleError, prepareCodexAppHost, } from './codex-host-pool.js';
-import { loadCatalogEfforts, resolveCatalogPath, validateModelEffort } from './codex-app-catalog.js';
-import { listenCodexAppTurnAdapter, applyCodexAppTextEvent, } from './codex-app-events.js';
 import { canGuardedAgyResume, resolveAgyNativeResume, shouldEmitHeartbeat, shouldResumeBucketSession } from './spawn/resume.js';
 export { canGuardedAgyResume, resolveAgyNativeResume, shouldEmitHeartbeat, shouldResumeBucketSession };
 import { createQueueController, FALLBACK_MAX_RETRIES } from './spawn/queue.js';
+import { stripSkillMentionBlock } from '../core/skill-mentions.js';
 function cleanupEmployeeTmpDir(cwd, workingDir, label) {
     if (cwd !== workingDir) {
         try {
@@ -1499,6 +1480,22 @@ export function spawnAgent(prompt, opts = {}) {
         cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
         return { child: null, promise: resultPromise };
     }
+    // ─── Claude model preflight: a model the installed CLI is known not to accept fails
+    // here, for print and native, fresh and resume, instead of as a raw API 400. ───
+    const claudeModelRefusal = cli === 'claude' ? claudeModelGateMessage(detected.path, runtimeModel) : null;
+    if (claudeModelRefusal) {
+        console.error(`[jaw:${agentLabel}] ${claudeModelRefusal}`);
+        if (mainManaged)
+            clearLiveRun(liveScope);
+        broadcast('agent_done', { ...runPin, text: `❌ ${claudeModelRefusal}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
+        resolve({ text: '', code: 1 });
+        if (mainManaged) {
+            releaseMainRun(scopeKey, null, ownerGeneration);
+            void processQueue(scopeKey);
+        }
+        cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
+        return { child: null, promise: resultPromise };
+    }
     if (cli === 'copilot') {
         console.log(`[jaw:${agentLabel}] Spawning: copilot --acp --model ${model} [${permissions}]`);
     }
@@ -1600,1833 +1597,21 @@ export function spawnAgent(prompt, opts = {}) {
         }
     }
     // ─── Native ACP main: protocol ownership is separate from application settlement. ───
-    if (runtimeTransport === 'native' && (cli === 'cursor' || cli === 'grok') && mainManaged) {
-        const grok = cli === 'grok';
-        const acquireRuntime = grok ? acquireGrokRuntime : acquireCursorRuntime;
-        const capturedRun = mainRun;
-        const nativeCwd = spawnCwd || process.cwd();
-        let traceRunId;
-        try {
-            traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: nativeCwd, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
-        }
-        catch {
-            traceRunId = createTraceId();
-            console.warn(`[runtime:${cli}] trace creation unavailable`);
-        }
-        const identity = Object.freeze({ runId: traceRunId, sessionId: chatSessionId, scope: scopeKey,
-            turnId: traceRunId, audience: traceAudience,
-            ...(opts.runtimeParentItemId ? { parentItemId: opts.runtimeParentItemId } : {}) });
-        const ctx = { fullText: '', traceLog: [], toolLog: [], seenToolKeys: new Set(),
-            hasClaudeStreamEvents: false, sessionId: null, cost: null, turns: null, duration: null, tokens: null,
-            stderrBuf: '', runStartedAt: Date.now(), origin,
-            ...(opts.requestId ? { requestId: opts.requestId } : {}),
-            liveScope: effectiveLiveScope, parentLiveScope: parentLiveScopeForChild, traceRunId, traceAudience };
-        const toolMirror = new Map();
-        const mirrorLimit = 160;
-        let facade = null, ownedLease = null;
-        let failedStart = null;
-        let nativeStarted = false, runtimeEnded = false, finalizeFailed = false, finalized = false;
-        let stopReason = null, queueRequested = false;
-        let capturedExit;
-        let selectedResult;
-        const ownsRun = () => !finalized && activeMainProcesses.get(scopeKey) === capturedRun
-            && isCurrentSessionOwner(persistenceOwner, scopeKey);
-        const cursorTarget = opts.target ? { ...opts.target } : undefined;
-        let acceptedContext = { messages: [], omitted: false };
-        const prepareReplacement = (instruction, partialText) => {
-            if (!ownsRun())
-                throw new Error('cursor_acp_owner_lost');
-            return { text: buildCursorReplacementPrompt({
-                    instruction: prependRemoteConversationContext(instruction, cursorTarget),
-                    originalRequest: promptForSnapshot, accepted: acceptedContext, partialText, sysPrompt,
-                }) };
-        };
-        const cursorReplaceHook = (instruction, commitInput) => replaceAcpMainTurn(facade, instruction, () => {
-            if (!ownsRun())
-                throw new Error('cursor_acp_owner_lost');
-            const next = appendCursorAcceptedInstruction(acceptedContext, instruction);
-            const result = commitInput();
-            if (result !== null && (typeof result === 'object' || typeof result === 'function')
-                && typeof result.then === 'function') {
-                void Promise.resolve(result).catch(() => undefined);
-                throw new Error('cursor_acp_async_input_commit');
-            }
-            acceptedContext = next;
-        });
-        const resultFor = (outcome) => ({
-            text: outcome.finalText?.trim() ?? '', code: outcome.status === 'done' ? 0 : outcome.status === 'stopped' ? 130 : 1,
-            runtimeOutcome: outcome, traceRunId,
-        });
-        // A runtime that never acquired a lease has no facade to ask, so the
-        // substring heuristic below could only ever produce the generic sentence
-        // for exactly the failures that need naming. The recorded start code is
-        // provider-independent by construction, so it decides the wording and is
-        // shown alongside it (#658).
-        const diagnostic = () => {
-            const code = nativeStarted ? undefined : nativeStartFailure(cli)?.code;
-            const named = code ? ` (${code})` : '';
-            if (grok)
-                return `Grok native runtime failed.${named} Check the native model, effort and existing CLI login.`;
-            const configFault = code ? code.startsWith('acp_config_') : facade?.lastError?.includes('config');
-            return configFault
-                ? `Cursor native model or effort is unsupported.${named} Choose an advertised model/effort; Composer models may require an unset effort.`
-                : `Cursor native runtime failed.${named} Check the native model, effort and existing CLI login.`;
-        };
-        const startFailedRuntime = () => {
-            if (!failedStart) {
-                failedStart = new RuntimeProjection(identity);
-                failedStart.start(cli);
-            }
-            return failedStart;
-        };
-        const closeFailedTrace = (outcome) => {
-            try {
-                finalizeTraceRun(traceRunId, outcome.status === 'stopped' ? 'interrupted' : outcome.status, outcome.status === 'error' ? diagnostic() : null, { onlyIfRunning: true });
-            }
-            catch {
-                console.warn(`[runtime:${cli}] failure trace finalization unavailable`);
-            }
-        };
-        const endRuntime = (end) => {
-            if (runtimeEnded)
-                return;
-            runtimeEnded = true;
-            if (facade?.claimTurnOutcome(traceRunId)) {
-                if (!facade.finalizeTurn(traceRunId, end))
-                    finalizeFailed = true;
-            }
-            else if (!nativeStarted) {
-                startFailedRuntime().close(end);
-            }
-            else {
-                finalizeFailed = true;
-                console.warn(`[runtime:${cli}] missing owned finalizer`);
-            }
-        };
-        const failRuntime = (outcome) => {
-            ctx.stallWatchdog?.stop();
-            const selected = ctx.runtimeTerminalAttempted && ctx.runtimeOutcome ? ctx.runtimeOutcome : {
-                status: stopReason || ctx.stallReason ? 'stopped' : 'error',
-                finalText: null, partialText: outcome.partialText,
-            };
-            const stopCause = selected.status === 'stopped' ? stopCauseFromKillReason(stopReason) : undefined;
-            handoffRuntimeOutcome(ctx, selected);
-            try {
-                // Admit the captured run before compatibility consumers retire it.
-                if (!nativeStarted && !runtimeEnded)
-                    startFailedRuntime();
-                if (!ctx.runtimeTerminalAttempted) {
-                    ctx.runtimeTerminalAttempted = true;
-                    broadcast('agent_done', { ...runPin, traceRunId, cli,
-                        text: selected.status === 'stopped' ? '' : `❌ ${diagnostic()}`, error: true,
-                        runtimeStatus: selected.status, runtimeFinality: selected.finalText === null ? 'absent' : 'present',
-                        ...(stopCause ? { stopCause } : {}),
-                    }, traceAudience);
-                }
-            }
-            finally {
-                try {
-                    endRuntime({ kind: 'turn-end', status: selected.status, finalText: selected.finalText,
-                        ...(selected.status === 'error' ? { error: diagnostic() } : {}) });
-                }
-                finally {
-                    closeFailedTrace(selected);
-                }
-            }
-            return selectedResult ?? { ...resultFor(selected), ...(stopCause ? { stopCause } : {}) };
-        };
-        let nativeRun;
-        const cancelHook = (reason) => {
-            stopReason ??= reason;
-            if (isLifecycleExitSettleReason(reason)) {
-                armExitSettle(scopeKey);
-                capturedExit ??= captureExitSettler(scopeKey);
-            }
-            nativeRun.cancel(reason);
-        };
-        const grokReplaceHook = async (text, commitInput) => {
-            if (!ownsRun())
-                return { kind: 'race', reason: 'native-owner-lost' };
-            const result = await replaceAcpMainTurn(facade, text, commitInput);
-            return result.kind === 'unavailable' && !ownsRun() ? { kind: 'race', reason: 'native-owner-lost' } : result;
-        };
-        const replaceHook = grok ? grokReplaceHook : cursorReplaceHook;
-        if (grok)
-            capturedRun.replaceTurn = replaceHook;
-        capturedRun.starting = true;
-        nativeRun = runNativeRuntime({
-            turnId: traceRunId, prompt: { text: promptForArgs }, isCurrent: ownsRun,
-            acquire: async (signal) => {
-                const lease = await acquireRuntime({
-                    key: { scopeKey, cwd: nativeCwd, model: runtimeModel === 'default' ? '' : runtimeModel, effort, permissions },
-                    binary: detected.path || (grok ? 'grok' : 'cursor-agent'), env: spawnEnv, promptTimeoutMs: resolvedAgyPrintTimeoutMs,
-                    persistenceOwner, isCurrentOwner: token => isCurrentSessionOwner(token, scopeKey), canAcquire: ownsRun,
-                    storedSessionId: resumeSessionId,
-                    forceNew: forceNew || Boolean(slackToolGrant),
-                    ...(slackToolGrant ? { lifetime: 'request' } : {}),
-                    signal,
-                });
-                facade = new AcpRuntimeSession(lease.session, { provider: cli, deferTurnEnd: true,
-                    ...(grok ? grokMainOptions : { createReplacement: io => new AcpReplacement(io), prepareReplacement }),
-                    getTurnContext: () => ({ ...identity, isCurrent: ownsRun }),
-                    capabilities: { transport: 'native', steer: 'cancel-reprompt', resume: lease.session.agentCapabilities['loadSession'] === true,
-                        tools: true, toolOutput: true, approvals: true, questions: false, images: false, subagents: false },
-                    record: (context, body) => {
-                        if (body.kind === 'turn-start')
-                            nativeStarted = true;
-                        return recordRuntimeEvent(context, body);
-                    },
-                });
-                ownedLease = { child: lease.session.child, session: facade,
-                    release: () => lease.release(), retire: reason => lease.retire(reason) };
-                return ownedLease;
-            },
-            ready: lease => {
-                if (!ownsRun())
-                    throw new Error('native_run_owner_lost');
-                capturedRun.process = lease.child;
-                // This start reached its lease, so the previous start failure is spent.
-                clearNativeStartFailure(cli);
-                if (!opts._skipInsert)
-                    insertMessage.run('user', prompt, cli, runtimeModel, nativeCwd, chatSessionId);
-                capturedRun.starting = false;
-                ctx.sessionId = lease.session.nativeSessionId || null;
-                if (capturedRun.cancelPending === cancelHook)
-                    delete capturedRun.cancelPending;
-                capturedRun.cancelTurn = cancelHook;
-                capturedRun.replaceTurn = replaceHook;
-                beginLiveRun(liveScope, cli);
-                setLiveRunTraceId(liveScope, traceRunId);
-                const activityIdentity = { runId: traceRunId, sessionId: chatSessionId,
-                    scope: scopeKey, origin, ...(opts.requestId ? { requestId: opts.requestId } : {}) };
-                const onIo = () => {
-                    if (!ownsRun())
-                        return;
-                    try {
-                        opts.lifecycle?.onActivity?.('native-runtime', activityIdentity);
-                    }
-                    catch {
-                        console.warn(`[runtime:${cli}] liveness observer failed`);
-                    }
-                };
-                const dispose = () => {
-                    ctx.stallWatchdog?.stop();
-                    if (capturedRun.replaceTurn === replaceHook)
-                        delete capturedRun.replaceTurn;
-                    lease.child.stdout?.off('data', onIo);
-                    lease.child.stderr?.off('data', onIo);
-                };
-                try {
-                    lease.child.stdout?.on('data', onIo);
-                    lease.child.stderr?.on('data', onIo);
-                    ctx.stallWatchdog = attachWatchdog(lease.child, agentLabel, reason => {
-                        ctx.stallReason = reason;
-                        nativeRun.cancel(reason);
-                    });
-                    broadcast('agent_status', { running: true, status: 'running', agentId: agentLabel, cli,
-                        scope: scopeKey, sessionId: chatSessionId, traceRunId,
-                        ...(opts.requestId ? { requestId: opts.requestId } : {}) }, traceAudience);
-                    return dispose;
-                }
-                catch (error) {
-                    dispose();
-                    throw error;
-                }
-            },
-            event: (event) => {
-                if (event.kind === 'usage') {
-                    ctx.tokens = { ...(event.inputTokens === undefined ? {} : { input_tokens: event.inputTokens }),
-                        ...(event.outputTokens === undefined ? {} : { output_tokens: event.outputTokens }),
-                        ...(event.cachedTokens === undefined ? {} : { cached_input_tokens: event.cachedTokens }) };
-                }
-                if (event.kind !== 'tool')
-                    return;
-                let tool = toolMirror.get(event.itemId);
-                if (!tool && toolMirror.size >= mirrorLimit)
-                    return;
-                const detail = [event.input, event.output, event.detail].filter(value => value !== undefined && value !== '').join('\n');
-                if (!tool) {
-                    tool = { icon: '🔧', label: event.name, toolType: 'tool', status: event.status, detail,
-                        stepRef: `runtime:${traceRunId}:${event.itemId}` };
-                    stampTraceTool(tool, ctx, 'tool');
-                    toolMirror.set(event.itemId, tool);
-                }
-                else {
-                    Object.assign(tool, { label: event.name, status: event.status, detail });
-                    updateTraceToolRow(tool);
-                }
-                ctx.toolLog = [...toolMirror.values()];
-                syncLiveTools(ctx);
-            },
-            settle: async (lease, outcome, problem) => {
-                // Immediate Stop can settle without entering acquire/ready/send.
-                if (!nativeStarted && !runtimeEnded)
-                    startFailedRuntime();
-                ctx.stallWatchdog?.stop();
-                ctx.fullText = outcome.partialText;
-                if (problem)
-                    ctx.stderrBuf = problem;
-                if (lease)
-                    ctx.sessionId = lease.session.nativeSessionId || null;
-                const recordedReason = consumeKillReason(lease?.child.pid);
-                const killReason = stopReason || recordedReason;
-                const wasKilled = Boolean(killReason), wasSteer = isLifecycleSteerReason(killReason);
-                const code = outcome.status === 'done' ? 0 : outcome.status === 'stopped' ? 130 : 1;
-                handoffRuntimeOutcome(ctx, outcome);
-                try {
-                    opts.lifecycle?.onExit?.(code);
-                }
-                catch {
-                    console.warn(`[runtime:${cli}] exit observer failed`);
-                }
-                await handleAgentExit({ onRuntimeEnd: endRuntime,
-                    ctx, code, cli, model: runtimeModel, effectiveProvider, agentLabel, mainManaged, origin,
-                    killReason,
-                    resumeKey, prompt, opts, cfg: { ...cfg, effort }, ownerGeneration, persistenceOwner, forceNew, empSid,
-                    isResume, wasKilled, wasSteer, smokeResult: detectSmokeResponse(outcome.finalText ?? '', ctx.toolLog, code, cli),
-                    effortDefault: effort, costLine: '', resolve: value => { selectedResult ??= value; },
-                    activeProcesses, scopeKey, runtimeTransport, scopedBucket: currentBucket, chatSessionId,
-                    childProcess: lease?.child ?? null, releaseMainRun,
-                    retryState: queueCtrl.retryStateForScope(scopeKey), fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
-                    fallbackMaxRetries: FALLBACK_MAX_RETRIES, processQueue: () => { queueRequested = true; },
-                });
-                if (finalizeFailed && lease)
-                    await lease.retire(new Error('native_runtime_finalization_failed'));
-                return selectedResult ?? resultFor(ctx.runtimeOutcome ?? outcome);
-            },
-            failed: (error, lease, outcome) => {
-                // A null lease means acquire never returned: the runtime failed to
-                // start, which is the only class this diagnostic answers (#658).
-                // Teardown faults after a claimed answer are a different failure.
-                if (!lease)
-                    recordNativeStartFailure(cli, error);
-                return failRuntime(outcome);
-            },
-            finalized: () => {
-                finalized = true;
-                try {
-                    if (capturedRun.cancelPending === cancelHook)
-                        delete capturedRun.cancelPending;
-                    if (capturedRun.cancelTurn === cancelHook)
-                        delete capturedRun.cancelTurn;
-                    if (capturedRun.replaceTurn === replaceHook)
-                        delete capturedRun.replaceTurn;
-                    if (activeMainProcesses.get(scopeKey) === capturedRun) {
-                        const child = ownedLease?.child ?? null;
-                        if (releaseMainRun(scopeKey, child, ownerGeneration)) {
-                            if (getLiveRun(liveScope).traceRunId === traceRunId)
-                                clearLiveRun(liveScope);
-                            broadcast('agent_status', { running: false, agentId: agentLabel, cli, scope: scopeKey,
-                                sessionId: chatSessionId, traceRunId }, traceAudience);
-                        }
-                    }
-                }
-                finally {
-                    // Projection/listener/cleanup failure must not leave our durable
-                    // row running or rewrite a lifecycle that already selected a result.
-                    if (ctx.runtimeOutcome)
-                        closeFailedTrace(ctx.runtimeOutcome);
-                    settleCapturedExit(scopeKey, capturedExit);
-                    // Exceptional settlement can release the slot before lifecycle requests its normal wake.
-                    if (queueRequested || !activeMainProcesses.has(scopeKey))
-                        void processQueue(scopeKey);
-                }
-            },
-        });
-        capturedRun.cancelPending = cancelHook;
-        let resolved = false;
-        const resolveOnce = (value) => { if (!resolved) {
-            resolved = true;
-            resolve(value);
-        } };
-        nativeRun.done.then(resolveOnce, error => {
-            const prior = ctx.runtimeTerminalAttempted && ctx.runtimeOutcome ? ctx.runtimeOutcome
-                : error instanceof NativeRunFailure ? { ...error.outcome,
-                    status: stopReason || ctx.stallReason || error.outcome.status === 'stopped' ? 'stopped' : 'error', finalText: null }
-                    : { status: 'error', finalText: null, partialText: ctx.fullText };
-            resolveOnce(selectedResult ?? resultFor(prior));
-        });
-        return { child: null, promise: resultPromise };
-    }
+    // Backend branches live in ./spawn/backend-*.ts; they read these values, captured here,
+    // and never write back (no spawnAgent binding they read is reassigned after this point).
+    const backendLocals = { agentLabel, bucketSessionId, cfg, chatSessionId, cleanupPiEmployee, cli, codexMultiplexMain, currentBucket, detected, effectiveLiveScope, effectiveProvider, effort, empSid, empTag, forceNew, historyBlock, isEmployee, isResume, liveScope, mainManaged, mainRun, model, opts, origin, ownerGeneration, parentLiveScopeForChild, permissions, persistenceOwner, prompt, promptForArgs, promptForSnapshot, resolve: (value) => resolve(value), resolvedAgyPrintTimeoutMs, resultPromise, resumeKey, resumeSessionId, runPin, runtimeModel, runtimeTransport, scopeKey, slackToolGrant, spawnCwd, spawnEnv, sysPrompt, traceAudience };
+    const backendHost = { CODEX_APP_ACQUIRE_RETRY_BACKOFF_MAX_MS, DEFAULT_CODEX_APP_ACQUIRE_WAIT_MS, DEFAULT_CODEX_APP_TURN_ABS_MS, DEFAULT_CODEX_APP_TURN_IDLE_MS, STDERR_BUF_CAP, activeMainProcesses, activeProcesses, appendParentLiveRunTool, broadcastAgentOutput, buildHistoryBlock, cancelOwnedPiProcess, cleanupEmployeeTmpDir, clearMainLiveRunOnStop, configuredPositiveMs, consumeKillReason, piProfileFingerprintKey, processQueue, queueCtrl, registerActiveProcess, releaseMainRun, stoppedBeforeStart };
+    if (runtimeTransport === 'native' && (cli === 'cursor' || cli === 'grok') && mainManaged)
+        return runNativeAcpBackend(backendLocals, backendHost);
     // ─── Copilot ACP branch ──────────────────────
-    if (cli === 'copilot') {
-        // Write model + reasoning_effort to ~/.copilot/config.json (CLI flags unsupported)
-        try {
-            const cfgPath = join(os.homedir(), '.copilot', 'config.json');
-            const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-            let changed = false;
-            // Sync model
-            if (model && model !== 'default') {
-                if (cfg.model !== model) {
-                    cfg.model = model;
-                    changed = true;
-                }
-            }
-            // Sync effort
-            if (effort) {
-                if (cfg.reasoning_effort !== effort) {
-                    cfg.reasoning_effort = effort;
-                    changed = true;
-                }
-            }
-            else if (cfg.reasoning_effort) {
-                delete cfg.reasoning_effort;
-                changed = true;
-            }
-            if (changed)
-                fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
-        }
-        catch (e) {
-            console.warn('[jaw:copilot] config.json sync failed:', e.message);
-        }
-        const acp = new AcpClient({ model, workDir: spawnCwd, permissions, env: spawnEnv });
-        acp.spawn();
-        const child = acp.proc;
-        if (!child) {
-            throw new Error('Copilot ACP process was not created');
-        }
-        if (mainManaged)
-            mainRun.process = child;
-        else
-            registerActiveProcess(agentLabel, child);
-        if (!opts.internal)
-            broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
-        if (mainManaged && !opts.internal)
-            beginLiveRun(liveScope, cli);
-        // ─── DIFF-C: ACP error guard — prevent uncaught EventEmitter crash ───
-        let acpSettled = false; // guard: error→exit can fire sequentially
-        acp.on('error', (err) => {
-            if (acpSettled)
-                return;
-            acpSettled = true;
-            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
-            opts.lifecycle?.onExit?.(null);
-            const msg = `Copilot ACP spawn failed: ${err.message}`;
-            console.error(`[acp:error] ${msg}`);
-            if (mainManaged) {
-                releaseMainRun(scopeKey, child, ownerGeneration);
-                clearLiveRun(liveScope);
-                broadcast('agent_status', { running: false, agentId: agentLabel });
-            }
-            else {
-                activeProcesses.delete(agentLabel);
-            }
-            broadcast('agent_done', { ...runPin, text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
-            finishPrintActivity(ctx, { kind: 'turn-end', status: 'error', finalText: null, error: msg });
-            resolve({ text: '', code: 1 });
-            if (mainManaged)
-                void processQueue(scopeKey);
-        });
-        if (mainManaged && !opts.internal && !opts._skipInsert) {
-            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, chatSessionId);
-        }
-        if (!opts.internal)
-            broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
-        if (mainManaged && !opts.internal)
-            beginLiveRun(liveScope, cli);
-        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
-        if (mainManaged && !opts.internal)
-            setLiveRunTraceId(liveScope, traceRunId);
-        const ctx = {
-            fullText: '', traceLog: [], toolLog: [], seenToolKeys: new Set(),
-            hasClaudeStreamEvents: false, sessionId: null, cost: null,
-            turns: null, duration: null, tokens: null, stderrBuf: '',
-            thinkingBuf: '',
-            runStartedAt: Date.now(),
-            ...(opts.requestId ? { requestId: opts.requestId } : {}),
-            ...(origin ? { origin } : {}),
-            liveScope: effectiveLiveScope,
-            parentLiveScope: parentLiveScopeForChild,
-            traceRunId,
-            traceAudience,
-            activityIdentity: { sessionId: chatSessionId, scope: scopeKey },
-        };
-        ctx.printActivity = createPrintActivity({ runId: traceRunId, sessionId: chatSessionId,
-            scope: scopeKey, turnId: traceRunId, audience: traceAudience }, cli);
-        // Flush accumulated 💭 thinking buffer as a single merged event
-        function flushThinking() {
-            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);
-                appendParentLiveRunTool(ctx, tool);
-                emitAgentTool(ctx, agentLabel, tool, empTag);
-            }
-            ctx.thinkingBuf = '';
-        }
-        // session/update → broadcast mapping
-        let replayMode = false; // Phase 17.2: suppress events during loadSession replay
-        let lastVisibleBroadcastTs = Date.now();
-        let heartbeatSent = false;
-        acp.on('session/update', (params) => {
-            if (replayMode)
-                return; // 리플레이 중 모든 이벤트 무시
-            const update = asCliEventRecord(asCliEventRecord(params)["update"]);
-            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: fieldString(update.sessionUpdate, 'session/update'), raw: params });
-            const parsed = extractFromAcpUpdate(params, ctx);
-            if (!parsed)
-                return;
-            if (parsed.tool) {
-                const parsedTool = parsed.tool;
-                // Buffer 💭 thought chunks → flush when different event arrives
-                if (parsedTool.icon === '💭') {
-                    ctx.printActivity?.reasoning(parsedTool.detail || parsedTool.label, 'append');
-                    ctx.thinkingBuf += parsedTool.detail || parsedTool.label;
-                    return;
-                }
-                // Non-💭 tool → flush any pending thinking first
-                flushThinking();
-                // [I3] Include stepRef + status in dedupe key to allow repeated same-name tool calls
-                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);
-                    appendParentLiveRunTool(ctx, parsedTool);
-                    emitAgentTool(ctx, agentLabel, parsedTool, empTag);
-                    // Reset heartbeat gate on actually visible broadcast (not 💭)
-                    lastVisibleBroadcastTs = Date.now();
-                    heartbeatSent = false;
-                }
-            }
-            if (parsed.text) {
-                flushThinking();
-                // NARRATION-BOUNDARY-01: a changed ACP messageId means a NEW
-                // assistant message, so what accumulated was progress narration
-                // rather than part of this answer. External channels deliver text
-                // derived from ctx.fullText; the live UI keeps the narration via
-                // the agent_output broadcast below. Chunks without a messageId
-                // carry no boundary signal and simply accumulate.
-                if (parsed.messageId && ctx.acpAssistantMessageId !== undefined
-                    && ctx.acpAssistantMessageId !== parsed.messageId) {
-                    ctx.printActivity?.nextMessage();
-                    ctx.fullText = '';
-                    ctx.outputTextStarted = false;
-                }
-                if (parsed.messageId)
-                    ctx.acpAssistantMessageId = parsed.messageId;
-                ctx.printActivity?.message(parsed.text, 'append', 'unknown');
-                const segment = appendAssistantTextSegment(ctx, parsed.text);
-                if (segment) {
-                    broadcastAgentOutput(ctx, agentLabel, cli, segment, empTag, traceAudience);
-                    lastVisibleBroadcastTs = Date.now();
-                    heartbeatSent = false;
-                }
-            }
-            opts.lifecycle?.onActivity?.('acp');
-        });
-        // [P2-3.14] session/cancelled → route through extractFromAcpUpdate for UI notification
-        acp.on('session/cancelled', (params) => {
-            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: 'session/cancelled', raw: params });
-            const parsed = extractFromAcpUpdate({
-                update: { sessionUpdate: 'session_cancelled', ...(params || {}) },
-            });
-            if (parsed?.tool) {
-                stampTraceTool(parsed.tool, ctx, parsed.tool.toolType || 'tool');
-                ctx.toolLog.push(parsed.tool);
-                if (ctx.liveScope)
-                    replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
-                appendParentLiveRunTool(ctx, parsed.tool);
-                emitAgentTool(ctx, agentLabel, parsed.tool, empTag);
-            }
-        });
-        // [P2-3.15] session/request_permission → audit record in toolLog
-        acp.on('session/request_permission', (params) => {
-            appendTraceEvent({ runId: ctx.traceRunId, source: 'acp_raw', eventType: 'session/request_permission', raw: params });
-            const parsed = extractFromAcpUpdate({
-                update: { sessionUpdate: 'request_permission', ...(params || {}) },
-            });
-            if (parsed?.tool) {
-                stampTraceTool(parsed.tool, ctx, parsed.tool.toolType || 'tool');
-                ctx.toolLog.push(parsed.tool);
-                if (ctx.liveScope)
-                    replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
-                appendParentLiveRunTool(ctx, parsed.tool);
-                emitAgentTool(ctx, agentLabel, parsed.tool, empTag);
-            }
-        });
-        // stderr_activity → stderrBuf accumulation + conditional heartbeat
-        acp.on('stderr_activity', (text) => {
-            appendTraceEvent({ runId: ctx.traceRunId, source: 'stderr', eventType: 'stderr_activity', raw: text });
-            // Accumulate stderr for diagnostics (capped)
-            if (ctx.stderrBuf.length < 4000) {
-                ctx.stderrBuf += text + '\n';
-            }
-            opts.lifecycle?.onActivity?.('stderr');
-            // Conditional heartbeat: visible progress absent for N seconds
-            if (shouldEmitHeartbeat(lastVisibleBroadcastTs, heartbeatSent)) {
-                heartbeatSent = true;
-                const elapsed = Math.round((Date.now() - lastVisibleBroadcastTs) / 1000);
-                console.log(`  ⏳ agent active (no visible event for ${elapsed}s)`);
-                emitAgentTool(ctx, agentLabel, {
-                    icon: '⏳',
-                    label: 'working... (no visible progress)',
-                }, empTag);
-            }
-        });
-        // Run ACP flow
-        let promptCompleted = false;
-        (async () => {
-            try {
-                const initResult = await acp.initialize();
-                if (process.env["DEBUG"])
-                    console.log('[acp:init]', JSON.stringify(initResult).slice(0, 200));
-                replayMode = true; // Phase 17.2: mute during session load
-                let loadSessionOk = false;
-                if (isResume && resumeSessionId) {
-                    try {
-                        await acp.loadSession(resumeSessionId);
-                        loadSessionOk = true;
-                        console.log(`[acp:session] loadSession OK: ${resumeSessionId.slice(0, 12)}...`);
-                    }
-                    catch (loadErr) {
-                        console.warn(`[acp:session] loadSession FAILED: ${loadErr.message} — falling back to createSession`);
-                        if (empSid && opts.agentId) {
-                            clearEmployeeSession.run(opts.agentId);
-                            console.warn(`[acp:session] cleared stale employee resume for ${opts.agentId}`);
-                        }
-                        await acp.createSession(spawnCwd, getEmployeeMcpServers());
-                    }
-                }
-                else {
-                    await acp.createSession(spawnCwd, getEmployeeMcpServers());
-                }
-                replayMode = false; // Phase 17.2: unmute after session load
-                ctx.sessionId = acp.sessionId;
-                // Reset accumulated text from loadSession replay (ACP replays full history)
-                ctx.fullText = '';
-                ctx.toolLog = [];
-                ctx.seenToolKeys.clear();
-                ctx.thinkingBuf = ''; // Phase 17.2: clear replay thinking too
-                if (mainManaged && !opts.internal) {
-                    beginLiveRun(liveScope, cli);
-                    if (ctx.traceRunId)
-                        setLiveRunTraceId(liveScope, ctx.traceRunId);
-                }
-                // If loadSession failed (or not resuming), inject history into prompt
-                const needsHistoryFallback = isResume && !loadSessionOk;
-                const fallbackHistory = needsHistoryFallback && !opts._skipHistory ? buildHistoryBlock(prompt, settings["workingDir"], chatSessionId) : '';
-                const acpPrompt = needsHistoryFallback
-                    ? withHistoryPrompt(prompt, fallbackHistory)
-                    : (isResume ? prompt : withHistoryPrompt(prompt, historyBlock));
-                const acpPromptWithSteer = withSteerContext(acpPrompt, opts.steerContext);
-                const { promise: promptPromise } = acp.prompt(acpPromptWithSteer);
-                const promptResult = await promptPromise;
-                promptCompleted = true;
-                if (process.env["DEBUG"])
-                    console.log('[acp:prompt:result]', JSON.stringify(promptResult).slice(0, 200));
-                // Save session BEFORE shutdown — acp.shutdown() causes SIGTERM (code=null),
-                // which skips the exit handler's code===0 gate, losing session continuity.
-                const persistedAcpSessionId = ctx.sessionId;
-                if (persistedAcpSessionId && persistMainSession(stripUndefined({
-                    persistenceOwner,
-                    scopeKey,
-                    forceNew,
-                    employeeSessionId: empSid,
-                    sessionId: persistedAcpSessionId,
-                    isFallback: opts._isFallback,
-                    cli,
-                    model,
-                    resumeKey,
-                    effort: cfg.effort || '',
-                    skipSessionPersist: opts._skipSessionPersist === true,
-                    // Without this the save falls back to the bare, unscoped bucket, and a
-                    // successful turn in another session writes its vendor id into the row
-                    // the default session resumes from. The exit handler below passes the
-                    // same value; this path runs first and must not disagree with it.
-                    runtimeTransport,
-                    scopedBucket: currentBucket,
-                }))) {
-                    console.log(`[jaw:session] saved ${cli} session=${persistedAcpSessionId.slice(0, 12)}... (pre-shutdown)`);
-                }
-                await acp.shutdown();
-            }
-            catch (err) {
-                console.error(`[acp:error] ${err.message}`);
-                if (ctx.stderrBuf.length < 4000)
-                    ctx.stderrBuf += err.message;
-                acp.kill();
-            }
-        })();
-        acp.on('exit', ({ code, signal }) => {
-            if (acpSettled)
-                return; // error handler already resolved
-            acpSettled = true;
-            cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
-            opts.lifecycle?.onExit?.(code ?? null);
-            // [I2] Consume per-process kill reason
-            const acpKillReason = consumeKillReason(acp.proc?.pid);
-            if (code !== 0 && !acpKillReason) {
-                console.warn(`[acp:unexpected-exit] code=${code} signal=${signal} sessionId=${ctx.sessionId || 'none'}`);
-            }
-            const wasKilled = !!acpKillReason;
-            const wasSteer = isLifecycleSteerReason(acpKillReason);
-            flushThinking(); // Flush any remaining thinking buffer
-            const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, code, cli);
-            const acpCode = promptCompleted ? 0 : (code ?? 1);
-            // Delegated to lifecycle-handler.ts → handleAgentExit:
-            //   - smoke continuation (guarded by !wasSteer)
-            //   - output: ⏹️ [interrupted] prefix (wasSteer && mainManaged && !opts.internal)
-            //   - error: code !== 0 && !wasKilled → classifyExitError
-            //   - trace: if (traceText) traceText = `⏹️ [interrupted]…`
-            handleAgentExit({
-                ctx, code: acpCode, childExitCode: code, cli, model, agentLabel, mainManaged, origin,
-                killReason: acpKillReason,
-                onRuntimeEnd: end => ctx.printActivity?.finish(end),
-                resumeKey,
-                prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
-                isResume, wasKilled, wasSteer, smokeResult,
-                effortDefault: '', costLine: '',
-                resolve: resolve,
-                activeProcesses,
-                scopeKey,
-                runtimeTransport,
-                scopedBucket: currentBucket,
-                chatSessionId,
-                childProcess: child,
-                releaseMainRun,
-                retryState: queueCtrl.retryStateForScope(scopeKey),
-                fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
-                fallbackMaxRetries: FALLBACK_MAX_RETRIES,
-                processQueue,
-            }).catch((err) => {
-                console.error('[jaw:lifecycle] handleAgentExit failed (ACP):', err.message);
-            }).finally(() => settleExit(scopeKey));
-        });
-        return { child, promise: resultPromise };
-    }
+    if (cli === 'copilot')
+        return runCopilotBackend(backendLocals, backendHost);
     // ─── Pi RPC branch ─────────────────────────────
-    if (cli === 'pi') {
-        let piExit = captureExitSettler(scopeKey);
-        const settlePiExit = () => { settleCapturedExit(scopeKey, piExit); };
-        const pi = normalizePiSettings(settings["pi"]);
-        const profileId = cfg.provider || pi.defaultProfileId;
-        const profile = pi.profiles.find((entry) => entry.id === profileId) || pi.profiles[0];
-        if (!profile) {
-            throw new Error('Pi profile is not configured');
-        }
-        const piSessionId = isResume && bucketSessionId ? bucketSessionId : '';
-        console.log(`[jaw:pi] isResume=${isResume}, bucketSessionId=${bucketSessionId || 'none'}, piSessionId=${piSessionId || 'new'}`);
-        const piPrompt = withSteerContext(piSessionId ? prompt : withHistoryPrompt(prompt, historyBlock), opts.steerContext);
-        const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
-        const ctx = {
-            fullText: '',
-            traceLog: [],
-            toolLog: [],
-            seenToolKeys: new Set(),
-            hasClaudeStreamEvents: false,
-            runStartedAt: Date.now(),
-            ...(opts.requestId ? { requestId: opts.requestId } : {}),
-            ...(origin ? { origin } : {}),
-            sessionId: null,
-            cost: null,
-            turns: null,
-            duration: null,
-            tokens: null,
-            stderrBuf: '',
-            hasActiveSubAgent: false,
-            showReasoning: settings["showReasoning"] === true,
-            outputTextStarted: false,
-            effectiveProvider: profile.id,
-            thinkingBuf: '',
-            liveOutputText: '',
-            liveScope: effectiveLiveScope,
-            parentLiveScope: parentLiveScopeForChild,
-            traceRunId,
-            traceAudience,
-            activityIdentity: { sessionId: chatSessionId, scope: scopeKey },
-        };
-        const activity = new RuntimeProjection({
-            runId: traceRunId, sessionId: chatSessionId, scope: scopeKey,
-            turnId: traceRunId, audience: traceAudience,
-            ...(opts.runtimeParentItemId ? { parentItemId: opts.runtimeParentItemId } : {}),
-        });
-        const piProjection = new PiProjection(activity);
-        const rawTrace = new PiRawTrace(traceRunId, appendTraceEvent, () => activity.report('persistence'));
-        activity.start('pi');
-        const onPiRawRecord = (raw) => {
-            rawTrace.record(raw);
-            piProjection.observeRecord(raw);
-        };
-        function flushPiThinking() {
-            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;
-                const tool = stripUndefined({ icon: '💭', label, toolType: 'thinking', detail: merged });
-                stampTraceTool(tool, ctx, 'thinking');
-                ctx.toolLog.push(tool);
-                if (ctx.liveScope)
-                    replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
-                appendParentLiveRunTool(ctx, tool);
-                emitAgentTool(ctx, agentLabel, tool, empTag);
-            }
-            ctx.thinkingBuf = '';
-        }
-        const piToolDiscipline = [
-            '[Pi Tool Discipline]',
-            'Your available tools are strictly lowercase: read, bash, edit, write, grep, find, ls.',
-            'Capitalized variants (Read, Bash, Edit, Write, Grep, Find, Ls) do NOT exist and will fail.',
-        ].join('\n');
-        const piSysPrompt = sysPrompt ? `${sysPrompt}\n\n${piToolDiscipline}` : piToolDiscipline;
-        const onPiEvent = (event) => {
-            piProjection.observe(event);
-            try {
-                opts.lifecycle?.onActivity?.('pi-rpc');
-            }
-            catch {
-                console.warn('[jaw:pi] activity observer failed');
-            }
-            if (event.kind === 'thinking') {
-                ctx.thinkingBuf = (ctx.thinkingBuf || '') + event.text;
-                return;
-            }
-            if (event.kind === 'text') {
-                flushPiThinking();
-                const delta = String(event.text || '');
-                if (!delta)
-                    return;
-                {
-                    // D3: bound fullText — see events/fulltext-bound.ts.
-                    const bounded = appendBoundedFullText(ctx.fullText, delta);
-                    ctx.fullText = bounded.text;
-                    if (bounded.truncated)
-                        ctx.fullTextTruncated = true;
-                }
-                const displayDelta = normalizeAssistantDisplayText(delta);
-                if (ctx.liveOutputText !== undefined) {
-                    // Bound this too: it is promoted into fullText at close.
-                    const live = appendBoundedFullText(ctx.liveOutputText, displayDelta);
-                    ctx.liveOutputText = live.text;
-                    if (live.truncated)
-                        ctx.fullTextTruncated = true;
-                }
-                if (!ctx.outputTextStarted)
-                    ctx.outputTextStarted = true;
-                broadcastAgentOutput(ctx, agentLabel, cli, displayDelta, empTag, traceAudience);
-                return;
-            }
-            if (event.kind === 'tool') {
-                flushPiThinking();
-                const tool = stripUndefined({ icon: '🔧', label: event.label, status: event.status, detail: event.detail, toolType: 'tool' });
-                stampTraceTool(tool, ctx, 'tool');
-                ctx.toolLog.push(tool);
-                if (ctx.liveScope)
-                    replaceLiveRunTools(ctx.liveScope, ctx.toolLog);
-                appendParentLiveRunTool(ctx, tool);
-                emitAgentTool(ctx, agentLabel, tool, empTag);
-                return;
-            }
-            if (event.kind === 'session')
-                ctx.sessionId = event.sessionId;
-        };
-        let piFacade = null;
-        let piTurnChild = null;
-        let piSendStarted = false;
-        const piTurnContext = () => ({
-            runId: traceRunId, sessionId: chatSessionId, scope: scopeKey,
-            turnId: traceRunId, audience: traceAudience,
-            isCurrent: () => isCurrentSessionOwner(persistenceOwner, scopeKey)
-                && (mainManaged
-                    ? activeMainProcesses.get(scopeKey) === mainRun
-                    : piTurnChild !== null && activeProcesses.get(agentLabel) === piTurnChild),
-        });
-        const appendPiStderr = (stderr) => {
-            if (!stderr || ctx.stderrBuf.length >= STDERR_BUF_CAP)
-                return;
-            ctx.stderrBuf = sliceWithoutSplittingSurrogate(ctx.stderrBuf + stderr, STDERR_BUF_CAP);
-        };
-        const onPiFailure = (error, outcome) => {
-            appendPiStderr(error.message);
-            if (outcome.status !== 'error')
-                return;
-            const diagnostic = sliceWithoutSplittingSurrogate(userErrorText(error), STDERR_BUF_CAP);
-            if (diagnostic.trim() && !ctx.runtimeDiagnostic?.trim())
-                ctx.runtimeDiagnostic = diagnostic;
-        };
-        const onPiStderr = (stderr) => appendPiStderr(stderr);
-        const mapPiSend = (child, send) => send.then((outcome) => ({
-            text: outcome.finalText ?? outcome.partialText ?? '',
-            code: typeof child.exitCode === 'number' ? child.exitCode
-                : outcome.status === 'error' ? 1 : 0,
-            sessionId: ctx.sessionId ?? piFacade?.nativeSessionId ?? null,
-            runtimeOutcome: outcome,
-        }));
-        const endPiRuntime = (end) => {
-            if (piFacade?.claimTurnOutcome(traceRunId)) {
-                if (!piFacade.finalizeTurn(traceRunId, end)) {
-                    console.warn('[jaw:pi] owned finalizer rejected the terminal');
-                    activity.close(end);
-                }
-                return;
-            }
-            if (piSendStarted)
-                console.warn('[jaw:pi] missing owned finalizer');
-            activity.close(end);
-        };
-        const runPiTurn = (child, lease, directCleanup, start) => {
-            let leaseCancel = null;
-            let cleanupDone = false, queueRequested = false;
-            let selectedResult;
-            const recordResult = (result) => {
-                if (selectedResult !== undefined)
-                    return;
-                selectedResult = result;
-                if (cleanupDone)
-                    resolve(result);
-            };
-            const requestQueue = () => {
-                if (cleanupDone)
-                    void processQueue(scopeKey);
-                else
-                    queueRequested = true;
-            };
-            const requestCancel = () => {
-                if (cleanupDone)
-                    return Promise.resolve();
-                if (!lease) {
-                    if (cancelOwnedPiProcess(child))
-                        return Promise.resolve();
-                    ownProcess(child).terminate('cancel');
-                    return Promise.resolve();
-                }
-                leaseCancel ??= lease.cancel();
-                return leaseCancel;
-            };
-            const cancelHook = (reason) => {
-                if (cleanupDone)
-                    return;
-                if (isLifecycleExitSettleReason(reason))
-                    piExit = captureExitSettler(scopeKey);
-                void requestCancel();
-            };
-            if (lease && mainRun)
-                mainRun.cancelTurn = cancelHook;
-            let piWatchdog;
-            let watchdogStopped = false;
-            const stopWatchdog = () => { if (!watchdogStopped) {
-                watchdogStopped = true;
-                piWatchdog?.stop();
-            } };
-            let setupError;
-            try {
-                piWatchdog = attachWatchdog(child, agentLabel, (reason) => {
-                    console.log(`[jaw:watchdog] cancelling ${agentLabel} (pi) — ${reason}`);
-                    ctx.stallReason = reason;
-                    void requestCancel();
-                });
-                ctx.stallWatchdog = piWatchdog;
-                if (mainManaged)
-                    mainRun.process = child;
-                else
-                    registerActiveProcess(agentLabel, child);
-                if (!opts.internal)
-                    broadcast('agent_status', { running: true, agentId: agentLabel, cli, provider: profile.id, ...empTag });
-                if (mainManaged && !opts.internal) {
-                    beginLiveRun(liveScope, cli);
-                    setLiveRunTraceId(liveScope, traceRunId);
-                }
-                if (mainManaged && !opts.internal && !opts._skipInsert) {
-                    insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
-                }
-                if (!opts.internal)
-                    broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, provider: profile.id, ...empTag }, traceAudience);
-            }
-            catch (error) {
-                setupError = error;
-                try {
-                    void requestCancel().catch(() => { console.warn('[jaw:pi] setup cancellation failed'); });
-                }
-                catch {
-                    console.warn('[jaw:pi] setup cancellation failed');
-                }
-            }
-            const releaseLease = async () => {
-                try {
-                    if (leaseCancel)
-                        await leaseCancel;
-                }
-                finally {
-                    if (mainRun?.cancelTurn === cancelHook)
-                        delete mainRun.cancelTurn;
-                    consumeKillReason(child.pid);
-                    if (lease)
-                        lease.release();
-                    else {
-                        let receipt;
-                        try {
-                            receipt = await directCleanup ?? undefined;
-                        }
-                        catch { /* Missing/rejected evidence never authorizes deletion. */ }
-                        if (receipt?.cwdDisposition === 'removable')
-                            cleanupPiEmployee();
-                        else
-                            console.warn('[jaw:pi] retaining employee cwd: physical cleanup unconfirmed', spawnCwd);
-                    }
-                }
-            };
-            const done = start();
-            done.then(async (result) => {
-                if (setupError !== undefined)
-                    throw setupError;
-                if (result.runtimeOutcome !== undefined)
-                    handoffRuntimeOutcome(ctx, result.runtimeOutcome);
-                const killReason = consumeKillReason(child.pid);
-                stopWatchdog();
-                flushPiThinking();
-                if (result.sessionId)
-                    ctx.sessionId = result.sessionId;
-                if (!ctx.fullText && result.text)
-                    ctx.fullText = result.text;
-                try {
-                    opts.lifecycle?.onExit?.(result.code);
-                }
-                catch {
-                    console.warn('[jaw:pi] exit observer failed');
-                }
-                const wasKilled = !!killReason;
-                const wasSteer = isLifecycleSteerReason(killReason);
-                const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, result.code, cli);
-                return handleAgentExit({
-                    onRuntimeEnd: endPiRuntime,
-                    ctx, code: result.code, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
-                    killReason,
-                    resumeKey,
-                    prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
-                    isResume: false, wasKilled, wasSteer, smokeResult,
-                    effortDefault: 'medium', costLine: '',
-                    resolve: recordResult,
-                    activeProcesses,
-                    scopeKey,
-                    runtimeTransport,
-                    scopedBucket: currentBucket,
-                    chatSessionId,
-                    childProcess: child,
-                    releaseMainRun: (scope, process, generation) => activeMainProcesses.get(scope) === mainRun
-                        && releaseMainRun(scope, process, generation),
-                    retryState: queueCtrl.retryStateForScope(scopeKey),
-                    fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
-                    fallbackMaxRetries: FALLBACK_MAX_RETRIES,
-                    processQueue: requestQueue,
-                });
-            }, async (err) => {
-                if (setupError !== undefined)
-                    throw setupError;
-                const failedOutcome = piFailureOutcome(err);
-                if (failedOutcome !== undefined)
-                    handoffRuntimeOutcome(ctx, failedOutcome);
-                const killReason = consumeKillReason(child.pid);
-                const wasKilled = !!killReason;
-                const wasSteer = isLifecycleSteerReason(killReason);
-                stopWatchdog();
-                appendPiStderr(err.message);
-                console.error('[jaw:pi] runtime failed:', userErrorText(err));
-                return handleAgentExit({
-                    onRuntimeEnd: endPiRuntime,
-                    ctx, code: 1, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
-                    killReason,
-                    resumeKey,
-                    prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
-                    isResume: false, wasKilled, wasSteer, smokeResult: detectSmokeResponse('', [], 1, cli),
-                    effortDefault: 'medium', costLine: '',
-                    resolve: recordResult,
-                    activeProcesses,
-                    scopeKey,
-                    runtimeTransport,
-                    scopedBucket: currentBucket,
-                    chatSessionId,
-                    childProcess: child,
-                    releaseMainRun: (scope, process, generation) => activeMainProcesses.get(scope) === mainRun
-                        && releaseMainRun(scope, process, generation),
-                    retryState: queueCtrl.retryStateForScope(scopeKey),
-                    fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
-                    fallbackMaxRetries: FALLBACK_MAX_RETRIES,
-                    processQueue: requestQueue,
-                });
-            }).catch((handleErr) => {
-                endPiRuntime({ kind: 'turn-end', status: 'error', finalText: null, error: 'Lifecycle failed' });
-                console.error('[jaw:lifecycle] handleAgentExit failed (Pi):', handleErr.message);
-                try {
-                    finalizeTraceRun(traceRunId, 'error', 'Lifecycle failed', { onlyIfRunning: true });
-                }
-                catch {
-                    console.warn('[runtime] Pi lifecycle trace finalization failed');
-                }
-                if (mainManaged && activeMainProcesses.get(scopeKey) === mainRun) {
-                    if (releaseMainRun(scopeKey, mainRun.process, ownerGeneration) && !opts.internal)
-                        requestQueue();
-                    if (getLiveRun(liveScope).traceRunId === traceRunId)
-                        clearLiveRun(liveScope);
-                }
-                else if (!mainManaged && activeProcesses.get(agentLabel) === child)
-                    activeProcesses.delete(agentLabel);
-                recordResult({ text: ctx.runtimeOutcome?.finalText ?? '', code: 1,
-                    ...(ctx.runtimeOutcome === undefined ? {} : { runtimeOutcome: { ...ctx.runtimeOutcome } }) });
-            }).finally(async () => {
-                try {
-                    stopWatchdog();
-                    await releaseLease();
-                }
-                catch {
-                    console.warn('[jaw:pi] runtime cleanup failed');
-                    recordResult({ text: '', code: 1 });
-                }
-                finally {
-                    cleanupDone = true;
-                    settlePiExit();
-                    if (queueRequested)
-                        void processQueue(scopeKey);
-                    if (selectedResult !== undefined)
-                        resolve(selectedResult);
-                }
-            });
-        };
-        if (opts.agentId) {
-            let opened;
-            try {
-                opened = openPiRpc(profile, pi, {
-                    model: runtimeModel,
-                    ...(piSessionId ? { sessionId: piSessionId } : {}),
-                    effort, cwd: spawnCwd, env: spawnEnv,
-                    onEvent: onPiEvent, onRawRecord: onPiRawRecord,
-                });
-            }
-            catch (error) {
-                activity.close({ kind: 'turn-end', status: 'error', finalText: null, error: 'Pi process creation failed' });
-                finalizeTraceRun(traceRunId, 'error', 'Pi process creation failed');
-                cleanupPiEmployee();
-                throw error;
-            }
-            piTurnChild = opened.child;
-            piFacade = new PiRuntimeSession(opened, {
-                lifetime: 'oneshot',
-                provider: 'pi',
-                deferTurnEnd: true,
-                projection: activity,
-                getTurnContext: piTurnContext,
-                ...(effort ? { effort } : {}),
-                onPiEvent,
-                onRawRecord: onPiRawRecord,
-                onFailure: onPiFailure,
-                onStderr: onPiStderr,
-            });
-            bindPiExecutionCancel(opened.child, () => { void piFacade.cancel(); });
-            runPiTurn(opened.child, null, opened.cleanup, () => {
-                piSendStarted = true;
-                return mapPiSend(opened.child, piFacade.send({ text: `${piSysPrompt}\n\n${piPrompt}` }, () => { }));
-            });
-            return { child: opened.child, promise: resultPromise };
-        }
-        const profileFp = crypto.createHmac('sha256', piProfileFingerprintKey)
-            .update(profile.apiKey || '')
-            .digest('hex')
-            .slice(0, 12);
-        mainRun.starting = true;
-        let piAcquireStopReason;
-        const cancelPiAcquire = (reason) => {
-            piAcquireStopReason ??= reason;
-            clearMainLiveRunOnStop(scopeKey, reason);
-        };
-        const finishPiAcquire = () => {
-            mainRun.starting = false;
-            if (mainRun.cancelPending === cancelPiAcquire)
-                delete mainRun.cancelPending;
-        };
-        const abandonPiAcquire = () => {
-            activity.close({ kind: 'turn-end', status: 'stopped', finalText: null });
-            try {
-                finalizeTraceRun(traceRunId, 'interrupted');
-            }
-            catch {
-                console.warn('[runtime] Pi cancelled acquisition trace finalization failed');
-            }
-            if (activeMainProcesses.get(scopeKey) === mainRun) {
-                if (getLiveRun(liveScope).traceRunId === traceRunId)
-                    clearLiveRun(liveScope);
-                releaseMainRun(scopeKey, null, ownerGeneration);
-            }
-            settlePiExit();
-            resolve(stoppedBeforeStart(piAcquireStopReason, traceRunId));
-        };
-        mainRun.cancelPending = cancelPiAcquire;
-        void acquirePiRuntime({
-            key: {
-                scopeKey,
-                cwd: spawnCwd,
-                profileId: profile.id,
-                fullEndpoint: profile.endpoint,
-                apiKind: profile.apiKind,
-                model: runtimeModel,
-                effort,
-                profileFp,
-            },
-            piSettings: pi,
-            env: spawnEnv,
-            storedSessionId: piSessionId || null,
-            instructions: piSysPrompt,
-            forceNew: forceNew || Boolean(slackToolGrant),
-        }).then((lease) => {
-            finishPiAcquire();
-            if (piAcquireStopReason !== undefined || activeMainProcesses.get(scopeKey) !== mainRun || !isCurrentSessionOwner(persistenceOwner, scopeKey)) {
-                lease.release();
-                abandonPiAcquire();
-                return;
-            }
-            ctx.sessionId = lease.session.sessionId;
-            console.log(`[jaw:pi:pool] reused=${lease.reused} sessionId=${lease.session.sessionId || 'new'}`);
-            piTurnChild = lease.session.child;
-            piFacade = new PiRuntimeSession(lease.session, {
-                lifetime: 'pooled',
-                provider: 'pi',
-                deferTurnEnd: true,
-                projection: activity,
-                getTurnContext: piTurnContext,
-                ...(effort ? { effort } : {}),
-                onPiEvent,
-                onRawRecord: onPiRawRecord,
-                onFailure: onPiFailure,
-                onStderr: onPiStderr,
-            });
-            runPiTurn(lease.session.child, lease, null, () => {
-                piSendStarted = true;
-                return mapPiSend(lease.session.child, piFacade.send({ text: piPrompt }, () => { }));
-            });
-        }).catch((err) => {
-            finishPiAcquire();
-            if (piAcquireStopReason !== undefined) {
-                abandonPiAcquire();
-                return;
-            }
-            console.error(`[jaw:pi:pool] acquire failed: ${err.message}`);
-            activity.close({ kind: 'turn-end', status: 'error', finalText: null, error: 'Pi acquisition failed' });
-            try {
-                finalizeTraceRun(traceRunId, 'error', 'Pi acquisition failed');
-            }
-            catch {
-                console.warn('[runtime] Pi acquisition trace finalization failed');
-            }
-            const ownsRun = activeMainProcesses.get(scopeKey) === mainRun;
-            if (ownsRun) {
-                clearLiveRun(liveScope);
-                try {
-                    broadcast('agent_status', { running: false, agentId: agentLabel });
-                    broadcast('agent_done', { ...runPin, text: `❌ Pi RPC acquire failed: ${err.message}`, error: true, origin }, 'public');
-                }
-                catch {
-                    console.warn('[jaw:pi] acquisition diagnostic delivery failed');
-                }
-                releaseMainRun(scopeKey, null, ownerGeneration);
-            }
-            resolve({ text: '', code: 1 });
-            if (ownsRun) {
-                settlePiExit();
-                void processQueue(scopeKey);
-            }
-        });
-        return { child: null, promise: resultPromise };
-    }
+    if (cli === 'pi')
+        return runPiBackend(backendLocals, backendHost);
     // ─── Codex AppServer branch ────────────────────
-    if (cli === 'codex-app') {
-        const catalogPath = resolveCatalogPath();
-        if (catalogPath) {
-            const verdict = validateModelEffort(model, effort, loadCatalogEfforts(catalogPath));
-            if (!verdict.ok) {
-                throw new Error(`[codex-app] ${verdict.error}`);
-            }
-        }
-        if (mainManaged && !opts.internal && !opts._skipInsert) {
-            insertMessage.run('user', prompt, cli, model, settings["workingDir"] || null, chatSessionId);
-        }
-        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, sessionId: chatSessionId, scopeKey });
-        if (mainManaged && !opts.internal)
-            setLiveRunTraceId(liveScope, traceRunId);
-        const ctx = {
-            fullText: '', traceLog: [], toolLog: [], seenToolKeys: new Set(),
-            hasClaudeStreamEvents: false, sessionId: null, cost: null,
-            turns: null, duration: null, tokens: null, stderrBuf: '',
-            thinkingBuf: '',
-            runStartedAt: Date.now(),
-            ...(opts.requestId ? { requestId: opts.requestId } : {}),
-            ...(origin ? { origin } : {}),
-            liveScope: effectiveLiveScope,
-            parentLiveScope: parentLiveScopeForChild,
-            traceRunId,
-            traceAudience,
-            activityIdentity: { sessionId: chatSessionId, scope: scopeKey },
-        };
-        const activity = new RuntimeProjection({
-            runId: traceRunId, sessionId: chatSessionId, scope: scopeKey,
-            turnId: traceRunId, audience: traceAudience,
-            ...(opts.runtimeParentItemId ? { parentItemId: opts.runtimeParentItemId } : {}),
-        });
-        const codexProjection = new CodexProjection(activity);
-        activity.start('codex-app');
-        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);
-                appendParentLiveRunTool(ctx, tool);
-                emitAgentTool(ctx, agentLabel, tool, empTag);
-            }
-            ctx.thinkingBuf = '';
-        }
-        let lastVisibleBroadcastTs = Date.now();
-        let heartbeatSent = false;
-        let turnCompleted = false;
-        let turnReportedFailure = false;
-        let markCodexProgress = () => { };
-        let settleTurn;
-        let rejectTurn;
-        const turnDone = new Promise((resolveTurn, rejectTurnPromise) => {
-            settleTurn = resolveTurn;
-            rejectTurn = rejectTurnPromise;
-        });
-        const consumeCodexAppEvent = (method, parsed) => {
-            if (!parsed) {
-                if (method === 'turn/completed')
-                    settleTurn();
-                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);
-                    appendParentLiveRunTool(ctx, parsedTool);
-                    emitAgentTool(ctx, agentLabel, parsedTool, empTag);
-                    lastVisibleBroadcastTs = Date.now();
-                    heartbeatSent = false;
-                }
-            }
-            // Sticky channel/item bookkeeping and the durable-vs-live decision live
-            // in applyCodexAppTextEvent so they can be tested without a live runtime.
-            if (parsed.text)
-                flushCodexAppThinking();
-            const textDecision = applyCodexAppTextEvent(ctx, parsed);
-            if (textDecision.durable) {
-                // codex-app streams item/agentMessage/delta at TOKEN granularity;
-                // the segment formatter would inject "\n- " between unjoined
-                // tokens ("이"+"지만" → "이\n- 지만"). Raw-append like the plain
-                // `claude` text_delta path (events/index.ts) instead.
-                const segment = appendAssistantRawText(ctx, textDecision.durable);
-                if (segment) {
-                    broadcastAgentOutput(ctx, agentLabel, cli, segment, empTag, traceAudience);
-                    lastVisibleBroadcastTs = Date.now();
-                    heartbeatSent = false;
-                }
-            }
-            else if (textDecision.live) {
-                // Commentary is a transient progress update, not part of the durable
-                // response. Broadcast it for live UI preview but keep it out of
-                // fullText — that way agent_done (and therefore Slack/Telegram/
-                // Discord delivery) contains only the final answer.
-                broadcastAgentOutput(ctx, agentLabel, cli, textDecision.live, empTag, traceAudience);
-            }
-            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}`);
-                turnReportedFailure = true;
-            }
-            opts.lifecycle?.onActivity?.('codex-app');
-            if (method === 'turn/completed')
-                settleTurn();
-        };
-        const handleStderr = (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)`);
-                emitAgentTool(ctx, agentLabel, {
-                    icon: '⏳',
-                    label: 'working... (no visible progress)',
-                }, empTag);
-            }
-        };
-        const effectiveFastMode = cfg.fastMode ?? settings["perCli"]?.["codex"]?.fastMode ?? false;
-        const runCodexAppTurn = async (appClient, lease, laneScope) => {
-            const child = appClient.proc;
-            if (!child)
-                throw new Error('Codex AppServer process was not created');
-            if (mainManaged)
-                mainRun.process = child;
-            else
-                registerActiveProcess(agentLabel, child);
-            if (!opts.internal)
-                broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...empTag });
-            const processExit = { value: null };
-            // The one documented cross-runtime exception. codex-app keeps a 300s idle
-            // bound where the shared watchdog defaults to 90s, because an appserver turn
-            // reports sparse STRUCTURED progress instead of a continuous stream and
-            // nothing here counts stdout as liveness. settings.agentTimeout deliberately
-            // does not narrow it either: a global idleMs written for print CLIs would
-            // cut the default runtime's bound by two thirds. The env overrides remain
-            // the supported knob and are mapped into the watchdog config below.
-            const idleMs = configuredPositiveMs(process.env["CODEX_APP_TURN_IDLE_MS"], DEFAULT_CODEX_APP_TURN_IDLE_MS);
-            const absoluteMs = configuredPositiveMs(process.env["CODEX_APP_TURN_ABS_MS"], DEFAULT_CODEX_APP_TURN_ABS_MS);
-            let watchdogCancel = null;
-            let leaseCancel = null;
-            const requestLeaseCancel = () => {
-                if (!lease) {
-                    appClient.kill();
-                    return Promise.resolve();
-                }
-                leaseCancel ??= lease.cancel().catch((err) => {
-                    console.warn('[codex-app:turn] cancel failed:', err.message);
-                });
-                return leaseCancel;
-            };
-            const cancelHook = (_reason) => { void requestLeaseCancel(); };
-            if (lease && mainRun)
-                mainRun.cancelTurn = cancelHook;
-            // Same-turn steer (turn/steer) for the duration of THIS turn only:
-            // installed and torn down with cancelHook so capability reads never
-            // outlive the steerable window.
-            const steerHook = async (text) => {
-                try {
-                    await appClient.steerTurn(laneScope, text, { clientUserMessageId: crypto.randomUUID() });
-                    return 'steered';
-                }
-                catch (err) {
-                    if (err instanceof CodexSteerError) {
-                        // review/compact turns reject steer; a mismatched/finished
-                        // turn raced us. Both are queue-fallback territory.
-                        return err.code === 'not-steerable' ? 'rejected' : 'unavailable';
-                    }
-                    throw err;
-                }
-            };
-            if (mainRun)
-                mainRun.steerTurnInBand = steerHook;
-            // The same watchdog every other runtime uses. The bespoke timer pair this
-            // replaces never set `ctx.stallReason`, and that field is the ONLY trigger
-            // for the #405 truncation notice (`error-classifier.ts:149-159`). So on the
-            // DEFAULT runtime a timeout surfaced as a generic error and the #405 fix
-            // never applied to the path most turns actually take.
-            const turnWatchdog = attachWatchdog(child, agentLabel, reason => {
-                if (watchdogCancel)
-                    return;
-                console.warn(`[codex-app:turn] watchdog stall (${reason}, idleMs=${idleMs}, absoluteMs=${absoluteMs})`);
-                ctx.stallReason = reason;
-                watchdogCancel = requestLeaseCancel();
-                rejectTurn(new Error(`Codex AppServer turn watchdog timeout: ${reason}`));
-            }, {
-                // This child's stdout IS the JSON-RPC stream and readline already owns
-                // it, so counting raw traffic as liveness would keep a wedged turn
-                // looking alive forever. Progress comes from the turn adapter instead.
-                observeStdio: false,
-                // The two bespoke timers map onto the watchdog's two real gates:
-                // markProgress slides absoluteDeadline to now+absoluteMs, giving
-                // "no progress for idleMs", capped at startedAt+absoluteHardCapMs,
-                // giving "total run beyond absoluteMs". firstProgressMs bounds a turn
-                // that never reports at all.
-                firstProgressMs: idleMs, idleMs, absoluteMs: idleMs, absoluteHardCapMs: absoluteMs,
-            });
-            ctx.stallWatchdog = turnWatchdog;
-            markCodexProgress = () => { turnWatchdog.markProgress(); };
-            const listener = listenCodexAppTurnAdapter(appClient, lease, laneScope, ctx, {
-                onProgress: () => { markCodexProgress(); },
-                onRawNotification: (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 });
-                },
-                onDiagnosticNotification: (entry) => {
-                    appendTraceEvent({
-                        runId: ctx.traceRunId,
-                        source: 'codex_app_raw',
-                        eventType: 'unrouted-notification',
-                        raw: entry,
-                    });
-                },
-                onEvent: consumeCodexAppEvent,
-                onProjectionNotification: (method, params, parsed) => {
-                    codexProjection.observe(method, params, parsed, ctx.codexAppActiveChannel || '');
-                },
-                onStderr: handleStderr,
-                onExit: (code, signal) => {
-                    processExit.value = { code, signal };
-                    rejectTurn(new Error(`Codex AppServer exited (code=${code}, signal=${signal})`));
-                },
-                onError: rejectTurn,
-                onInterruptFailed: (err) => {
-                    console.warn(`[codex-app:interrupt] ${err.message}`);
-                },
-            });
-            try {
-                if (lease) {
-                    ctx.sessionId = lease.threadId;
-                    console.log(`[codex-app:pool] thread=${lease.threadId.slice(0, 12)}... reused=${lease.reused} resumed=${lease.resumedThread}`);
-                }
-                else {
-                    const initResult = await appClient.initialize();
-                    if (process.env["DEBUG"])
-                        console.log('[codex-app:init]', JSON.stringify(initResult).slice(0, 200));
-                    const threadOptions = {
-                        model,
-                        effort,
-                        cwd: spawnCwd,
-                        fastMode: effectiveFastMode,
-                        instructions: sysPrompt,
-                    };
-                    if (isResume && resumeSessionId) {
-                        try {
-                            await appClient.resumeThread(laneScope, resumeSessionId, threadOptions);
-                            console.log(`[codex-app:session] resumeThread OK: ${resumeSessionId.slice(0, 12)}...`);
-                        }
-                        catch (resumeErr) {
-                            const message = resumeErr.message || '';
-                            if (!isRecoverableResumeError(message))
-                                throw resumeErr;
-                            console.warn(`[codex-app:session] resumeThread FAILED (recoverable): ${message} — starting new thread`);
-                            if (empSid && opts.agentId)
-                                clearEmployeeSession.run(opts.agentId);
-                            await appClient.startThread(laneScope, threadOptions);
-                        }
-                    }
-                    else {
-                        await appClient.startThread(laneScope, threadOptions);
-                    }
-                    ctx.sessionId = appClient.getThreadId(laneScope) ?? '';
-                }
-                const shouldPrependHistory = lease
-                    ? !(lease.resumedThread || lease.reused)
-                    : !(isResume && Boolean(resumeSessionId));
-                const codexAppPrompt = (shouldPrependHistory && historyBlock)
-                    ? `${historyBlock}\n\n[User Message]\n${prompt}`
-                    : prompt;
-                const codexAppPromptWithSteer = withSteerContext(codexAppPrompt, opts.steerContext);
-                const startTurn = appClient.startTurn(laneScope, codexAppPromptWithSteer);
-                await Promise.race([startTurn, turnDone]);
-                await turnDone;
-                turnCompleted = !turnReportedFailure;
-                flushCodexAppThinking();
-                const persistedThreadId = lease?.threadId ?? appClient.getThreadId(laneScope);
-                if (persistedThreadId && persistMainSession(stripUndefined({
-                    persistenceOwner,
-                    scopeKey,
-                    forceNew,
-                    employeeSessionId: empSid,
-                    sessionId: persistedThreadId,
-                    isFallback: opts._isFallback,
-                    cli,
-                    model,
-                    resumeKey,
-                    effort: cfg.effort || '',
-                    skipSessionPersist: opts._skipSessionPersist === true,
-                    ...(lease?.bucketKey ? { codexAppBucket: lease.bucketKey } : {}),
-                    // With multiplex off there is no lease bucket key, and without this the
-                    // save lands on the bare `codex-app` row that belongs to the default
-                    // session. codex-app is the default runtime, so that is the common case.
-                    runtimeTransport,
-                    scopedBucket: currentBucket,
-                }))) {
-                    console.log(`[jaw:session] saved ${cli} session=${persistedThreadId.slice(0, 12)}... (pre-shutdown)`);
-                }
-            }
-            catch (err) {
-                console.error(`[codex-app:error] ${err.message}`);
-                if (ctx.stderrBuf.length < 4000)
-                    ctx.stderrBuf += err.message;
-                if (!lease)
-                    appClient.kill();
-            }
-            finally {
-                turnWatchdog.stop();
-                markCodexProgress = () => { };
-                if (watchdogCancel)
-                    await watchdogCancel;
-                if (mainRun?.cancelTurn === cancelHook)
-                    delete mainRun.cancelTurn;
-                if (mainRun?.steerTurnInBand === steerHook)
-                    delete mainRun.steerTurnInBand;
-                listener.dispose();
-                if (lease)
-                    lease.release();
-                else {
-                    await appClient.closeGracefully();
-                    appClient.cleanup();
-                    cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
-                }
-            }
-            // A turn that never completed is a failure even when the process it
-            // was running on exited cleanly. Trusting the child's status here
-            // reports success for a turn that produced nothing, which is exactly
-            // what happens when a shared host is closed mid-turn.
-            const exitCode = turnCompleted ? 0 : (processExit.value?.code || 1);
-            opts.lifecycle?.onExit?.(exitCode);
-            const killReason = consumeKillReason(child.pid);
-            if (processExit.value && processExit.value.code !== 0 && !killReason) {
-                console.warn(`[codex-app:unexpected-exit] code=${processExit.value.code} signal=${processExit.value.signal} threadId=${ctx.sessionId || 'none'}`);
-            }
-            const wasKilled = !!killReason;
-            const wasSteer = isLifecycleSteerReason(killReason);
-            flushCodexAppThinking();
-            const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, exitCode, cli);
-            await handleAgentExit({
-                onRuntimeEnd: (end) => { activity.close(end); },
-                ctx, code: exitCode, cli, model, agentLabel, mainManaged, origin,
-                killReason,
-                resumeKey,
-                prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
-                isResume, wasKilled, wasSteer, smokeResult,
-                effortDefault: '', costLine: '',
-                resolve: resolve,
-                activeProcesses,
-                scopeKey,
-                runtimeTransport,
-                scopedBucket: currentBucket,
-                chatSessionId,
-                ...(lease?.bucketKey ? { codexAppBucket: lease.bucketKey } : {}),
-                childProcess: child,
-                releaseMainRun,
-                retryState: queueCtrl.retryStateForScope(scopeKey),
-                fallbackState: queueCtrl.fallbackStateForScope(scopeKey),
-                fallbackMaxRetries: FALLBACK_MAX_RETRIES,
-                processQueue,
-            }).catch((err) => {
-                activity.close({ kind: 'turn-end', status: 'error', finalText: null, error: 'Lifecycle failed' });
-                console.error('[jaw:lifecycle] handleAgentExit failed (codex-app):', err.message);
-            }).finally(() => settleExit(scopeKey));
-        };
-        if (opts.agentId) {
-            const employeeLaneScope = `employee:${opts.agentId}`;
-            const appClient = new CodexAppClient({
-                binary: detected.path || 'codex', workDir: spawnCwd, env: spawnEnv,
-            });
-            let child;
-            try {
-                appClient.spawn();
-                if (!appClient.proc)
-                    throw new Error('Codex AppServer process was not created');
-                child = appClient.proc;
-            }
-            catch (error) {
-                activity.close({ kind: 'turn-end', status: 'error', finalText: null, error: 'Codex process creation failed' });
-                finalizeTraceRun(traceRunId, 'error', 'Codex process creation failed');
-                cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
-                throw error;
-            }
-            void runCodexAppTurn(appClient, null, employeeLaneScope);
-            return { child, promise: resultPromise };
-        }
-        mainRun.starting = true;
-        let codexAcquireStopReason;
-        const cancelCodexAcquire = (reason) => { codexAcquireStopReason ??= reason; };
-        const releaseCodexAcquireHook = () => {
-            if (mainRun.cancelPending === cancelCodexAcquire)
-                delete mainRun.cancelPending;
-        };
-        mainRun.cancelPending = cancelCodexAcquire;
-        const acquireCodexAppForTurn = async () => {
-            const acquireWasCancelled = () => codexAcquireStopReason !== undefined || activeMainProcesses.get(scopeKey) !== mainRun;
-            try {
-                if (!codexMultiplexMain) {
-                    const lease = await acquireCodexAppRuntime({
-                        binary: detected.path || 'codex', env: spawnEnv,
-                        route: 'legacy',
-                        key: {
-                            scopeKey,
-                            cwd: spawnCwd, model, effort, fastMode: effectiveFastMode,
-                        },
-                        storedThreadId: resumeSessionId || null,
-                        instructions: sysPrompt,
-                        forceNew: forceNew || Boolean(slackToolGrant),
-                    });
-                    return { kind: 'lease', lease };
-                }
-                const waitMs = configuredPositiveMs(process.env["CODEX_APP_ACQUIRE_WAIT_MS"], DEFAULT_CODEX_APP_ACQUIRE_WAIT_MS);
-                const deadlineAt = Date.now() + waitMs;
-                let lastStaleError = null;
-                let staleAttempts = 0;
-                const deadlineError = (stage) => lastStaleError
-                    ?? new Error(`Codex App ${stage} timed out after ${waitMs}ms`);
-                const awaitWithinDeadline = async (stage, pending, onLateValue) => {
-                    let deadlineWon = false;
-                    let timeout;
-                    void pending.then((value) => {
-                        if (deadlineWon)
-                            onLateValue?.(value);
-                    }, () => { });
-                    const remainingMs = deadlineAt - Date.now();
-                    if (remainingMs <= 0) {
-                        deadlineWon = true;
-                        throw deadlineError(stage);
-                    }
-                    const deadline = new Promise((_resolveDeadline, rejectDeadline) => {
-                        timeout = setTimeout(() => {
-                            deadlineWon = true;
-                            rejectDeadline(deadlineError(stage));
-                        }, remainingMs);
-                    });
-                    try {
-                        return await Promise.race([pending, deadline]);
-                    }
-                    finally {
-                        if (timeout)
-                            clearTimeout(timeout);
-                    }
-                };
-                for (;;) {
-                    if (acquireWasCancelled())
-                        return { kind: 'cancelled', reason: codexAcquireStopReason };
-                    // Check the budget before spawning more work. awaitWithinDeadline()
-                    // only measures what remains once the promise already exists, so a
-                    // backoff that consumed the last of the budget would still get to
-                    // start one more prepare.
-                    if (deadlineAt - Date.now() <= 0)
-                        throw lastStaleError ?? deadlineError('prepare');
-                    try {
-                        const prepared = await awaitWithinDeadline('prepare', prepareCodexAppHost({
-                            binary: detected.path || 'codex', cwd: spawnCwd,
-                            fastMode: effectiveFastMode, env: spawnEnv, model, effort,
-                        }));
-                        if (acquireWasCancelled())
-                            return { kind: 'cancelled', reason: codexAcquireStopReason };
-                        const lease = await awaitWithinDeadline('acquire', acquireCodexAppLane(prepared, {
-                            scopeKey,
-                            bucketKey: currentBucket,
-                            storedThreadId: resumeSessionId || null,
-                            instructions: sysPrompt,
-                            forceNew: forceNew || Boolean(slackToolGrant),
-                            waitMs: deadlineAt - Date.now(),
-                        }), (lateLease) => { lateLease.release(); });
-                        if (acquireWasCancelled()) {
-                            lease.release();
-                            return { kind: 'cancelled', reason: codexAcquireStopReason };
-                        }
-                        return { kind: 'lease', lease };
-                    }
-                    catch (err) {
-                        if (!(err instanceof CodexHostGenerationStaleError))
-                            throw err;
-                        lastStaleError = err;
-                        if (acquireWasCancelled())
-                            return { kind: 'cancelled', reason: codexAcquireStopReason };
-                        const remainingMs = deadlineAt - Date.now();
-                        if (remainingMs <= 0)
-                            throw lastStaleError;
-                        staleAttempts += 1;
-                        const backoffMs = Math.min(remainingMs, CODEX_APP_ACQUIRE_RETRY_BACKOFF_MAX_MS, 25 * staleAttempts);
-                        await new Promise((done) => { setTimeout(done, backoffMs); });
-                    }
-                }
-            }
-            finally {
-                // The next promise continuation still owns the acquired lease.
-                // Keep its cancellation hook until it hands off or abandons it.
-                mainRun.starting = false;
-            }
-        };
-        // A run that never started a turn owns nothing but its own map slot.
-        // releaseMainRun() matches on (process, ownerGeneration), and a pending
-        // run has process=null while sharing the global generation with whatever
-        // replaced it, so calling it here would delete the replacement's entry.
-        // Compare the captured object instead and only drop our own slot.
-        const abandonTurn = (lease) => {
-            lease?.release();
-            activity.close({ kind: 'turn-end', status: 'stopped', finalText: null });
-            finalizeTraceRun(traceRunId, 'interrupted');
-            if (!activeMainProcesses.has(scopeKey) || activeMainProcesses.get(scopeKey) === mainRun) {
-                const currentLive = getLiveRun(liveScope);
-                const ownsLive = currentLive.traceRunId === traceRunId;
-                if (ownsLive)
-                    clearLiveRun(liveScope);
-                if (ownsLive || (!currentLive.running && currentLive.traceRunId === undefined)) {
-                    broadcast('agent_status', { running: false, agentId: agentLabel });
-                }
-            }
-            resolve(stoppedBeforeStart(codexAcquireStopReason, traceRunId));
-            if (activeMainProcesses.get(scopeKey) === mainRun)
-                activeMainProcesses.delete(scopeKey);
-            void processQueue(scopeKey);
-        };
-        void acquireCodexAppForTurn().then(async (outcome) => {
-            releaseCodexAcquireHook();
-            if (outcome.kind === 'cancelled') {
-                abandonTurn(null);
-                return;
-            }
-            const lease = outcome.lease;
-            if (codexAcquireStopReason !== undefined || activeMainProcesses.get(scopeKey) !== mainRun) {
-                abandonTurn(lease);
-                return;
-            }
-            await runCodexAppTurn(lease.client, lease, lease.laneScope);
-        }).catch((err) => {
-            releaseCodexAcquireHook();
-            if (codexAcquireStopReason !== undefined) {
-                abandonTurn(null);
-                return;
-            }
-            console.error(`[codex-app:pool] acquire failed: ${err.message}`);
-            activity.close({ kind: 'turn-end', status: 'error', finalText: null, error: 'Codex acquisition failed' });
-            try {
-                finalizeTraceRun(traceRunId, 'error', 'Codex acquisition failed');
-            }
-            catch {
-                console.warn('[runtime] Codex acquisition trace finalization failed');
-            }
-            const ownsRun = activeMainProcesses.get(scopeKey) === mainRun;
-            if (ownsRun) {
-                clearLiveRun(liveScope);
-                broadcast('agent_status', { running: false, agentId: agentLabel });
-                broadcast('agent_done', { ...runPin, text: `❌ Codex AppServer acquire failed: ${err.message}`, error: true, origin }, 'public');
-                releaseMainRun(scopeKey, null, ownerGeneration);
-            }
-            resolve({ text: '', code: 1 });
-            if (ownsRun) {
-                settleExit(scopeKey);
-                void processQueue(scopeKey);
-            }
-        });
-        return { child: null, promise: resultPromise };
-    }
+    if (cli === 'codex-app')
+        return runCodexAppBackend(backendLocals, backendHost);
     // ─── Standard CLI branch (claude/codex/opencode) ──────
     const spawnCommand = cli === 'opencode' && process.platform !== 'win32'
         ? (resolvedOpencodeBinary || detected.path || cli)
@@ -3568,7 +1753,8 @@ export function spawnAgent(prompt, opts = {}) {
             void processQueue(scopeKey);
     });
     if (mainManaged && !opts.internal && !opts._skipInsert) {
-        insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
+        // The runtime gets the inline-skill block; the chat row keeps what was written.
+        insertMessage.run('user', stripSkillMentionBlock(prompt), cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
     }
     if (cli === 'claude') {
         child.stdin.write(withSteerContext(isResume ? prompt : withHistoryPrompt(prompt, historyBlock), opts.steerContext));