cli-jaw 2.17.38 → 2.17.39

package/dist/src/agent/spawn.js

@@ -29,7 +29,7 @@ import { extractSessionId, extractFromEvent, extractFromAcpUpdate, extractOutput
 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, persistMainSession, } from './session-persistence.js';
+import { getSessionOwnershipGeneration, isCurrentSessionOwner, persistMainSession, } 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 } from '../orchestrator/worker-registry.js';
@@ -37,19 +37,37 @@ 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 { LOCAL_SESSION_SCOPE_ACTIVATION, resolveOrcScope } from '../orchestrator/scope.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 { setSpawnRef as setMemorySpawnRef, } from './memory-flush-controller.js';
 import { applyCliEnvDefaults, buildSessionResumeKey, ensureOpencodeAlwaysAllowPermissions, mergeEnvWindowsSafe } from './spawn-env.js';
-import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt, withSteerContext } from './prompt-context.js';
+import { buildPromptForArgs, shouldBuildHistoryBlock, withHistoryPrompt, withSteerContext, PROMPT_HISTORY_MAX_ROWS, PROMPT_HISTORY_MAX_CHARS, appendCursorAcceptedInstruction, buildCursorReplacementPrompt } 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 { 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 { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
+import { isRemoteTarget } from '../messaging/types.js';
+import { buildRemoteBindingKey } from '../messaging/session-key.js';
 import { isJawRuntimeEvent, handleJawRuntimeEvent } from './claude-e-runtime.js';
 import { jawRuntimesByScope, runtimeForScope } from './jwc-runtime.js';
 import { applyOutputPolicy, runBeforeSpawnChecks } from '../core/policy-hooks.js';
-import { appendTraceEvent, finalizeTraceRun, stampTraceTool, startTraceRun } from '../trace/store.js';
+import { appendTraceEvent, createTraceId, finalizeTraceRun, stampTraceTool, startTraceRun, updateTraceToolRow } 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';
@@ -58,13 +76,29 @@ import { appendAssistantRawText, appendAssistantTextSegment, emitAgentTool, norm
 import { captureKiroSessionIdAfterExit, finalizeKiroFullText, flushKiroStdoutContext, isKiroPlainTextCli, isKiroStaleSessionOutput, parseAiESessionIdFromStderr, processKiroStdoutChunk, spawnWithKiroSnapshot, } from './kiro-runtime.js';
 import { resolveCursorModelVariant } from './cursor-runtime.js';
 import { normalizePiSettings, spawnPiRpc } from './pi-runtime.js';
+import * as piExecutionControls from './pi-runtime.js';
+import { piFailureOutcome } from './runtime/pi-turn.js';
 import { getEmployeeMcpServers } from './mcp-passthrough.js';
 // ─── State ───────────────────────────────────────────
 export const activeProcesses = new Map(); // agentId → child process
+export function hasActiveAgent(agentId) {
+    return activeProcesses.has(agentId) || hasClaudeWorker(agentId);
+}
 /** Kill reason recorded when a duplicate registration reaps the previous child. */
 const DUP_REGISTRATION_KILL_REASON = 'dup-registration';
 /** Grace before escalating that kill to SIGKILL, matching the sibling kill paths. */
 const DUP_REGISTRATION_KILL_GRACE_MS = 2_000;
+function cancelOwnedPiProcess(child, reason) {
+    const cancel = piExecutionControls.cancelPiExecution;
+    if (typeof cancel !== 'function')
+        return false;
+    const live = !hasChildExited(child);
+    if (!cancel(child))
+        return false;
+    if (live && child.pid && reason)
+        killReasons.set(child.pid, reason);
+    return true;
+}
 function registerActiveProcess(agentLabel, child) {
     // Defensive: the concrete spawn site should already own this child, and
     // ownProcess is memoized, so this returns that existing owner rather than
@@ -77,7 +111,10 @@ function registerActiveProcess(agentLabel, child) {
         // Treating it as exited would drop that survivor from the map without
         // even scheduling the escalation below — the exact invisible process
         // this branch exists to prevent.
-        if (hasChildExited(prev)) {
+        if (cancelOwnedPiProcess(prev, DUP_REGISTRATION_KILL_REASON)) {
+            // Its captured pair owns cleanup; never start a second tree timer.
+        }
+        else if (hasChildExited(prev)) {
             activeProcesses.delete(agentLabel);
         }
         else {
@@ -171,9 +208,10 @@ function broadcastAgentOutput(ctx, agentLabel, cli, text, empTag, audience) {
         agentId: agentLabel,
         cli,
         text,
-        ...(ctx.traceRunId ? { traceRunId: ctx.traceRunId } : {}),
         ...(textLen !== null ? { textLen } : {}),
         ...empTag,
+        ...(ctx.traceRunId ? { traceRunId: ctx.traceRunId } : {}),
+        ...(ctx.activityIdentity ?? {}),
     }, audience);
 }
 function appendParentLiveRunTool(ctx, tool) {
@@ -199,6 +237,7 @@ function emitKiroStreamEvents(events, ctx, agentLabel, cli, empTag, traceAudienc
             const segment = normalizeAssistantDisplayText(event.text);
             if (!segment)
                 continue;
+            ctx.printActivity?.message(segment, 'append', 'unknown');
             if (ctx.liveOutputText !== undefined) {
                 ctx.liveOutputText += segment;
             }
@@ -229,10 +268,14 @@ function emitKiroStreamEvents(events, ctx, agentLabel, cli, empTag, traceAudienc
     }
 }
 export function killAgentById(agentId) {
+    if (cancelClaudeWorker(agentId, 'user'))
+        return true;
     const proc = activeProcesses.get(agentId);
     if (!proc)
         return false;
     try {
+        if (cancelOwnedPiProcess(proc, 'user'))
+            return true;
         if (proc.pid) {
             killProcessTree(proc.pid, 'SIGTERM');
         }
@@ -449,6 +492,8 @@ function abortInProcessRuntimeOnStop(scopeKey, reason) {
 export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
     const scopeKey = scopedReason === undefined ? 'default' : scopeKeyOrReason;
     const reason = scopedReason ?? scopeKeyOrReason;
+    cancelSteerInputs(scopeKey);
+    const cancelledClaude = cancelClaudeScope(scopeKey, reason, reason === 'api' || reason === 'user');
     const run = activeMainProcesses.get(scopeKey);
     const hadTimer = queueCtrl.isRetryPending(scopeKey);
     const cancelledPendingMain = run?.cancelPending ? (run.cancelPending(reason), true) : false;
@@ -466,7 +511,7 @@ export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
         settleOnce(run?.meta?.requestId, 'cancelled', { reason });
         clearWorkerSlotsOnStop(scopeKey, reason);
     }
-    if (run?.cancelTurn && (getActiveMainCli(scopeKey) === 'codex-app' || getActiveMainCli(scopeKey) === 'pi')) {
+    if (run?.cancelTurn && ['codex-app', 'pi', 'cursor', 'grok', 'claude'].includes(getActiveMainCli(scopeKey) || '')) {
         if (run.process?.pid)
             killReasons.set(run.process.pid, reason);
         console.log(`[jaw:kill] reason=${reason} scope=${scopeKey} cli=${getActiveMainCli(scopeKey)} action=lease.cancel`);
@@ -481,7 +526,7 @@ export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
     if (!activeProcess) {
         if (reason === 'api' || reason === 'user' || reason === 'steer' || reason === 'interrupt')
             activeMainProcesses.delete(scopeKey);
-        return hadTimer || cancelledPendingMain || abortedInProcess;
+        return hadTimer || cancelledPendingMain || abortedInProcess || cancelledClaude;
     }
     const policy = getKillPolicy(scopeKey, reason);
     console.log(`[jaw:kill] reason=${reason} scope=${scopeKey} cli=${getActiveMainCli(scopeKey) || 'unknown'} signal=${policy.signal} escalationMs=${policy.escalationMs}`);
@@ -518,6 +563,8 @@ export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
     return true;
 }
 export function killAllAgents(reason = 'user') {
+    cancelAllSteerInputs();
+    const cancelledClaude = cancelAllClaudeRuns(reason);
     const hadTimer = queueCtrl.isRetryPending(null);
     const mainScopes = [...activeMainProcesses.keys()];
     let killedMain = false;
@@ -531,6 +578,10 @@ export function killAllAgents(reason = 'user') {
         console.log(`[jaw:killAll] killing ${id}, reason=${reason}`);
         if (proc.pid)
             killReasons.set(proc.pid, reason);
+        if (cancelOwnedPiProcess(proc, reason)) {
+            killed++;
+            continue;
+        }
         // Same owner contract as killActiveAgent: tree walk now, escalation
         // after the grace, guarded by real exit state rather than `killed`.
         ownProcess(proc, {
@@ -550,16 +601,23 @@ export function killAllAgents(reason = 'user') {
         activeMainProcesses.clear();
         clearAllWorkers();
     }
-    return killed > 0 || killedMain || hadTimer;
+    return killed > 0 || killedMain || hadTimer || cancelledClaude;
 }
 export function waitForProcessEnd(scopeKeyOrTimeout = 'default', scopedTimeout = 3000) {
     const scopeKey = typeof scopeKeyOrTimeout === 'string' ? scopeKeyOrTimeout : 'default';
     const timeoutMs = typeof scopeKeyOrTimeout === 'number' ? scopeKeyOrTimeout : scopedTimeout;
-    if (!activeMainProcesses.has(scopeKey))
+    return waitForScopedProcessEnd(scopeKey, timeoutMs, hasClaudeRuns);
+}
+/** Steer waits for main accounting, including pending main cleanup, but not surviving workers. */
+export function waitForMainProcessEnd(scopeKey, timeoutMs = 3000) {
+    return waitForScopedProcessEnd(scopeKey, timeoutMs, hasClaudeMainRuns);
+}
+function waitForScopedProcessEnd(scopeKey, timeoutMs, hasClaude) {
+    if (!activeMainProcesses.has(scopeKey) && !hasClaude(scopeKey))
         return Promise.resolve();
     return new Promise(resolve => {
         const check = setInterval(() => {
-            if (!activeMainProcesses.has(scopeKey)) {
+            if (!activeMainProcesses.has(scopeKey) && !hasClaude(scopeKey)) {
                 clearInterval(check);
                 clearTimeout(deadline);
                 resolve();
@@ -586,11 +644,11 @@ export function waitForProcessEnd(scopeKeyOrTimeout = 'default', scopedTimeout =
  *  force-exit budget. Returning on timeout is the same outcome as today, minus
  *  the common case where the child would have finished in milliseconds. */
 export function waitForAllProcessesEnd(timeoutMs = 2000) {
-    if (activeMainProcesses.size === 0)
+    if (activeMainProcesses.size === 0 && !hasClaudeRuns())
         return Promise.resolve();
     return new Promise(resolve => {
         const check = setInterval(() => {
-            if (activeMainProcesses.size === 0) {
+            if (activeMainProcesses.size === 0 && !hasClaudeRuns()) {
                 clearInterval(check);
                 clearTimeout(deadline);
                 resolve();
@@ -603,8 +661,9 @@ export function canSteerAgent(scopeKey) {
     const run = activeMainProcesses.get(scopeKey);
     if (run?.meta.cli === 'jwc' && jawRuntimesByScope.get(scopeKey)?.busy === true)
         return true;
-    // codex-app: the hook exists exactly while a steerable turn is in flight.
-    return typeof run?.steerTurnInBand === 'function';
+    // Route CLI steering through either the in-band hook or the native replacement hook.
+    // Each owning hook decides whether the current turn can still accept the input.
+    return typeof run?.steerTurnInBand === 'function' || typeof run?.replaceTurn === 'function';
 }
 export async function steerAgent(scopeKey, newPrompt, source, meta) {
     const run = activeMainProcesses.get(scopeKey);
@@ -613,7 +672,7 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
     if (run?.meta.cli === 'jwc' && runtime.busy) {
         insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, chatSessionId);
         broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
-        broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId, remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget }));
+        broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId, remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget, mode: 'native-input' }));
         await runtime.steer(settings["workingDir"] || process.cwd(), newPrompt);
         // A steer injects into the turn already running; no new completion
         // event will ever carry this id. Settling here is what stops a caller
@@ -621,6 +680,64 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
         settleOnce(meta?.requestId, 'steered');
         return 'steered';
     }
+    if (typeof run?.replaceTurn === 'function') {
+        const capturedSessionOwner = getSessionOwnershipGeneration(scopeKey);
+        const owner = run.meta;
+        const ownerTarget = isRemoteTarget(owner.target) ? owner.target : undefined;
+        const ownerRemoteKey = owner.remoteKey ?? (ownerTarget ? buildRemoteBindingKey(ownerTarget) : undefined);
+        const suppliedTarget = meta?.target;
+        if ((meta?.chatSessionId !== undefined && meta.chatSessionId !== owner.chatSessionId)
+            || (meta?.remoteKey !== undefined && meta.remoteKey !== ownerRemoteKey)
+            || (suppliedTarget !== undefined && (!isRemoteTarget(suppliedTarget)
+                || buildRemoteBindingKey(suppliedTarget) !== ownerRemoteKey
+                || (ownerTarget !== undefined && (buildRemoteBindingKey(suppliedTarget) !== buildRemoteBindingKey(ownerTarget)
+                    || suppliedTarget.targetKind !== ownerTarget.targetKind
+                    || suppliedTarget.guildId !== ownerTarget.guildId
+                    || suppliedTarget.parentTargetId !== ownerTarget.parentTargetId))))) {
+            throw new MainReplacementOwnerMismatchError();
+        }
+        const capturedMeta = { ...meta, ...(suppliedTarget === undefined ? {} : { target: { ...suppliedTarget } }) };
+        const capturedOwnerGeneration = run.ownerGeneration;
+        const workingDir = settings['workingDir'] || null;
+        let attempted = false;
+        const inputGuard = beginSteerInput(scopeKey);
+        let outcome, inputCancelled;
+        try {
+            outcome = await run.replaceTurn(newPrompt, () => {
+                if (activeMainProcesses.get(scopeKey) !== run || run.ownerGeneration !== capturedOwnerGeneration
+                    || !isCurrentSessionOwner(capturedSessionOwner, scopeKey)) {
+                    throw new MainReplacementOwnerMismatchError();
+                }
+                if (attempted)
+                    throw new Error('native_replacement_duplicate_input');
+                attempted = true; // A partial recording failure must never retry this input.
+                insertMessage.run('user', newPrompt, source, '', workingDir, chatSessionId);
+                broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
+                broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey,
+                    sessionId: chatSessionId, target: capturedMeta.target, chatId: capturedMeta.chatId,
+                    requestId: capturedMeta.requestId, remoteKey: capturedMeta.remoteKey, replyViaTarget: capturedMeta.replyViaTarget,
+                    mode: 'cancel-reprompt', localDispatch: true }));
+                settleOnce(capturedMeta.requestId, 'steered');
+            });
+        }
+        finally {
+            inputCancelled = inputGuard.isCancelled();
+            inputGuard.release();
+        }
+        if (outcome.kind === 'failed')
+            throw outcome.error;
+        if ((outcome.kind === 'dispatched') !== attempted)
+            throw new Error('native_replacement_inconsistent_receipt');
+        if (outcome.kind === 'dispatched')
+            return 'steered';
+        if (outcome.kind === 'cancelled' || inputCancelled) {
+            settleOnce(capturedMeta.requestId, 'cancelled', { reason: 'native-steer-stopped', scope: scopeKey, sessionId: chatSessionId });
+            return 'cancelled';
+        }
+        broadcast('steer_rejected', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey,
+            sessionId: chatSessionId, reason: outcome.reason, requestId: capturedMeta.requestId }));
+        return 'fallback-queue';
+    }
     if (typeof run?.steerTurnInBand === 'function') {
         // codex-app same-turn steer. The user row is written only AFTER the
         // server accepts — a fallback must not leave a duplicate insert for the
@@ -643,7 +760,7 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
         }
         insertMessage.run('user', newPrompt, source, '', settings["workingDir"] || null, chatSessionId);
         broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
-        broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId, remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget }));
+        broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey, sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId, remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget, mode: 'native-input' }));
         settleOnce(meta?.requestId, 'steered');
         return 'steered';
     }
@@ -654,7 +771,7 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
     const maxIdBeforeKill = getMaxMessageId(chatSessionId);
     const wasRunning = killActiveAgent(scopeKey, 'steer');
     if (wasRunning)
-        await waitForProcessEnd(scopeKey, steerWaitMs);
+        await waitForMainProcessEnd(scopeKey, steerWaitMs);
     // The kill removes the scope's map entry synchronously, so the wait above can
     // return before the exit handler's salvage insert. Wait for the settle barrier
     // armed by the kill so the follow-up run actually sees the partial output.
@@ -748,7 +865,7 @@ export function makeCleanEnv(extraEnv = {}, inheritedEnv = process.env, platform
     merged["PATH"] = buildServicePath(extraPath || env["PATH"] || '', [], os.homedir(), platform);
     return merged;
 }
-function buildHistoryBlock(currentPrompt, workingDir, chatSessionId, maxSessions = 10, maxTotalChars = 8000) {
+function buildHistoryBlock(currentPrompt, workingDir, chatSessionId, maxSessions = PROMPT_HISTORY_MAX_ROWS, maxTotalChars = PROMPT_HISTORY_MAX_CHARS) {
     const recent = getRecentMessages.all(workingDir || null, chatSessionId, Math.max(1, maxSessions * 2));
     if (!recent.length)
         return '';
@@ -837,7 +954,8 @@ export { buildMediaPrompt, buildMediaPromptMany };
 // ─── Spawn Agent ─────────────────────────────────────
 import { AcpClient } from '../cli/acp-client.js';
 import { CodexAppClient, CodexSteerError, isRecoverableResumeError } from './codex-app-client.js';
-import { acquireCodexAppRuntime, acquirePiRuntime, } from './runtime-pool.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';
@@ -864,27 +982,13 @@ export function spawnAgent(prompt, opts = {}) {
     const empTag = isEmployee ? { isEmployee: true } : {};
     const multiSessionEnabled = settings["multiSession"]?.enabled === true;
     const capturedScope = currentSessionScope();
-    const scopeKey = multiSessionEnabled
-        ? (opts.scopeKey || capturedScope?.scope || resolveOrcScope(stripUndefined({
-            origin,
-            target: opts.target,
-            chatId: opts.chatId,
-            workingDir: settings["workingDir"] || null,
-            persistedScopeId: opts.remoteKey,
-            multiSessionEnabled,
-        })))
-        : 'default';
-    const chatSessionId = multiSessionEnabled
-        ? (opts.chatSessionId || capturedScope?.chatSessionId || getActiveChatSession())
-        : getActiveChatSession();
-    if (multiSessionEnabled) {
-        opts = stripUndefined({
-            ...opts,
-            scopeKey,
-            chatSessionId,
-            ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}),
-        });
-    }
+    const binding = resolveExecutionBinding(stripUndefined({ scope: opts.scopeKey, chatSessionId: opts.chatSessionId,
+        captured: capturedScope, activeChatSessionId: getActiveChatSession(), origin,
+        target: opts.target, chatId: opts.chatId, workingDir: settings['workingDir'] || null,
+        persistedScopeId: opts.remoteKey, multiSessionEnabled }));
+    const scopeKey = binding.scope, chatSessionId = binding.chatSessionId;
+    opts = stripUndefined({ ...opts, scopeKey, chatSessionId,
+        ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}) });
     let mainRun = mainManaged ? activeMainProcesses.get(scopeKey) : undefined;
     if (mainManaged && mainRun && !opts._settingsGateWaited) {
         console.log(`[jaw] Agent already running for scope=${scopeKey}, skipping`);
@@ -905,14 +1009,15 @@ export function spawnAgent(prompt, opts = {}) {
             console.log('[jaw] Agent already running, skipping');
             return { child: null, promise: Promise.resolve({ text: '', code: -1 }) };
         }
-        mainRun.starting = true;
+        const waitingRun = mainRun;
+        waitingRun.starting = true;
         let cancelled = false;
         let cancelReason = 'user';
         const cancelThisSpawn = (reason) => {
             cancelled = true;
             cancelReason = reason;
         };
-        mainRun.cancelPending = cancelThisSpawn;
+        waitingRun.cancelPending = cancelThisSpawn;
         const promise = (async () => {
             try {
                 await waitForRuntimeSettingsIdle();
@@ -924,15 +1029,57 @@ export function spawnAgent(prompt, opts = {}) {
             }
             finally {
                 const latest = activeMainProcesses.get(scopeKey);
-                if (latest?.cancelPending === cancelThisSpawn)
-                    delete latest.cancelPending;
-                if (latest)
+                if (latest === waitingRun) {
+                    if (latest.cancelPending === cancelThisSpawn)
+                        delete latest.cancelPending;
                     latest.starting = false;
+                }
                 void processQueue(scopeKey);
             }
         })();
         return { child: null, promise };
     }
+    let resolve;
+    const resultPromise = new Promise(r => { resolve = r; });
+    const session = getSession() ?? {};
+    const persistenceOwner = getSessionOwnershipGeneration(scopeKey);
+    const ownerGeneration = persistenceOwner.global;
+    if (mainRun)
+        mainRun.ownerGeneration = ownerGeneration;
+    let cli = resolveMainCli(opts.cli, settings, session);
+    if (mainRun)
+        mainRun.meta.cli = cli;
+    // Namespace selection is captured once for this run. Builtin native
+    // Codex/Pi keep their existing bucket keys; only switchable adapters use
+    // the new namespace. Reject unavailable native choices before fallback,
+    // saved-session reads, bootstrap consumption, or worker isolation.
+    const runtimeTransport = isSwitchableNativeCli(cli)
+        ? resolveRuntimeTransport(settings['perCli']?.[cli]?.transport) : 'print';
+    const permissions = opts.permissions || settings['permissions'] || session.permissions || 'auto';
+    const unavailableNative = runtimeTransport === 'native'
+        && (!isNativeAdapterImplemented(cli) || (isEmployee && !isNativeWorkerImplemented(cli)));
+    const restrictiveNative = runtimeTransport === 'native' && (cli === 'cursor' || cli === 'grok') && permissions !== 'auto';
+    const unsupportedClaudePolicy = runtimeTransport === 'native' && cli === 'claude'
+        && permissions !== 'auto' && permissions !== 'safe';
+    const duplicateClaudeWorker = isEmployee && (hasClaudeWorker(opts.agentId || 'main')
+        || (runtimeTransport === 'native' && cli === 'claude' && activeProcesses.has(opts.agentId || 'main')));
+    if (unavailableNative || restrictiveNative || unsupportedClaudePolicy || duplicateClaudeWorker) {
+        const message = duplicateClaudeWorker ? 'Worker is still completing its previous assignment.'
+            : unsupportedClaudePolicy ? 'Claude native supports auto or safe permissions. Select print to retain this permission profile.'
+                : unavailableNative
+                    ? `${cli} native ${isEmployee ? 'worker ' : ''}transport is not implemented in this build. Set perCli.${cli}.transport to "print" to use compatibility mode.`
+                    : `${cli === 'cursor' ? 'Cursor' : 'Grok'} native restrictive permissions are not verified in this build. Select print transport to retain restrictive permission behavior.`;
+        const released = mainManaged && activeMainProcesses.get(scopeKey) === mainRun
+            && releaseMainRun(scopeKey, null, ownerGeneration);
+        broadcast('agent_done', {
+            text: message, error: true, origin, cli, scope: scopeKey, sessionId: chatSessionId,
+            ...(opts.requestId ? { requestId: opts.requestId } : {}), ...empTag,
+        }, isEmployee ? 'internal' : 'public');
+        resolve({ text: message, code: 78 });
+        if (released)
+            void processQueue(scopeKey);
+        return { child: null, promise: resultPromise };
+    }
     // Ensure AGENTS.md on disk is fresh before CLI reads it
     // Skip for employee spawns — distribute.ts manages AGENTS.md isolation
     if (!opts.internal && !opts._isFallback && !opts.agentId)
@@ -951,6 +1098,7 @@ export function spawnAgent(prompt, opts = {}) {
     if (mainManaged) {
         setCurrentMainMeta(scopeKey, stripUndefined({
             origin,
+            cli,
             target: opts.target,
             chatId: opts.chatId,
             requestId: opts.requestId,
@@ -960,21 +1108,11 @@ export function spawnAgent(prompt, opts = {}) {
             ...(opts.remoteKey ? { remoteKey: opts.remoteKey } : {}),
         }));
     }
-    let resolve;
-    const resultPromise = new Promise(r => { resolve = r; });
-    const session = getSession() ?? {};
-    const persistenceOwner = getSessionOwnershipGeneration(scopeKey);
-    const ownerGeneration = persistenceOwner.global;
-    if (mainRun)
-        mainRun.ownerGeneration = ownerGeneration;
-    let cli = resolveMainCli(opts.cli, settings, session);
-    if (mainRun)
-        mainRun.meta.cli = cli;
     // Phase 52: Bootstrap consumption is moved BELOW the bucket-aware `isResume`
     // computation so we can use the authoritative per-bucket resume decision
     // instead of the legacy `isResumeGuess` heuristic. See comment near line 762.
     // ─── Fallback retry: skip to fallback if retries exhausted ───
-    if (!opts._isFallback && !opts.internal) {
+    if (runtimeTransport !== 'native' && !opts._isFallback && !opts.internal) {
         const st = queueCtrl.fallbackStateForScope(scopeKey).get(cli);
         if (st?.fallbackCli && st.retriesLeft <= 0) {
             const fbAvail = detectCli(st.fallbackCli)?.available;
@@ -1041,7 +1179,6 @@ export function spawnAgent(prompt, opts = {}) {
         });
         return { child: null, promise: resultPromise };
     }
-    const permissions = opts.permissions || settings["permissions"] || session.permissions || 'auto';
     if (cli === 'opencode') {
         ensureOpencodeAlwaysAllowPermissions();
     }
@@ -1059,7 +1196,8 @@ export function spawnAgent(prompt, opts = {}) {
     const model = cli === 'ai-e' && effectiveProvider === 'claude'
         ? migrateLegacyClaudeValue(requestedModel)
         : requestedModel;
-    const runtimeModel = cli === 'cursor' ? resolveCursorModelVariant(model, effort) : model;
+    const runtimeModel = cli === 'cursor' && runtimeTransport !== 'native' ? resolveCursorModelVariant(model, effort)
+        : cli === 'grok' && runtimeTransport === 'native' && model === 'default' ? 'grok-build' : model;
     const codexMultiplexMain = cli === 'codex-app' && mainManaged && !opts.agentId
         && settings["runtime"]?.codexApp?.multiplex === true;
     if (mainManaged) {
@@ -1092,7 +1230,7 @@ export function spawnAgent(prompt, opts = {}) {
     // snapshot, no stale clear — because sharing one was worse. Having its own is better
     // than either. The default scope keeps the bare bucket name, so a session that existed
     // before this change continues the conversation it was already in.
-    const currentBucket = resolveScopedSessionBucket(cli, runtimeModel, effectiveProvider, scopeKey, effort, 'fallback', codexMultiplexMain);
+    const currentBucket = runtimeSessionBucket(resolveScopedSessionBucket(cli, runtimeModel, effectiveProvider, scopeKey, effort, 'fallback', codexMultiplexMain), runtimeTransport);
     const envDefaultsCli = cli === 'ai-e' ? effectiveProvider : cli;
     const cliEnv = applyCliEnvDefaults(envDefaultsCli, opts.env);
     const spawnEnv = makeCleanEnv(cliEnv);
@@ -1217,12 +1355,13 @@ export function spawnAgent(prompt, opts = {}) {
         codexMultiplexMain,
     });
     const historyBlock = needsHistory
-        ? buildHistoryBlock(prompt, settings["workingDir"], chatSessionId, 10, 8000)
+        ? buildHistoryBlock(prompt, settings["workingDir"], chatSessionId, PROMPT_HISTORY_MAX_ROWS, PROMPT_HISTORY_MAX_CHARS)
         : '';
     let agyBootstrap = null;
     let promptForArgs = buildPromptForArgs({
         cli,
         effectiveProvider,
+        runtimeTransport,
         prompt,
         historyBlock,
         sysPrompt,
@@ -1278,7 +1417,7 @@ export function spawnAgent(prompt, opts = {}) {
         return buildResumeArgs(cli, runtimeModel, effort, sid, promptForArgs, permissions, options);
     };
     let args = [];
-    if (cli !== 'agy')
+    if (cli !== 'agy' && runtimeTransport !== 'native')
         args = buildCurrentArgs(argOptions);
     const agentLabel = agentId || 'main';
     const traceAudience = (opts.internal || isEmployee) ? 'internal' : 'public';
@@ -1287,13 +1426,51 @@ export function spawnAgent(prompt, opts = {}) {
     // All CLIs auto-read AGENTS.md/CLAUDE.md/GEMINI.md from cwd.
     // Employees must NOT see the Boss's instruction files.
     let spawnCwd = settings["workingDir"];
+    let claudeEmployeeTmpDir;
+    let piEmployeeTmp;
+    const cleanupPiEmployee = () => {
+        if (!piEmployeeTmp)
+            return;
+        const owned = piEmployeeTmp;
+        try {
+            const stat = fs.lstatSync(owned.path, { bigint: true });
+            if (!stat.isDirectory() || stat.isSymbolicLink() || stat.dev !== owned.dev || stat.ino !== owned.ino
+                || fs.realpathSync(owned.path) !== owned.path) {
+                console.warn('[jaw:pi] retaining employee cwd: directory ownership changed', owned.path);
+                return;
+            }
+            fs.rmSync(owned.path, { recursive: true });
+            piEmployeeTmp = undefined;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            console.warn('[jaw:pi] retaining employee cwd: cleanup failed', owned.path);
+        }
+    };
     if (opts.agentId && (customSysPrompt || sysPrompt)) {
         const empPrompt = customSysPrompt || sysPrompt;
         const empPromptWithWorkspace = opts.workspaceContext
             ? `${opts.workspaceContext}\n\n${empPrompt}`
             : empPrompt;
-        const tmpDir = join(os.tmpdir(), `jaw-emp-${agentLabel}-${Date.now()}`);
+        const nativeClaude = runtimeTransport === 'native' && cli === 'claude';
+        const tmpDir = nativeClaude || cli === 'pi'
+            ? fs.mkdtempSync(join(cli === 'pi' ? fs.realpathSync(os.tmpdir()) : os.tmpdir(), `jaw-emp-${agentLabel.slice(0, 80).replace(/[^\w.-]/g, '_')}-`))
+            : join(os.tmpdir(), `jaw-emp-${agentLabel}-${Date.now()}`);
         fs.mkdirSync(tmpDir, { recursive: true });
+        if (nativeClaude)
+            claudeEmployeeTmpDir = tmpDir;
+        if (cli === 'pi') {
+            const created = fs.lstatSync(tmpDir, { bigint: true });
+            if (!created.isDirectory() || created.isSymbolicLink())
+                throw new Error('Pi employee cwd ownership unavailable');
+            const canonical = fs.realpathSync(tmpDir);
+            const stat = fs.lstatSync(canonical, { bigint: true });
+            if (canonical !== tmpDir || !stat.isDirectory() || stat.isSymbolicLink()
+                || stat.dev !== created.dev || stat.ino !== created.ino)
+                throw new Error('Pi employee cwd ownership unavailable');
+            piEmployeeTmp = { path: canonical, dev: stat.dev, ino: stat.ino };
+        }
         for (const name of ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', 'CONTEXT.md']) {
             fs.writeFileSync(join(tmpDir, name), empPromptWithWorkspace);
         }
@@ -1359,6 +1536,428 @@ export function spawnAgent(prompt, opts = {}) {
         if (cli === 'claude-e')
             console.log(`[jaw:${agentLabel}:args] ${JSON.stringify(args)}`);
     }
+    // ─── Native Claude: provider adaptation uses the shared host/lifecycle. ───
+    if (runtimeTransport === 'native' && cli === 'claude') {
+        const cleanupClaudeWorker = () => {
+            if (claudeEmployeeTmpDir)
+                cleanupEmployeeTmpDir(claudeEmployeeTmpDir, '', agentLabel);
+        };
+        const capturedRun = mainRun;
+        let capturedExit;
+        const ownedRun = () => isCurrentSessionOwner(persistenceOwner, scopeKey)
+            && (!mainManaged || activeMainProcesses.get(scopeKey) === capturedRun);
+        let attachedCancel;
+        const watchdog = {};
+        for (const key of ['firstProgressMs', 'idleMs', 'absoluteMs', 'absoluteHardCapMs']) {
+            const value = mergedTimeoutCfg[key];
+            if (typeof value === 'number')
+                watchdog[key] = value;
+        }
+        const prepared = { cwd: spawnCwd || process.cwd(), binary: detected.path || 'claude',
+            env: spawnEnv, model: runtimeModel, systemPrompt: sysPrompt, permissions: permissions,
+            fastMode: cfg.fastMode === true, ...(effort ? { effort: effort } : {}) };
+        try {
+            return startClaudeNativeRun({ prepared, timeoutMs: resolvedAgyPrintTimeoutMs, watchdog,
+                prompt: { text: withSteerContext(withHistoryPrompt(prompt, historyBlock), opts.steerContext), ...(opts.images ? { images: opts.images } : {}) },
+                audience: traceAudience, liveScope: effectiveLiveScope, parentLiveScope: parentLiveScopeForChild,
+                ...(opts.runtimeParentItemId ? { parentItemId: opts.runtimeParentItemId } : {}),
+                storedSessionId: resumeSessionId, fresh: forceNew || opts._skipResume === true || isEmployee,
+                cleanupUnleased: cleanupClaudeWorker,
+                isCurrent: ownedRun, isCurrentOwner: token => isCurrentSessionOwner(token, scopeKey), consumeKillReason,
+                activity: identity => opts.lifecycle?.onActivity?.('native-runtime', identity),
+                exited: code => opts.lifecycle?.onExit?.(code),
+                cancelling: reason => {
+                    if (reason === 'steer' || reason === 'interrupt') {
+                        armExitSettle(scopeKey);
+                        capturedExit ??= exitSettlers.get(scopeKey);
+                    }
+                },
+                exit: { cli, model: runtimeModel, effectiveProvider, agentLabel, mainManaged, origin, resumeKey, prompt, opts,
+                    cfg: { ...cfg, effort }, ownerGeneration, persistenceOwner, forceNew, empSid, isResume, effortDefault: effort,
+                    activeProcesses, scopeKey, runtimeTransport, scopedBucket: currentBucket, chatSessionId, releaseMainRun,
+                    retryState: queueCtrl.retryStateForScope(scopeKey), fallbackState: queueCtrl.fallbackStateForScope(scopeKey), fallbackMaxRetries: FALLBACK_MAX_RETRIES },
+                starting: cancel => {
+                    attachedCancel = cancel;
+                    if (capturedRun) {
+                        capturedRun.starting = true;
+                        capturedRun.cancelPending = cancel;
+                    }
+                },
+                ready: (child, cancel) => {
+                    if (!ownedRun())
+                        throw new Error('claude_owner_lost');
+                    attachedCancel ??= cancel;
+                    if (capturedRun) {
+                        capturedRun.process = child;
+                        capturedRun.starting = false;
+                        if (capturedRun.cancelPending === attachedCancel)
+                            delete capturedRun.cancelPending;
+                        capturedRun.cancelTurn = attachedCancel;
+                    }
+                    else
+                        registerActiveProcess(agentLabel, child);
+                },
+                finished: (child, _cancel, queued, cleanupSafe) => {
+                    try {
+                        if (capturedRun && capturedRun.cancelPending === attachedCancel)
+                            delete capturedRun.cancelPending;
+                        if (capturedRun && capturedRun.cancelTurn === attachedCancel)
+                            delete capturedRun.cancelTurn;
+                        if (capturedRun && activeMainProcesses.get(scopeKey) === capturedRun)
+                            releaseMainRun(scopeKey, child, ownerGeneration);
+                        if (!mainManaged && activeProcesses.get(agentLabel) === child)
+                            activeProcesses.delete(agentLabel);
+                        if (cleanupSafe)
+                            cleanupClaudeWorker();
+                    }
+                    finally {
+                        if (capturedExit && exitSettlers.get(scopeKey) === capturedExit) {
+                            exitSettlers.delete(scopeKey);
+                            capturedExit.resolve();
+                        }
+                        if (mainManaged && (queued || !activeMainProcesses.has(scopeKey)))
+                            void processQueue(scopeKey);
+                    }
+                },
+            });
+        }
+        catch {
+            if (capturedRun && activeMainProcesses.get(scopeKey) === capturedRun)
+                releaseMainRun(scopeKey, null, ownerGeneration);
+            cleanupClaudeWorker();
+            const text = 'Claude native runtime could not be admitted.';
+            broadcast('agent_done', { text, error: true, origin, cli, scope: scopeKey, sessionId: chatSessionId, ...empTag }, traceAudience);
+            if (mainManaged && !activeMainProcesses.has(scopeKey))
+                void processQueue(scopeKey);
+            return { child: null, promise: Promise.resolve({ text, code: 1 }) };
+        }
+    }
+    // ─── 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,
+        });
+        const diagnostic = () => grok ? 'Grok native runtime failed. Check the native model, effort and existing CLI login.' : facade?.lastError?.includes('config')
+            ? 'Cursor native model or effort is unsupported. Choose an advertised model/effort; Composer models may require an unset effort.'
+            : 'Cursor native runtime failed. 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,
+            };
+            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', { traceRunId, scope: scopeKey, sessionId: chatSessionId, origin, cli,
+                        ...(opts.requestId ? { requestId: opts.requestId } : {}),
+                        text: selected.status === 'stopped' ? '' : `❌ ${diagnostic()}`, error: true,
+                        runtimeStatus: selected.status, runtimeFinality: selected.finalText === null ? 'absent' : 'present',
+                    }, 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);
+        };
+        let nativeRun;
+        const cancelHook = (reason) => {
+            stopReason ??= reason;
+            if (reason === 'steer' || reason === 'interrupt') {
+                armExitSettle(scopeKey);
+                capturedExit ??= exitSettlers.get(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, 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;
+                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 = killReason === 'steer' || killReason === 'interrupt' || killReason === DUP_REGISTRATION_KILL_REASON;
+                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,
+                    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) => 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);
+                    if (capturedExit && exitSettlers.get(scopeKey) === capturedExit) {
+                        exitSettlers.delete(scopeKey);
+                        capturedExit.resolve();
+                    }
+                    // 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 };
+    }
     // ─── Copilot ACP branch ──────────────────────
     if (cli === 'copilot') {
         // Write model + reasoning_effort to ~/.copilot/config.json (CLI flags unsupported)
@@ -1423,6 +2022,7 @@ export function spawnAgent(prompt, opts = {}) {
                 activeProcesses.delete(agentLabel);
             }
             broadcast('agent_done', { 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);
@@ -1434,7 +2034,7 @@ export function spawnAgent(prompt, opts = {}) {
             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 });
+        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
         if (mainManaged && !opts.internal)
             setLiveRunTraceId(liveScope, traceRunId);
         const ctx = {
@@ -1449,7 +2049,10 @@ export function spawnAgent(prompt, opts = {}) {
             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)
@@ -1485,6 +2088,7 @@ export function spawnAgent(prompt, opts = {}) {
                 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;
                 }
@@ -1515,11 +2119,13 @@ export function spawnAgent(prompt, opts = {}) {
                 // 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);
@@ -1648,6 +2254,7 @@ export function spawnAgent(prompt, opts = {}) {
                     // 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)`);
@@ -1684,6 +2291,7 @@ export function spawnAgent(prompt, opts = {}) {
             //   - trace: if (traceText) traceText = `⏹️ [interrupted]…`
             handleAgentExit({
                 ctx, code: acpCode, cli, model, agentLabel, mainManaged, origin,
+                onRuntimeEnd: end => ctx.printActivity?.finish(end),
                 resumeKey,
                 prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                 isResume, wasKilled, wasSteer, smokeResult,
@@ -1691,6 +2299,7 @@ export function spawnAgent(prompt, opts = {}) {
                 resolve: resolve,
                 activeProcesses,
                 scopeKey,
+                runtimeTransport,
                 scopedBucket: currentBucket,
                 chatSessionId,
                 childProcess: child,
@@ -1707,6 +2316,13 @@ export function spawnAgent(prompt, opts = {}) {
     }
     // ─── Pi RPC branch ─────────────────────────────
     if (cli === 'pi') {
+        let piExit = exitSettlers.get(scopeKey);
+        const settlePiExit = () => {
+            if (!piExit || exitSettlers.get(scopeKey) !== piExit)
+                return;
+            exitSettlers.delete(scopeKey);
+            piExit.resolve();
+        };
         const pi = normalizePiSettings(settings["pi"]);
         const profileId = cfg.provider || pi.defaultProfileId;
         const profile = pi.profiles.find((entry) => entry.id === profileId) || pi.profiles[0];
@@ -1716,7 +2332,7 @@ export function spawnAgent(prompt, opts = {}) {
         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 });
+        const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
         const ctx = {
             fullText: '',
             traceLog: [],
@@ -1742,6 +2358,19 @@ export function spawnAgent(prompt, opts = {}) {
             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)
@@ -1767,7 +2396,13 @@ export function spawnAgent(prompt, opts = {}) {
         ].join('\n');
         const piSysPrompt = sysPrompt ? `${sysPrompt}\n\n${piToolDiscipline}` : piToolDiscipline;
         const onPiEvent = (event) => {
-            opts.lifecycle?.onActivity?.('pi-rpc');
+            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;
@@ -1811,10 +2446,29 @@ export function spawnAgent(prompt, opts = {}) {
             if (event.kind === 'session')
                 ctx.sessionId = event.sessionId;
         };
-        const runPiTurn = (child, done, lease) => {
+        const runPiTurn = (child, done, lease, directCleanup) => {
             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();
                     if (child.pid) {
                         const pid = child.pid;
                         killProcessTree(pid, 'SIGTERM');
@@ -1829,43 +2483,85 @@ export function spawnAgent(prompt, opts = {}) {
                 leaseCancel ??= lease.cancel();
                 return leaseCancel;
             };
-            const cancelHook = (_reason) => { void requestCancel(); };
+            const cancelHook = (reason) => {
+                if (cleanupDone)
+                    return;
+                if (reason === 'steer' || reason === 'interrupt')
+                    piExit = exitSettlers.get(scopeKey);
+                void requestCancel();
+            };
             if (lease && mainRun)
                 mainRun.cancelTurn = cancelHook;
-            const 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);
+            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);
             }
-            if (mainManaged && !opts.internal && !opts._skipInsert) {
-                insertMessage.run('user', prompt, cli, runtimeModel, settings["workingDir"] || null, chatSessionId);
+            catch (error) {
+                setupError = error;
+                try {
+                    void requestCancel().catch(() => { console.warn('[jaw:pi] setup cancellation failed'); });
+                }
+                catch {
+                    console.warn('[jaw:pi] setup cancellation failed');
+                }
             }
-            if (!opts.internal)
-                broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, provider: profile.id, ...empTag }, traceAudience);
             const releaseLease = async () => {
-                if (leaseCancel)
-                    await leaseCancel;
-                if (mainRun?.cancelTurn === cancelHook)
-                    delete mainRun.cancelTurn;
-                if (lease)
-                    lease.release();
-                else
-                    cleanupEmployeeTmpDir(spawnCwd, settings["workingDir"], agentLabel);
+                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);
+                    }
+                }
             };
             done.then(async (result) => {
-                piWatchdog.stop();
-                await releaseLease();
+                if (setupError !== undefined)
+                    throw setupError;
+                if (result.runtimeOutcome !== undefined)
+                    handoffRuntimeOutcome(ctx, result.runtimeOutcome);
+                const killReason = consumeKillReason(child.pid);
+                stopWatchdog();
                 flushPiThinking();
                 if (ctx.stderrBuf.length < 4000)
                     ctx.stderrBuf += result.stderr || '';
@@ -1873,8 +2569,12 @@ export function spawnAgent(prompt, opts = {}) {
                     ctx.sessionId = result.sessionId;
                 if (!ctx.fullText && result.text)
                     ctx.fullText = result.text;
-                opts.lifecycle?.onExit?.(result.code);
-                const killReason = consumeKillReason(child.pid);
+                try {
+                    opts.lifecycle?.onExit?.(result.code);
+                }
+                catch {
+                    console.warn('[jaw:pi] exit observer failed');
+                }
                 const wasKilled = !!killReason;
                 // 'dup-registration' behaves like a steer for cleanup purposes: a
                 // replacement child already owns this label, so the stale exit handler
@@ -1882,62 +2582,116 @@ export function spawnAgent(prompt, opts = {}) {
                 const wasSteer = killReason === 'steer' || killReason === DUP_REGISTRATION_KILL_REASON;
                 const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, result.code, cli);
                 return handleAgentExit({
+                    onRuntimeEnd: (end) => { activity.close(end); },
                     ctx, code: result.code, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
                     resumeKey,
                     prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
                     isResume: false, wasKilled, wasSteer, smokeResult,
                     effortDefault: 'medium', costLine: '',
-                    resolve: resolve,
+                    resolve: recordResult,
                     activeProcesses,
                     scopeKey,
+                    runtimeTransport,
                     scopedBucket: currentBucket,
                     chatSessionId,
                     childProcess: child,
-                    releaseMainRun,
+                    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,
-                }).finally(() => settleExit(scopeKey));
-            }).catch(async (err) => {
-                piWatchdog.stop();
-                await releaseLease().catch(() => { });
+                    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 = killReason === 'steer' || killReason === DUP_REGISTRATION_KILL_REASON;
+                stopWatchdog();
                 if (ctx.stderrBuf.length < 4000)
                     ctx.stderrBuf += err.message;
                 console.error('[jaw:pi] runtime failed:', err.message);
-                handleAgentExit({
+                return handleAgentExit({
+                    onRuntimeEnd: (end) => { activity.close(end); },
                     ctx, code: 1, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
                     resumeKey,
                     prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
-                    isResume: false, wasKilled: false, wasSteer: false, smokeResult: detectSmokeResponse('', [], 1, cli),
+                    isResume: false, wasKilled, wasSteer, smokeResult: detectSmokeResponse('', [], 1, cli),
                     effortDefault: 'medium', costLine: '',
-                    resolve: resolve,
+                    resolve: recordResult,
                     activeProcesses,
                     scopeKey,
+                    runtimeTransport,
                     scopedBucket: currentBucket,
                     chatSessionId,
                     childProcess: child,
-                    releaseMainRun,
+                    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,
-                }).catch((handleErr) => {
-                    console.error('[jaw:lifecycle] handleAgentExit failed (Pi):', handleErr.message);
-                }).finally(() => settleExit(scopeKey));
+                    processQueue: requestQueue,
+                });
+            }).catch((handleErr) => {
+                activity.close({ 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) {
-            const { child, done } = spawnPiRpc(profile, pi, {
-                prompt: piPrompt,
-                model: runtimeModel,
-                ...(piSessionId ? { sessionId: piSessionId } : {}),
-                effort,
-                cwd: spawnCwd,
-                sysPrompt: piSysPrompt,
-                onEvent: onPiEvent,
-            });
-            runPiTurn(child, done, null);
+            let execution;
+            try {
+                execution = spawnPiRpc(profile, pi, {
+                    prompt: piPrompt, model: runtimeModel,
+                    ...(piSessionId ? { sessionId: piSessionId } : {}),
+                    effort, cwd: spawnCwd, sysPrompt: piSysPrompt,
+                    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;
+            }
+            const { child, done, cleanup } = execution;
+            runPiTurn(child, done, null, cleanup ?? null);
             return { child, promise: resultPromise };
         }
         const profileFp = crypto.createHmac('sha256', piProfileFingerprintKey)
@@ -1962,20 +2716,62 @@ export function spawnAgent(prompt, opts = {}) {
             forceNew,
         }).then((lease) => {
             mainRun.starting = false;
+            if (activeMainProcesses.get(scopeKey) !== mainRun || !isCurrentSessionOwner(persistenceOwner, scopeKey)) {
+                lease.release();
+                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({ text: '', code: 130, runtimeOutcome: { status: 'stopped', finalText: null, partialText: '' } });
+                return;
+            }
             ctx.sessionId = lease.session.sessionId;
             console.log(`[jaw:pi:pool] reused=${lease.reused} sessionId=${lease.session.sessionId || 'new'}`);
-            const done = lease.session.sendPrompt(piPrompt, { effort, onEvent: onPiEvent })
-                .then((result) => ({ ...result, code: 0, sessionId: lease.session.sessionId }));
-            runPiTurn(lease.session.child, done, lease);
+            let done;
+            try {
+                done = lease.session.sendPrompt(piPrompt, { effort, onEvent: onPiEvent, onRawRecord: onPiRawRecord })
+                    .then((result) => ({ ...result, code: 0, sessionId: lease.session.sessionId }));
+            }
+            catch (error) {
+                done = Promise.reject(error);
+            }
+            runPiTurn(lease.session.child, done, lease, null);
         }).catch((err) => {
             mainRun.starting = false;
             console.error(`[jaw:pi:pool] acquire failed: ${err.message}`);
-            clearLiveRun(liveScope);
-            broadcast('agent_status', { running: false, agentId: agentLabel });
-            broadcast('agent_done', { text: `❌ Pi RPC acquire failed: ${err.message}`, error: true, origin }, 'public');
-            releaseMainRun(scopeKey, null, ownerGeneration);
+            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', { 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 });
-            void processQueue(scopeKey);
+            if (ownsRun) {
+                settlePiExit();
+                void processQueue(scopeKey);
+            }
         });
         return { child: null, promise: resultPromise };
     }
@@ -1993,7 +2789,7 @@ export function spawnAgent(prompt, opts = {}) {
         }
         if (!opts.internal)
             broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...empTag }, traceAudience);
-        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
+        const traceRunId = startTraceRun({ cli, model, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
         if (mainManaged && !opts.internal)
             setLiveRunTraceId(liveScope, traceRunId);
         const ctx = {
@@ -2008,7 +2804,15 @@ export function spawnAgent(prompt, opts = {}) {
             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;
@@ -2202,6 +3006,9 @@ export function spawnAgent(prompt, opts = {}) {
                     });
                 },
                 onEvent: consumeCodexAppEvent,
+                onProjectionNotification: (method, params, parsed) => {
+                    codexProjection.observe(method, params, parsed, ctx.codexAppActiveChannel || '');
+                },
                 onStderr: handleStderr,
                 onExit: (code, signal) => {
                     processExit.value = { code, signal };
@@ -2277,6 +3084,7 @@ export function spawnAgent(prompt, opts = {}) {
                     // 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)`);
@@ -2324,6 +3132,7 @@ export function spawnAgent(prompt, opts = {}) {
             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,
                 resumeKey,
                 prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
@@ -2332,6 +3141,7 @@ export function spawnAgent(prompt, opts = {}) {
                 resolve: resolve,
                 activeProcesses,
                 scopeKey,
+                runtimeTransport,
                 scopedBucket: currentBucket,
                 chatSessionId,
                 ...(lease?.bucketKey ? { codexAppBucket: lease.bucketKey } : {}),
@@ -2342,6 +3152,7 @@ export function spawnAgent(prompt, opts = {}) {
                 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));
         };
@@ -2350,10 +3161,19 @@ export function spawnAgent(prompt, opts = {}) {
             const appClient = new CodexAppClient({
                 binary: detected.path || 'codex', workDir: spawnCwd, env: spawnEnv,
             });
-            appClient.spawn();
-            const child = appClient.proc;
-            if (!child)
-                throw new Error('Codex AppServer process was not created');
+            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 };
         }
@@ -2474,6 +3294,7 @@ export function spawnAgent(prompt, opts = {}) {
             // 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');
                 clearLiveRun(liveScope);
                 broadcast('agent_status', { running: false, agentId: agentLabel });
@@ -2494,12 +3315,25 @@ export function spawnAgent(prompt, opts = {}) {
             await runCodexAppTurn(lease.client, lease, lease.laneScope);
         }).catch((err) => {
             console.error(`[codex-app:pool] acquire failed: ${err.message}`);
-            clearLiveRun(liveScope);
-            broadcast('agent_status', { running: false, agentId: agentLabel });
-            broadcast('agent_done', { text: `❌ Codex AppServer acquire failed: ${err.message}`, error: true, origin }, 'public');
-            releaseMainRun(scopeKey, null, ownerGeneration);
+            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', { text: `❌ Codex AppServer acquire failed: ${err.message}`, error: true, origin }, 'public');
+                releaseMainRun(scopeKey, null, ownerGeneration);
+            }
             resolve({ text: '', code: 1 });
-            void processQueue(scopeKey);
+            if (ownsRun) {
+                settleExit(scopeKey);
+                void processQueue(scopeKey);
+            }
         });
         return { child: null, promise: resultPromise };
     }
@@ -2638,6 +3472,7 @@ export function spawnAgent(prompt, opts = {}) {
             activeProcesses.delete(agentLabel);
         }
         broadcast('agent_done', { text: `❌ ${msg}`, error: true, origin, ...empTag }, isEmployee ? 'internal' : 'public');
+        finishPrintActivity(ctx, { kind: 'turn-end', status: 'error', finalText: null, error: msg });
         resolve({ text: '', code: 127 });
         if (mainManaged)
             void processQueue(scopeKey);
@@ -2665,7 +3500,7 @@ export function spawnAgent(prompt, opts = {}) {
     child.stdin.end();
     if (!opts.internal)
         broadcast('agent_status', { status: 'running', cli, agentId: agentLabel, ...runtimeStatusMeta, ...empTag }, traceAudience);
-    const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience });
+    const traceRunId = startTraceRun({ cli, model: runtimeModel, workingDir: settings["workingDir"] || null, agentLabel, audience: traceAudience, sessionId: chatSessionId, scopeKey });
     if (mainManaged && !opts.internal)
         setLiveRunTraceId(liveScope, traceRunId);
     // Native `agy --conversation ... -p` may emit only the current answer.
@@ -2694,6 +3529,7 @@ export function spawnAgent(prompt, opts = {}) {
         parentLiveScope: parentLiveScopeForChild,
         traceRunId,
         traceAudience,
+        activityIdentity: { sessionId: chatSessionId, scope: scopeKey },
         ...(opencodeSpawnAudit ? { opencodeSpawnAudit: opencodeSpawnAudit } : {}),
         ...(agyResumeOffset > 0 ? { agyResumeOffset, agyBytesReceived: 0 } : {}),
         ...(cli === 'agy' ? {
@@ -2710,6 +3546,8 @@ export function spawnAgent(prompt, opts = {}) {
         ...(kiroPlainText || cli === 'agy' || cli === 'pi' ? { liveOutputText: '' } : {}),
         ...(kiroPlainText ? { kiroLastVisibleAt: Date.now(), kiroHeartbeatSent: false } : {}),
     };
+    ctx.printActivity = createPrintActivity({ runId: traceRunId, sessionId: chatSessionId,
+        scope: scopeKey, turnId: traceRunId, audience: traceAudience }, cli);
     let agyClosing = false;
     let agyGuardedStaleDetected = false;
     const scheduleAgyQuietCompletion = () => {
@@ -2866,6 +3704,10 @@ export function spawnAgent(prompt, opts = {}) {
         }
         const outputChunk = extractOutputChunk(dispatchCli, event, ctx);
         if (outputChunk) {
+            // Dedicated providers observe before their destructive legacy resets.
+            // Copilot's ordinary print fallback exposes only accepted assistant text here.
+            if (dispatchCli === 'copilot')
+                ctx.printActivity?.message(outputChunk, 'append', 'unknown');
             broadcastAgentOutput(ctx, agentLabel, cli, outputChunk, empTag, (opts.internal || isEmployee) ? 'internal' : 'public');
         }
     };
@@ -2916,6 +3758,7 @@ export function spawnAgent(prompt, opts = {}) {
                 ctx.agyResumeOffset = 0;
                 if (!newText)
                     return;
+                ctx.printActivity?.message(newText, 'append', 'unknown');
                 if (ctx.liveOutputText !== undefined)
                     ctx.liveOutputText += newText;
                 ctx.outputTextStarted = true;
@@ -2948,6 +3791,7 @@ export function spawnAgent(prompt, opts = {}) {
                 return;
             }
             appendTraceEvent({ runId: ctx.traceRunId, source: 'cli_raw', eventType: 'plain_text', raw: displayText });
+            ctx.printActivity?.message(displayFullText, 'replace', 'unknown');
             broadcastAgentOutput(ctx, agentLabel, cli, displayText, empTag, traceAudience);
             scheduleAgyQuietCompletion();
             return;
@@ -3086,6 +3930,7 @@ export function spawnAgent(prompt, opts = {}) {
                     releaseMainRun(scopeKey, child, ownerGeneration);
                 else
                     activeProcesses.delete(agentLabel);
+                finishPrintActivity(ctx, { kind: 'turn-end', status: 'stopped', finalText: null, error: 'AGY stale resume; retrying fresh' });
                 const { promise: freshPromise } = spawnAgent(prompt, {
                     ...opts, _agyStaleFreshRetry: true, _skipResume: true, _skipInsert: true,
                 });
@@ -3257,6 +4102,7 @@ export function spawnAgent(prompt, opts = {}) {
         //   - trace: if (traceText) traceText = `⏹️ [interrupted]…`
         handleAgentExit({
             ctx, code: effectiveExitCode, cli, model: runtimeModel, effectiveProvider, agentLabel, mainManaged, origin,
+            onRuntimeEnd: end => ctx.printActivity?.finish(end),
             resumeKey,
             prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid,
             isResume, wasKilled, wasSteer, smokeResult,
@@ -3264,6 +4110,7 @@ export function spawnAgent(prompt, opts = {}) {
             resolve: resolve,
             activeProcesses,
             scopeKey,
+            runtimeTransport,
             scopedBucket: currentBucket,
             chatSessionId,
             childProcess: child,