cli-jaw 2.17.38 → 2.17.39

package/dist/src/agent/lifecycle-handler.js

@@ -2,7 +2,7 @@
 // Extracted from spawn.ts to unify ACP + CLI exit handling.
 import { broadcast } from '../core/bus.js';
 import { settings, detectCli } from '../core/config.js';
-import { clearEmployeeSession, insertMessage, insertMessageWithTraceRun, updateSession, clearSessionBucket, markAnchorConsumed, updateSessionBucketLastRun } from '../core/db.js';
+import { clearEmployeeSession, insertMessage, insertMessageWithTrace, insertMessageWithTraceRun, updateSession, clearSessionBucket, markAnchorConsumed, updateSessionBucketLastRun } from '../core/db.js';
 import { getActiveChatSession } from '../core/chat-sessions.js';
 import { persistMainSession } from './session-persistence.js';
 import { resolveSessionBucket } from './args.js';
@@ -18,6 +18,8 @@ import { clearLiveRun, getLiveRun } from './live-run-state.js';
 import { sanitizeToolLogForDurableStorage, serializeSanitizedToolLog } from '../shared/tool-log-sanitize.js';
 import { scanStructuredFence } from '../shared/structured-fence.js';
 import { finalizeTraceRun, linkTraceRunToMessage } from '../trace/store.js';
+import { mergeLatestTools } from './merge-tool-log.js';
+import { handoffRuntimeOutcome, lifecycleRuntimeOutcome, runtimeOutcomeExitCode } from './runtime/outcome.js';
 import { resolveSpawnOutputText } from './events/helpers.js';
 import { isKiroPlainTextCli, isKiroResumeDegradedOutput } from './kiro-runtime.js';
 import { incrementMemoryFlush, countTurnForFlush, triggerMemoryFlush, memoryFlushCounter, } from './memory-flush-controller.js';
@@ -137,6 +139,10 @@ function lifecycleRuntimeCli(cli, provider) {
         return cli;
     return provider === 'claude' ? 'claude-e' : (provider || cli);
 }
+/** Compatibility delivery alone collapses whitespace; canonical data stays exact. */
+function runtimeCompatibilityText(finalText) {
+    return finalText === null || finalText.trim().length === 0 ? '' : finalText;
+}
 /** Tag agent_done with the trace run that produced it so the web UI can drop
  *  SSE replays of already-finished turns instead of mid-turn-finalizing the
  *  in-flight one (devlog 260612 manager_stream_hidden_state_audit 06-08). */
@@ -150,7 +156,11 @@ function runTag(ctx) {
  * fallback recovery, output save, error classification, 429 retry, fallback.
  */
 export async function handleAgentExit(params) {
-    const { ctx, code, cli, model, agentLabel, mainManaged, origin, prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid, isResume, wasKilled, wasSteer, smokeResult, effortDefault, costLine, resolve, activeProcesses, scopeKey, chatSessionId, codexAppBucket, childProcess, releaseMainRun, retryState, fallbackState, fallbackMaxRetries, processQueue, } = params;
+    const { ctx, code: processCode, cli, model, agentLabel, mainManaged, origin, prompt, opts, cfg, ownerGeneration, persistenceOwner, forceNew, empSid, isResume, wasKilled, wasSteer, smokeResult, effortDefault, costLine, resolve, activeProcesses, scopeKey, chatSessionId, childProcess, releaseMainRun, retryState, fallbackState, fallbackMaxRetries, processQueue, } = params;
+    const nativeOutcome = lifecycleRuntimeOutcome(ctx, wasKilled || wasSteer || Boolean(ctx.stallReason));
+    const code = runtimeOutcomeExitCode(nativeOutcome, processCode);
+    const nativeRequestId = ctx.requestId ?? opts.requestId;
+    const nativeTraceRunId = ctx.traceRunId;
     const effectiveProvider = params.effectiveProvider;
     const runtimeCli = lifecycleRuntimeCli(cli, effectiveProvider);
     const effortVal = cfg.effort || effortDefault;
@@ -164,9 +174,51 @@ export async function handleAgentExit(params) {
     const isEmployee = !mainManaged;
     const empTag = isEmployee ? { isEmployee: true } : {};
     const liveScope = ctx.liveScope || 'default';
-    const traceStatus = code === 0 ? 'done' : wasKilled ? 'interrupted' : 'error';
+    const ownsLiveRun = () => nativeOutcome === undefined
+        || (typeof ctx.traceRunId === 'string' && getLiveRun(liveScope).traceRunId === ctx.traceRunId);
+    const traceStatus = nativeOutcome === undefined
+        ? code === 0 ? 'done' : wasKilled ? 'interrupted' : 'error'
+        : nativeOutcome.status === 'stopped' ? 'interrupted' : nativeOutcome.status;
+    let runtimeFinalText = null;
+    let runtimeEnded = false;
+    const finalizeRun = (status, error) => {
+        if (!runtimeEnded) {
+            runtimeEnded = true;
+            const stopped = wasKilled || wasSteer || Boolean(ctx.stallReason) || status === 'interrupted';
+            try {
+                params.onRuntimeEnd?.({
+                    kind: 'turn-end',
+                    status: nativeOutcome === undefined
+                        ? stopped ? 'stopped' : status === 'error' ? 'error' : 'done'
+                        : nativeOutcome.status,
+                    finalText: runtimeFinalText,
+                    ...(error ? { error } : {}),
+                });
+            }
+            catch {
+                console.warn('[runtime:projection] lifecycle observer failed');
+            }
+        }
+        if (nativeOutcome === undefined) {
+            try {
+                finalizeTraceRun(ctx.traceRunId, status, error);
+            }
+            catch {
+                console.warn('[trace] print finalization failed');
+            }
+        }
+        else {
+            try {
+                finalizeTraceRun(nativeTraceRunId, status, error);
+            }
+            catch {
+                console.warn('[runtime] outcome trace finalization failed');
+            }
+        }
+    };
     // ─── Smoke response auto-continuation ───
-    if (smokeResult.isSmoke
+    if (nativeOutcome === undefined
+        && smokeResult.isSmoke
         && smokeResult.confidence !== 'low'
         && !opts._isSmokeContinuation
         && !opts.internal
@@ -187,6 +239,7 @@ export async function handleAgentExit(params) {
                 skipSessionPersist: opts._skipSessionPersist === true,
                 outputLen: params.outputLen,
                 ...(params.codexAppBucket ? { codexAppBucket: params.codexAppBucket } : {}),
+                runtimeTransport: params.runtimeTransport,
                 scopedBucket: runBucket,
             });
             console.log(`[jaw:smoke] persisted session ${smokeSessionId.slice(0, 12)}... for continuation`);
@@ -195,7 +248,7 @@ export async function handleAgentExit(params) {
         if (releaseMainRun(scopeKey, childProcess, ownerGeneration)) {
             broadcast('agent_status', { running: false, agentId: agentLabel, scope: scopeKey, ...empTag });
         }
-        finalizeTraceRun(ctx.traceRunId, 'done');
+        finalizeRun('done');
         const contPrompt = buildContinuationPrompt(prompt, ctx.fullText);
         const { promise: contPromise } = _spawnAgent(contPrompt, {
             ...opts, _isSmokeContinuation: true, _skipInsert: true,
@@ -231,12 +284,19 @@ export async function handleAgentExit(params) {
     else {
         activeProcesses.delete(agentLabel);
     }
+    if (nativeOutcome !== undefined && wasSteer && mainManaged && !opts.internal
+        && nativeOutcome.partialText.length > 0) {
+        // The existing MAX(id) salvage query reads MESSAGE rows, not Activity.
+        // Commit before asynchronous cleanup and the caller's settleExit barrier.
+        const partialTools = sanitizeToolLogForDurableStorage(ctx.toolLog);
+        insertMessageWithTrace.run('assistant', '⏹️ [interrupted]\n\n' + nativeOutcome.partialText, cli, model, ctx.traceLog.join('\n') || null, serializeSanitizedToolLog(partialTools), settings['workingDir'] || null, chatSessionId);
+    }
     // Post-flush reindex moved into memory-flush-controller's completion path
     // (032). Firing it here raced the append: this runs before the extractor
     // promise resolves, so it reindexed a file that did not yet contain the
     // entry — and a generation that had already expired could still trigger it.
     // ─── CLI-native compact → auto session refresh (awaited to avoid race with processQueue) ───
-    if (ctx.cliNativeCompactDetected && mainManaged && !opts.internal) {
+    if (nativeOutcome === undefined && ctx.cliNativeCompactDetected && mainManaged && !opts.internal) {
         console.log('[jaw:compact] CLI-native compaction detected — auto-refreshing session');
         try {
             const { autoCompactRefresh } = await import('../core/compact.js');
@@ -247,7 +307,7 @@ export async function handleAgentExit(params) {
                 model,
                 scopeKey,
                 chatSessionId,
-                ...(codexAppBucket === undefined ? {} : { sessionBucket: codexAppBucket }),
+                sessionBucket: runBucket,
             });
         }
         catch (e) {
@@ -263,6 +323,7 @@ export async function handleAgentExit(params) {
         skipSessionPersist: opts._skipSessionPersist === true,
         outputLen: params.outputLen,
         ...(params.codexAppBucket ? { codexAppBucket: params.codexAppBucket } : {}),
+        runtimeTransport: params.runtimeTransport,
         scopedBucket: runBucket,
     })) {
         console.log(`[jaw:session] saved ${cli} session=${persistedSessionId.slice(0, 12)}...${wasKilled ? ' (post-kill)' : ''}`);
@@ -276,7 +337,7 @@ export async function handleAgentExit(params) {
     // ─── Phase 54-A: Proactive compact by turn count ───
     // CLIs without a reliable native compact/resume path get a conservative
     // turn-count refresh. AGY owns its compaction and keeps its conversation.
-    if (mainManaged && !opts.internal && code === 0 && !ctx.cliNativeCompactDetected) {
+    if (nativeOutcome === undefined && mainManaged && !opts.internal && code === 0 && !ctx.cliNativeCompactDetected) {
         const turns = ctx.turns ?? memoryFlushCounter;
         const useTurnCountRefresh = shouldUseTurnCountRefresh(runtimeCli);
         if (useTurnCountRefresh && turns >= 35) {
@@ -290,7 +351,7 @@ export async function handleAgentExit(params) {
                     model,
                     scopeKey,
                     chatSessionId,
-                    ...(codexAppBucket === undefined ? {} : { sessionBucket: codexAppBucket }),
+                    sessionBucket: runBucket,
                 });
             }
             catch (e) {
@@ -308,7 +369,7 @@ export async function handleAgentExit(params) {
     // ─── High-turn native-compaction coordination ───
     // AGY keeps a native compacted conversation. Other CLIs still use the
     // conservative fresh-session guard when their compaction is not observable.
-    if (mainManaged && !opts.internal && code === 0 && !ctx.cliNativeCompactDetected) {
+    if (nativeOutcome === undefined && mainManaged && !opts.internal && code === 0 && !ctx.cliNativeCompactDetected) {
         const turns = ctx.turns ?? memoryFlushCounter;
         if (shouldClearHighTurnSessionBucket(runtimeCli, turns)) {
             console.log(`[jaw:compact] ${cli} exited after ${turns} turns — clearing session bucket for fresh start`);
@@ -332,7 +393,7 @@ export async function handleAgentExit(params) {
     // cleared here and nowhere else. Same key space as the write (#519).
     if (code === 0)
         clearRuntimeCooldown(runtimeCli);
-    if (code === 0 && runtimeCli === 'grok') {
+    if (nativeOutcome === undefined && code === 0 && runtimeCli === 'grok') {
         const recovered = backfillGrokTraceTools(ctx);
         if (recovered > 0) {
             console.log(`[jaw:grok] recovered ${recovered} tool event(s) from Grok trace export`);
@@ -344,7 +405,8 @@ export async function handleAgentExit(params) {
     // A genuine stale resume does ZERO work, so require an empty toolLog: a turn that
     // actually ran tools must never be reclassified as stale and silently discarded.
     const kiroDiagnosticText = `${ctx.stderrBuf}\n${ctx.fullText}`;
-    if (isKiroPlainTextCli(cli, effectiveProvider)
+    if (nativeOutcome === undefined
+        && isKiroPlainTextCli(cli, effectiveProvider)
         && isResume
         && mainManaged
         && !opts.internal
@@ -371,7 +433,7 @@ export async function handleAgentExit(params) {
                 await autoCompactRefresh({
                     workDir: settings["workingDir"] || null, instructions: '', cli, model, scopeKey,
                     chatSessionId,
-                    ...(codexAppBucket === undefined ? {} : { sessionBucket: codexAppBucket }),
+                    sessionBucket: runBucket,
                 });
             }
         }
@@ -382,7 +444,7 @@ export async function handleAgentExit(params) {
             reason: 'kiro stale resume — fresh with history',
             ...empTag,
         }, isEmployee ? 'internal' : 'public');
-        finalizeTraceRun(ctx.traceRunId, 'error', 'kiro stale resume');
+        finalizeRun('error', 'kiro stale resume');
         const { promise: retryP } = _spawnAgent(prompt, {
             ...opts,
             _skipResume: true,
@@ -403,8 +465,69 @@ export async function handleAgentExit(params) {
         return;
     }
     // ─── Output handling ───
-    const outputText = resolveSpawnOutputText(ctx);
-    if (outputText || (code === 0 && ctx.toolLog.length > 0)) {
+    const outputText = nativeOutcome === undefined ? resolveSpawnOutputText(ctx) : '';
+    if (nativeOutcome !== undefined) {
+        let finalContent = nativeOutcome.finalText;
+        if (mainManaged && !opts.internal) {
+            const safeTools = sanitizeToolLogForDurableStorage(mergeLatestTools(ctx.toolLog, ownsLiveRun() ? getLiveRun(liveScope).toolLog : [], nativeTraceRunId || ''));
+            if (finalContent !== null) {
+                finalContent = applyOutputPolicy(finalContent, { scope: 'main' }).text;
+                evaluateRecordPending(ctx.toolLog, finalContent);
+                const structuredFence = scanStructuredFence(finalContent);
+                if (structuredFence.status === 'incomplete') {
+                    console.warn('[lifecycle] assistant output contains incomplete structured fence before durable insert', {
+                        cli, model, traceRunId: nativeTraceRunId || null, chars: finalContent.length,
+                        langs: structuredFence.langs, incompleteCount: structuredFence.incompleteCount,
+                    });
+                }
+                // trace_run_id is nullable TEXT, not a FK: missing journal rows
+                // cannot suppress final delivery or this history pointer.
+                const info = insertMessageWithTraceRun.run('assistant', finalContent, cli, model, ctx.traceLog.join('\n') || null, serializeSanitizedToolLog(safeTools), settings['workingDir'] || null, nativeTraceRunId || null, chatSessionId);
+                const messageId = Number(info.lastInsertRowid);
+                if (nativeTraceRunId && Number.isSafeInteger(messageId) && messageId > 0) {
+                    try {
+                        linkTraceRunToMessage(nativeTraceRunId, messageId);
+                    }
+                    catch {
+                        console.warn('[runtime] outcome trace link failed');
+                    }
+                }
+            }
+            const failed = nativeOutcome.status !== 'done';
+            const errorKind = failed ? classifyExitError(runtimeCli, code ?? 1, ctx.stderrBuf).errorKind : undefined;
+            // Even absent/empty finals must terminate existing UI/collectors.
+            // Only compatibility text collapses whitespace; never the outcome.
+            handoffRuntimeOutcome(ctx, { ...nativeOutcome, finalText: finalContent });
+            ctx.runtimeTerminalAttempted = true;
+            broadcast('agent_done', {
+                ...(nativeTraceRunId ? { traceRunId: nativeTraceRunId } : {}),
+                text: runtimeCompatibilityText(finalContent),
+                runtimeFinality: finalContent === null ? 'absent' : 'present',
+                runtimeStatus: nativeOutcome.status,
+                ...(nativeRequestId !== undefined ? { requestId: nativeRequestId } : {}),
+                sessionId: chatSessionId, scope: scopeKey, toolLog: safeTools, origin, ...empTag,
+                ...(wasSteer ? { steered: true } : {}),
+                ...(failed ? { error: true, errorKind, cli: runtimeCli } : {}),
+            });
+            if (finalContent !== null) {
+                if (opts._heartbeatAnchorId) {
+                    try {
+                        markAnchorConsumed.run(Date.now(), opts._heartbeatAnchorId);
+                    }
+                    catch {
+                        console.warn('[runtime] heartbeat anchor update failed');
+                    }
+                }
+                incrementMemoryFlush();
+                const threshold = settings['memory']?.flushEvery ?? 10;
+                if (settings['memory']?.enabled !== false && countTurnForFlush(threshold)) {
+                    void triggerMemoryFlush();
+                }
+            }
+        }
+        runtimeFinalText = finalContent;
+    }
+    else if (outputText || (code === 0 && ctx.toolLog.length > 0)) {
         const cleaned = (outputText || ctx.fullText.trim())
             .replace(/<\/?tool_call>/g, '')
             .replace(/<\/?tool_result>[\s\S]*?(?:<\/tool_result>|$)/g, '')
@@ -477,32 +600,18 @@ export async function handleAgentExit(params) {
                 });
             }
             const liveRun = getLiveRun(liveScope);
-            // Union, not pick-one: boss tools (ctx.toolLog) + worker mirrors (liveRun.toolLog,
-            // preserved across syncs by replaceLiveRunTools). Key on stepRef (durable, never
-            // stripped by the sanitizer); identity-less entries append (no false dedup). The
-            // old ternary kept only the longer array and discarded the other, dropping worker
-            // mirrors whenever the boss tool log was longer (claude). (devlog 260620 R1.)
-            const unionSeen = new Set();
-            const unionToolLog = [];
-            const pushUnionTool = (t) => {
-                const ref = typeof t.stepRef === 'string' && t.stepRef ? t.stepRef : null;
-                if (ref) {
-                    if (unionSeen.has(ref))
-                        return;
-                    unionSeen.add(ref);
-                }
-                unionToolLog.push(t);
-            };
-            for (const t of ctx.toolLog)
-                pushUnionTool(t);
-            for (const t of liveRun.toolLog)
-                pushUnionTool(t);
-            const sanitizedToolLog = sanitizeToolLogForDurableStorage(unionToolLog);
+            const sanitizedToolLog = sanitizeToolLogForDurableStorage(mergeLatestTools(ctx.toolLog, liveRun.toolLog, ctx.traceRunId || ''));
             const toolLogJson = serializeSanitizedToolLog(sanitizedToolLog);
             const info = insertMessageWithTraceRun.run('assistant', finalContent, cli, model, traceText || null, toolLogJson, settings["workingDir"] || null, ctx.traceRunId || null, chatSessionId);
             const messageId = Number(info.lastInsertRowid || 0);
-            if (ctx.traceRunId && Number.isInteger(messageId) && messageId > 0)
-                linkTraceRunToMessage(ctx.traceRunId, messageId);
+            if (ctx.traceRunId && Number.isInteger(messageId) && messageId > 0) {
+                try {
+                    linkTraceRunToMessage(ctx.traceRunId, messageId);
+                }
+                catch {
+                    console.warn('[trace] print link failed');
+                }
+            }
             broadcast('agent_done', { ...runTag(ctx), text: finalContent, toolLog: sanitizedToolLog, origin, ...empTag, ...(wasSteer ? { steered: true } : {}) });
             if (opts._heartbeatAnchorId) {
                 try {
@@ -524,6 +633,7 @@ export async function handleAgentExit(params) {
                 void triggerMemoryFlush();
             }
         }
+        runtimeFinalText = finalContent;
     }
     else if (code !== 0 && wasKilled && !wasSteer && ctx.stallReason) {
         // Watchdog kills carry a useful reason, but `wasKilled` intentionally
@@ -539,7 +649,7 @@ export async function handleAgentExit(params) {
         // the one failure the channel MUST show, and the forwarder gate
         // drops anything without errorKind (#519 round 2).
         { ...runTag(ctx), text: `❌ ${errMsg}`, error: true, errorKind, cli: runtimeCli, origin, ...empTag }, isEmployee ? 'internal' : 'public');
-        finalizeTraceRun(ctx.traceRunId, 'error', errMsg);
+        finalizeRun('error', errMsg);
         resolve({ text: '', code: code ?? 1, diagnostic: errMsg });
         if (mainManaged && !opts.internal)
             processQueue(scopeKey);
@@ -604,7 +714,7 @@ export async function handleAgentExit(params) {
                 reason: `${errMsg} (retry without stale resume)`,
                 ...empTag,
             }, isEmployee ? 'internal' : 'public');
-            finalizeTraceRun(ctx.traceRunId, 'error', errMsg);
+            finalizeRun('error', errMsg);
             const { promise: retryP } = _spawnAgent(prompt, {
                 ...opts,
                 _skipResume: true,
@@ -628,7 +738,7 @@ export async function handleAgentExit(params) {
                         await autoCompactRefresh({
                             workDir: settings["workingDir"] || null, instructions: '', cli, model, scopeKey,
                             chatSessionId,
-                            ...(codexAppBucket === undefined ? {} : { sessionBucket: codexAppBucket }),
+                            sessionBucket: runBucket,
                         });
                     }
                     catch { }
@@ -636,7 +746,7 @@ export async function handleAgentExit(params) {
                 insertMessage.run('assistant', `⏱️ ${errMsg}`, cli, model, settings["workingDir"] || null, chatSessionId);
             }
             broadcast('agent_done', { ...runTag(ctx), text: `❌ ${errMsg}`, error: true, errorKind, cli: runtimeCli, origin, ...empTag, ...(wasSteer ? { steered: true } : {}) }, isEmployee ? 'internal' : 'public');
-            finalizeTraceRun(ctx.traceRunId, 'error', errMsg);
+            finalizeRun('error', errMsg);
             resolve({ text: '', code: 1 });
             if (mainManaged && !opts.internal)
                 processQueue(scopeKey);
@@ -658,7 +768,7 @@ export async function handleAgentExit(params) {
             const delaySec = Math.round(delayMs / 1000);
             console.log(`[jaw:retry] ${cli} 429 detected — waiting ${delaySec}s before retry (attempt ${mainAttempt + 1}/${MAIN_MAX_RETRIES})`);
             broadcast('agent_retry', { cli, delay: delaySec, reason: errMsg, attempt: mainAttempt + 1, maxRetries: MAIN_MAX_RETRIES, ...empTag }, isEmployee ? 'internal' : 'public');
-            finalizeTraceRun(ctx.traceRunId, 'error', errMsg);
+            finalizeRun('error', errMsg);
             retryState.setIsEmployee(isEmployee);
             retryState.setResolve(resolve);
             retryState.setOrigin(origin);
@@ -711,7 +821,7 @@ export async function handleAgentExit(params) {
                     console.log(`[jaw:fallback] ${cli} → ${fallbackCli}, ${fallbackMaxRetries} retries queued`);
                 }
                 broadcast('agent_fallback', { from: cli, to: fallbackCli, reason: errMsg, ...empTag }, isEmployee ? 'internal' : 'public');
-                finalizeTraceRun(ctx.traceRunId, 'error', errMsg);
+                finalizeRun('error', errMsg);
                 try {
                     const { peekPendingBootstrapPrompt } = await import('../core/main-session.js');
                     if (!peekPendingBootstrapPrompt(scopeKey)) {
@@ -719,7 +829,7 @@ export async function handleAgentExit(params) {
                         await autoCompactRefresh({
                             workDir: settings["workingDir"] || null, instructions: '', cli, model, scopeKey,
                             chatSessionId,
-                            ...(codexAppBucket === undefined ? {} : { sessionBucket: codexAppBucket }),
+                            sessionBucket: runBucket,
                         });
                     }
                 }
@@ -778,7 +888,7 @@ export async function handleAgentExit(params) {
                 attempt: 1,
                 maxRetries: 1,
             }, 'internal');
-            finalizeTraceRun(ctx.traceRunId, 'error', cls.message);
+            finalizeRun('error', cls.message);
             const { promise: retryP } = _spawnAgent(prompt, {
                 ...opts,
                 _skipInsert: true,
@@ -803,7 +913,7 @@ export async function handleAgentExit(params) {
             const empDelaySec = Math.round(empDelayMs / 1000);
             console.log(`[jaw:retry] employee ${cli} transient exit — retry in ${empDelaySec}s (attempt ${empAttempt + 1}/${EMP_MAX_RETRIES}, ${cls.message})`);
             broadcast('agent_retry', { cli, delay: empDelaySec, reason: cls.message, isEmployee: true, attempt: empAttempt + 1 }, 'internal');
-            finalizeTraceRun(ctx.traceRunId, 'error', cls.message);
+            finalizeRun('error', cls.message);
             retryState.setIsEmployee(true);
             retryState.setResolve(resolve);
             retryState.setOrigin(origin);
@@ -824,8 +934,9 @@ export async function handleAgentExit(params) {
         // non-retryable employee error → fall through to Final resolve below
     }
     // ─── Kiro resume degraded (empty body) → fresh spawn with history fallback ───
-    const kiroOutputText = resolveSpawnOutputText(ctx);
-    if (isKiroPlainTextCli(cli, effectiveProvider)
+    const kiroOutputText = nativeOutcome === undefined ? resolveSpawnOutputText(ctx) : '';
+    if (nativeOutcome === undefined
+        && isKiroPlainTextCli(cli, effectiveProvider)
         && isResume
         && mainManaged
         && !opts.internal
@@ -849,7 +960,7 @@ export async function handleAgentExit(params) {
             reason: 'kiro resume empty — fresh with history',
             ...empTag,
         }, isEmployee ? 'internal' : 'public');
-        finalizeTraceRun(ctx.traceRunId, 'error', 'kiro resume empty');
+        finalizeRun('error', 'kiro resume empty');
         const { promise: retryP } = _spawnAgent(prompt, {
             ...opts,
             _skipResume: true,
@@ -872,10 +983,11 @@ export async function handleAgentExit(params) {
     }
     // ─── Final resolve ───
     const resolvedCode = code;
-    finalizeTraceRun(ctx.traceRunId, traceStatus, traceStatus === 'error' ? classifyExitError(runtimeCli, resolvedCode ?? 1, ctx.stderrBuf).message : null);
-    if (mainManaged && !wasSteer)
+    finalizeRun(traceStatus, traceStatus === 'error' ? classifyExitError(runtimeCli, resolvedCode ?? 1, ctx.stderrBuf).message : null);
+    const liveOwnedAtFinish = ownsLiveRun();
+    if (mainManaged && !wasSteer && liveOwnedAtFinish)
         clearLiveRun(liveScope);
-    if (!opts.internal && !wasSteer) {
+    if (!opts.internal && !wasSteer && liveOwnedAtFinish) {
         broadcast('agent_status', {
             status: (resolvedCode === 0 || resolvedCode === null) ? 'done' : 'error',
             agentId: agentLabel,
@@ -888,8 +1000,13 @@ export async function handleAgentExit(params) {
     const diagnostic = resolvedCode !== 0 && resolvedCode !== null
         ? classifyExitError(runtimeCli, resolvedCode, ctx.stderrBuf).message
         : ctx.stderrBuf.trim().slice(0, 500);
+    const resolvedOutcome = nativeOutcome === undefined
+        ? undefined : { ...nativeOutcome, finalText: runtimeFinalText };
+    const answerText = resolvedOutcome === undefined ? ctx.fullText : runtimeCompatibilityText(resolvedOutcome.finalText);
     resolve({
-        text: ctx.fullText, code: resolvedCode ?? 0,
+        text: answerText, code: resolvedCode ?? 0,
+        ...(resolvedOutcome === undefined ? {} : { runtimeOutcome: resolvedOutcome }),
+        ...(resolvedOutcome !== undefined && nativeTraceRunId ? { traceRunId: nativeTraceRunId } : {}),
         sessionId: ctx.sessionId, cost: ctx.cost,
         tools: ctx.toolLog, smoke: smokeResult,
         diagnostic,
@@ -902,17 +1019,21 @@ export async function handleAgentExit(params) {
     // ─── AI-initiated /goal done or /goal cancel ───
     // The AI can't execute slash commands directly. Detect the pattern in output
     // and execute it so the continuation loop stops.
+    const controlText = resolvedOutcome === undefined ? ctx.fullText
+        : resolvedOutcome.status === 'done' ? resolvedOutcome.finalText ?? '' : '';
+    const allowNativeContinuation = resolvedOutcome === undefined
+        || (resolvedOutcome.status === 'done' && resolvedOutcome.finalText !== null);
     let goalDoneRejected = false;
-    if (mainManaged && !opts.internal && ctx.fullText) {
+    if (mainManaged && !opts.internal && controlText) {
         const activeGoal = getActiveGoal();
         if (activeGoal && activeGoal.status === 'active') {
             // A truncated capture means a trailing marker may have been dropped,
             // so the ABSENCE of one is no longer authoritative. Say so rather
             // than silently treating the clipped text as complete.
-            if (ctx.fullTextTruncated && !GOAL_DONE_RE.test(ctx.fullText)) {
+            if (resolvedOutcome === undefined && ctx.fullTextTruncated && !GOAL_DONE_RE.test(controlText)) {
                 console.warn('[jaw:goal] assistant text was truncated at the safety bound — a trailing /goal marker may have been lost');
             }
-            if (GOAL_DONE_RE.test(ctx.fullText)) {
+            if (GOAL_DONE_RE.test(controlText)) {
                 if (goalHasCompletionEvidence(activeGoal)) {
                     completeGoal();
                     clearGoalTimers();
@@ -925,7 +1046,7 @@ export async function handleAgentExit(params) {
                     broadcast('goal_done_rejected', { goalId: activeGoal.id, reason: 'no_evidence' });
                 }
             }
-            else if (GOAL_CANCEL_RE.test(ctx.fullText)) {
+            else if (GOAL_CANCEL_RE.test(controlText)) {
                 // Cancelling used to happen here on sight of the marker, with no
                 // gate at all — which made ABANDONING a goal strictly easier than
                 // completing one, since /goal done next door demands verification
@@ -939,7 +1060,7 @@ export async function handleAgentExit(params) {
                 console.warn('[jaw:goal] AI output contained /goal cancel — timers cleared, goal left active for a human decision');
                 broadcast('goal_cancel_requested', { goalId: activeGoal.id, source: 'ai_output' });
             }
-            else if (GOAL_PAUSE_RE.test(ctx.fullText)) {
+            else if (GOAL_PAUSE_RE.test(controlText)) {
                 clearGoalTimers();
                 console.log('[jaw:goal] AI output contained /goal pause — timers cleared');
                 broadcast('goal_pause_detected', { goalId: activeGoal.id, source: 'ai_output' });
@@ -949,7 +1070,8 @@ export async function handleAgentExit(params) {
     // ─── ScheduleWakeup server intercept ───
     // When the AI called ScheduleWakeup, the CLI ignores it (only works in /loop).
     // cli-jaw intercepts the params and schedules a delayed --resume of the same session.
-    if (ctx.scheduleWakeup
+    if (allowNativeContinuation
+        && ctx.scheduleWakeup
         && ctx.scheduleWakeup.prompt.trim()
         && mainManaged
         && !opts.internal
@@ -1000,7 +1122,8 @@ export async function handleAgentExit(params) {
     }
     else if (
     // ─── Goal auto-continuation (max 20 consecutive attempts) ───
-    mainManaged
+    allowNativeContinuation
+        && mainManaged
         && !opts.internal
         && !wasKilled
         && !wasSteer