cli-jaw 2.17.38 → 2.17.39

package/public/js/ws.ts

@@ -1,8 +1,9 @@
 // ── Server Event Connection (SSE via event-channel) ──
 import { state } from './state.js';
 import { API_BASE } from './api.js';
+import { requestBoundedJson } from './bounded-api.js';
 import { connectEventChannel, subscribe, onChannelOpen, onChannelDisconnect, onChannelUnavailable } from './event-channel.js';
-import { setStatus, updateQueueBadge, addSystemMsg, appendAgentText, finalizeAgent, addMessage, showProcessStep, cleanupToolActivity, applyQueuedOverlay, hydrateActiveRun, reconcileChatBottomAfterRestore, showChatRestoreIndicator, markSteered, clearSteer, isRecentSteer } from './ui.js';
+import { setStatus, updateQueueBadge, addSystemMsg, appendAgentText, finalizeAgent, replaceAgentAnswer, addMessage, showProcessStep, cleanupToolActivity, applyQueuedOverlay, hydrateActiveRun, reconcileChatBottomAfterRestore, showChatRestoreIndicator, markSteered, clearSteer, isRecentSteer } from './ui.js';
 import { renderPendingQueue } from './features/pending-queue.js';
 import { t, getLang } from './features/i18n.js';
 import { getVirtualScroll } from './virtual-scroll.js';
@@ -13,6 +14,48 @@ import { notifyUnreadResponse } from './features/attention-badge.js';
 import { shouldApplyOrcStateEvent } from './features/orchestrate-scope.js';
 import { providerLabel } from './provider-icons.js';
 import { handleSessionListBroadcast } from './features/session-hub.js';
+import { createNativeRequestBridge } from './features/native-request-bridge.js';
+import { parseRuntimeEvent } from '../../src/shared/runtime-event-parse.js';
+import type { RuntimeEvent } from '../../src/shared/runtime-contract.js';
+import { parseActivityIdentity, type ActivityIdentity } from '../../src/shared/presentation.js';
+import {
+    ActivityCapacityError, configureLiveActivityHost, clearLiveActivity, setLiveActivityIdentity,
+    findLiveActivity, ingestLiveActivity, settleLiveActivity, reconcileLiveActivityAnswer,
+    degradeLiveActivity, rebindLiveActivity,
+    setActivityTransportHealthy, settleModelFreeUnavailableAnswer, reconcileModelFreePublicAnswer, hasModelFreeAnswerReceipt,
+} from './features/activity-live.js';
+import { setActivityHistoryIdentity, setActivityHistoryReadReady, setActivityTranscript,
+    observeActivityHistory, hydrateActivityHost, discoverActivityHistory, disposeActivityHistory,
+    markActivityHistoryUnavailable, type RecoveredActivityTerminal } from './features/activity-history.js';
+
+configureLiveActivityHost({
+    currentMessage: () => state.currentAgentDiv,
+    useMessage: message => { state.currentAgentDiv = message; },
+    createMessage: createActivityMessage,
+    reconcileMessage: (id, update) => getVirtualScroll().reconcileMessage(id, update),
+    replaceAnswer: replaceAgentAnswer,
+    evicted: markActivityHistoryUnavailable,
+    closeTrace: () => {
+        void import('./features/trace-drawer.js').then(m => m.closeTraceDrawer())
+            .catch(error => console.warn('[activity] trace close unavailable', error));
+    },
+    inspectTrace: (runId, sessionId) => {
+        void import('./features/trace-drawer.js').then(m => m.openTraceDrawer(runId, undefined, sessionId))
+            .catch(error => console.warn('[activity] trace unavailable', error));
+    },
+});
+
+function createActivityMessage(): HTMLElement {
+    // A missed previous terminal must not carry its legacy stream/tool singleton
+    // into the new run's answer/cache. This is presentation cleanup, not Stop.
+    cleanupToolActivity();
+    return addMessage('agent', '');
+}
+
+const nativeRequests = createNativeRequestBridge({
+    host: () => document.querySelector<HTMLElement>('.chat-area'),
+    refreshSnapshot: () => syncOrchestrateSnapshot('native-request-retry', { hydrateRun: true }),
+});
 
 const ROADMAP_PHASES = ['I', 'P', 'A', 'B', 'C'] as const;
 
@@ -71,7 +114,10 @@ interface WsMessage {
     rawRetentionStatus?: string;
     /** Server run-start (ms) riding on agent_tool — authoritative elapsed origin. */
     startedAt?: number;
-    text?: string;
+    text?: string | null;
+    runtimeFinality?: 'present' | 'absent';
+    runtimeStatus?: 'done' | 'error' | 'stopped';
+    mode?: string;
     toolLog?: { icon: string; label: string; detail?: string; toolType?: string; stepRef?: string; isEmployee?: boolean; traceRunId?: string; traceSeq?: number; detailAvailable?: boolean; detailBytes?: number; rawRetentionStatus?: string }[];
     from?: string;
     to?: string;
@@ -108,7 +154,7 @@ interface WsMessage {
     code?: string;
     employeeName?: string;
     exitCode?: number;
-    error?: string;
+    error?: string | boolean;
     message?: string;
     steered?: boolean;
     steerWaitMs?: number;
@@ -140,7 +186,8 @@ const finalizedTraceRuns: string[] = [];
 const liveAppliedToolSeqByRun = new Map<string, number>();
 
 function isFinalizedRun(runId: string | null): boolean {
-    return runId !== null && finalizedTraceRuns.includes(runId);
+    return runId !== null && (finalizedTraceRuns.includes(runId) || hasModelFreeAnswerReceipt(runId)
+        || !!findLiveActivity(runId)?.answerSource);
 }
 
 function positiveSeq(value: unknown): number | null {
@@ -188,6 +235,7 @@ function shouldDropReplayedTool(runId: string | null, seq: number | null, replay
 /** Record the turn that just finalized and reset the live cursors. Pass the
  *  event's runId when present; falls back to the adopted live run id. */
 function markRunFinalized(runId: string | null): void {
+    ++liveRunRevision;
     const finalized = runId ?? liveTraceRunId;
     liveTraceRunId = null;
     liveAppliedTextLen = 0;
@@ -201,6 +249,7 @@ function markRunFinalized(runId: string | null): void {
  *  new turn started — the text cursor restarts from zero. */
 function adoptLiveRun(runId: string | null): void {
     if (!runId || runId === liveTraceRunId) return;
+    ++liveRunRevision;
     liveTraceRunId = runId;
     liveAppliedTextLen = 0;
 }
@@ -226,6 +275,183 @@ function syncLiveRunCursor(activeRun?: { running?: boolean; traceRunId?: string;
 }
 
 let currentOrcScope = '';
+let liveRunRevision = 0;
+let activityAdmissionReady = false;
+let activityStreamHealthy = false;
+let pendingRuntimeBytes = 0;
+type ActivityGap = ActivityIdentity & { runId: string };
+type PendingActivity = { event: RuntimeEvent; replay: boolean } | { gap: ActivityGap };
+let pendingRuntime: PendingActivity[] = [];
+let runtimeBufferLost = false;
+
+function suspendRuntimeAdmission(): void {
+    activityAdmissionReady = false;
+    setActivityTransportHealthy(false);
+    setActivityHistoryReadReady(false);
+    if (liveTraceRunId) degradeLiveActivity(liveTraceRunId);
+}
+
+function clearRuntimePresentation(): void {
+    clearLiveActivity();
+    pendingRuntime = []; pendingRuntimeBytes = 0; runtimeBufferLost = false;
+}
+
+function showActivityUnavailable(runId: string, detail = 'Activity preview is unavailable at its retention limit. The final answer will still appear here.'): void {
+    let message = state.currentAgentDiv;
+    if (!message || message.dataset['traceRunId'] !== runId) {
+        message = createActivityMessage();
+        state.currentAgentDiv = message;
+        message.dataset['traceRunId'] = runId;
+    }
+    if (!message.querySelector('.activity-unavailable')) {
+        const notice = message.ownerDocument.createElement('p');
+        notice.className = 'activity-unavailable'; notice.setAttribute('role', 'status');
+        notice.textContent = detail;
+        message.querySelector('.agent-body')?.prepend(notice);
+    }
+    adoptLiveRun(runId);
+}
+
+function bufferActivity(entry: PendingActivity): void {
+    const bytes = new TextEncoder().encode(JSON.stringify(entry)).length;
+    if (pendingRuntime.length >= 256 || pendingRuntimeBytes + bytes > 1024 * 1024) {
+        pendingRuntime = []; pendingRuntimeBytes = 0; runtimeBufferLost = true;
+        return;
+    }
+    pendingRuntime.push(entry); pendingRuntimeBytes += bytes;
+}
+
+function handleActivityGap(gap: ActivityGap): void {
+    const identity = state.activityIdentity;
+    if (!activityAdmissionReady || !identity) { bufferActivity({ gap }); return; }
+    if (gap.sessionId !== identity.sessionId || gap.scope !== identity.scope) return;
+    if (findLiveActivity(gap.runId)) degradeLiveActivity(gap.runId);
+    else if (liveTraceRunId === gap.runId && state.currentAgentDiv)
+        showActivityUnavailable(gap.runId, 'Activity is incomplete. Runtime updates were not recorded; the final answer remains available separately.');
+}
+
+function handleRuntimeEvent(event: RuntimeEvent, replay = false): void {
+    const identity = state.activityIdentity;
+    if (!activityAdmissionReady || !identity) {
+        bufferActivity({ event, replay });
+        return;
+    }
+    if (event.sessionId !== identity.sessionId || event.scope !== identity.scope) return;
+    const known = findLiveActivity(event.runId);
+    if (known && known.model.identity.turnId !== event.turnId) return;
+    const finalized = isFinalizedRun(event.runId);
+    if (finalized && !known) return;
+    if (!known && liveTraceRunId && liveTraceRunId !== event.runId && (event.kind !== 'turn-start' || replay)) return;
+    let turn;
+    try {
+        turn = ingestLiveActivity(event, !liveTraceRunId || liveTraceRunId === event.runId)
+            ?? (event.kind === 'turn-end' && known?.model.end?.seq === event.seq ? known : null);
+    } catch (error) {
+        if (!(error instanceof ActivityCapacityError)) throw error;
+        // Capacity cannot transfer an old run's host to a new answer. Keep a
+        // separate bounded-warning host and the compatibility final path alive.
+        if (!replay && (!liveTraceRunId || liveTraceRunId === event.runId || event.kind === 'turn-start'))
+            showActivityUnavailable(event.runId);
+        return;
+    }
+    if (!turn) return;
+    ++liveRunRevision;
+    if (runtimeBufferLost) degradeLiveActivity(event.runId);
+    if (event.kind !== 'turn-end') {
+        if (!finalized && !replay) adoptLiveRun(event.runId);
+        return;
+    }
+    if (finalized || (liveTraceRunId && liveTraceRunId !== event.runId)
+        || state.currentAgentDiv !== turn.message) return;
+    turn.answerSource = 'canonical';
+    markRunFinalized(event.runId);
+    // The journal is redacted and the reducer is bounded. Use the incoming
+    // terminal here; a later owned public answer may reconcile this same row.
+    finalizeAgent(event.finalText, undefined, event.finalText === null ? 'absent' : 'present', event.runId, turn.cacheScope, event.sessionId);
+    notifyUnreadResponse();
+}
+
+function settleCompatibilityMessage(msg: WsMessage): void {
+    if (msg.isEmployee === true) return;
+    const runId = typeof msg.traceRunId === 'string' && msg.traceRunId ? msg.traceRunId : null;
+    const finality = msg.runtimeFinality === 'present' || msg.runtimeFinality === 'absent' ? msg.runtimeFinality : undefined;
+    if (!runId && !finality && (msg.error === true || (liveTraceRunId && findLiveActivity(liveTraceRunId)))) {
+        if (typeof msg.text === 'string' && msg.text) addSystemMsg(escapeHtml(msg.text), 'tool-activity');
+        return;
+    }
+    const known = runId ? findLiveActivity(runId) : undefined;
+    const ownedText = !!known && finality !== 'absent' && typeof msg.text === 'string';
+    if (isFinalizedRun(runId)) {
+        if (ownedText && runId) reconcileLiveActivityAnswer(runId, msg.text!);
+        else if (!known && runId && finality !== 'absent' && typeof msg.text === 'string') {
+            // A model-free receipt is not authority to guess missing packet IDs.
+            const packetIdentity = parseActivityIdentity(msg);
+            if (packetIdentity && packetIdentity.sessionId === state.activityIdentity?.sessionId) {
+                reconcileModelFreePublicAnswer({ ...packetIdentity, runId, text: msg.text });
+            }
+        }
+        return;
+    }
+    if (runId && liveTraceRunId && runId !== liveTraceRunId) return;
+    settleLiveActivity(runId, msg.runtimeStatus ?? (msg.error === true ? 'error' : undefined));
+    if (known) known.answerSource = 'compatibility';
+    markRunFinalized(runId);
+    const tools = msg.type === 'agent_done' ? msg.toolLog : undefined;
+    if (known && runId) {
+        finalizeAgent(finality === 'absent' ? null : msg.text || '', tools,
+            finality ?? (ownedText ? 'present' : undefined), runId, known.cacheScope, known.model.identity.sessionId);
+        if (finality === 'absent' && typeof msg.text === 'string' && msg.text)
+            addSystemMsg(escapeHtml(msg.text.slice(0, 500)), 'activity-diagnostic');
+    } else finalizeAgent(msg.text || '', tools, finality);
+    notifyUnreadResponse();
+}
+
+/** A retained terminal is not a new SSE event or permission response. */
+function recoverActivityTerminal(value: RecoveredActivityTerminal): void {
+    const message = state.currentAgentDiv;
+    const turn = findLiveActivity(value.runId);
+    if (!message || liveTraceRunId !== value.runId || state.activityIdentity?.sessionId !== value.sessionId
+        || message !== value.message || message.dataset['traceRunId'] !== value.runId || isFinalizedRun(value.runId)) return;
+    if (turn && (turn.model.identity.sessionId !== value.sessionId || turn.model.identity.scope !== value.scope
+        || value.turnId !== undefined && turn.model.identity.turnId !== value.turnId)) return;
+    settleLiveActivity(value.runId, value.status);
+    markRunFinalized(value.runId);
+    if (message.dataset['activitySaved'] === 'true') {
+        if (turn) turn.answerSource = 'saved';
+        delete message.dataset['activityRecovering']; cleanupToolActivity(); setStatus('idle'); return;
+    }
+    if (turn) turn.answerSource = value.answer.kind === 'saved' ? 'saved' : 'unavailable';
+    else if (value.answer.kind !== 'saved' && state.activityIdentity) {
+        // History's execution scope may predate a routing change. A late public
+        // packet must match the delivery identity that owned this current host.
+        settleModelFreeUnavailableAnswer({ runId: value.runId, sessionId: value.sessionId,
+            scope: state.activityIdentity.scope, message, cacheScope: value.cacheScope });
+    }
+    // No verified answer remains blank, with the history control explaining
+    // absence versus a failed read. Never resurrect the provisional stream.
+    finalizeAgent(value.answer.kind === 'saved' ? value.answer.message.content : null, undefined,
+        value.answer.kind === 'saved' ? 'present' : 'absent', value.runId, value.cacheScope, value.sessionId);
+    notifyUnreadResponse();
+}
+
+function bindHistoryIdentity(): void {
+    setActivityHistoryIdentity(state.activityIdentity, { terminal: recoverActivityTerminal,
+        refreshIdentity: () => syncOrchestrateSnapshot('history-identity', { hydrateRun: true }) });
+    setActivityHistoryReadReady(activityAdmissionReady);
+}
+
+function drainRuntimeBuffer(): void {
+    const buffered = pendingRuntime;
+    pendingRuntime = []; pendingRuntimeBytes = 0;
+    for (const entry of buffered) {
+        if ('event' in entry) handleRuntimeEvent(entry.event, entry.replay);
+        else handleActivityGap(entry.gap);
+    }
+    if (runtimeBufferLost && liveTraceRunId && state.currentAgentDiv && !findLiveActivity(liveTraceRunId))
+        showActivityUnavailable(liveTraceRunId, 'Activity is incomplete. Updates were dropped while reconnecting; the final answer remains available separately.');
+    runtimeBufferLost = false;
+}
+
 let lastLoadTs = 0;
 let snapshotSyncInFlight: Promise<void> | null = null;
 let lastSnapshotSyncAt = 0;
@@ -234,9 +460,35 @@ let lastRestoreTriggerAt = 0;
 const SNAPSHOT_SYNC_THROTTLE_MS = 750;
 const RESTORE_TRIGGER_DEBOUNCE_MS = 750;
 
+type RuntimeSnapshot = {
+    activityIdentity?: unknown;
+    orc: { scope?: string; state: OrcStateName; ctx?: Parameters<typeof applyOrcContext>[0] };
+    heartbeat?: Parameters<typeof applyHeartbeatRuntime>[0];
+    workers: Parameters<typeof hydrateAgentPhases>[0];
+    runtime: { queuePending: number; busy: boolean };
+    queued?: Parameters<typeof applyQueuedOverlay>[0];
+    activeRun?: Parameters<typeof hydrateActiveRun>[0] & Parameters<typeof syncLiveRunCursor>[0];
+};
+
 async function refreshRuntimeSnapshot(options: { hydrateRun?: boolean } = {}): Promise<void> {
-    const response = await fetch(`${API_BASE}/api/orchestrate/snapshot`);
-    const snap = await response.json();
+    const capture = nativeRequests.beginSnapshot();
+    const readRevision = liveRunRevision;
+    let snap: RuntimeSnapshot;
+    try {
+        // Includes headers AND body: manual identity recovery must release its
+        // latch even if the peer never finishes responding. Preserve API auth.
+        snap = await requestBoundedJson(capture.path, { method: 'GET' },
+            new AbortController().signal, 16 * 1024 * 1024) as RuntimeSnapshot;
+    } catch (error) {
+        if (capture.isCurrent()) suspendRuntimeAdmission();
+        capture.fail(); throw error;
+    }
+    if (!capture.isCurrent()) return;
+    capture.accept(snap?.activityIdentity);
+    activityAdmissionReady = activityStreamHealthy && state.activityIdentity !== null;
+    setLiveActivityIdentity(state.activityIdentity);
+    setActivityTransportHealthy(activityAdmissionReady);
+    bindHistoryIdentity();
     currentOrcScope = String(snap.orc.scope || '');
     applyOrcState(snap.orc.state);
     applyOrcContext(snap.orc.ctx || null);
@@ -245,18 +497,32 @@ async function refreshRuntimeSnapshot(options: { hydrateRun?: boolean } = {}): P
     updateQueueBadge(snap.runtime.queuePending);
     applyQueuedOverlay(snap.queued || []);
     renderPendingQueue(snap.queued || []);
-    if (options.hydrateRun) {
+    const snapshotRunFinalized = isFinalizedRun(snap.activeRun?.traceRunId ?? null);
+    const currentRunSnapshot = readRevision === liveRunRevision;
+    if (options.hydrateRun && currentRunSnapshot && !snapshotRunFinalized) {
         hydrateActiveRun(snap.activeRun);
         // The hydrated block now renders the snapshot's cumulative state —
         // move the replay cursors there so replayed chunks older than the
         // snapshot are dropped instead of re-appended.
         syncLiveRunCursor(snap.activeRun);
+        if (snap.activeRun?.running && snap.activeRun.traceRunId && state.currentAgentDiv) {
+            state.currentAgentDiv.dataset['traceRunId'] = snap.activeRun.traceRunId;
+            if (state.activityIdentity) state.currentAgentDiv.dataset['messageSessionId'] = state.activityIdentity.sessionId;
+            rebindLiveActivity(snap.activeRun.traceRunId, state.currentAgentDiv);
+        }
     }
     hydrateGoalState();
-    if (snap.runtime.busy) {
-        setStatus('running');
-    } else if (!isRecentSteer()) {
-        setStatus('idle');
+    if (currentRunSnapshot) {
+        if (snap.runtime.busy && !snapshotRunFinalized) setStatus('running');
+        else if (!isRecentSteer()) setStatus('idle');
+    }
+    if (activityAdmissionReady) drainRuntimeBuffer();
+    const historyRoot = document.getElementById('chatMessages');
+    if (historyRoot) observeActivityHistory(historyRoot);
+    if (activityAdmissionReady && options.hydrateRun) {
+        if (state.currentAgentDiv && liveTraceRunId && (currentRunSnapshot || findLiveActivity(liveTraceRunId)?.degraded))
+            void hydrateActivityHost(state.currentAgentDiv, liveTraceRunId, true);
+        void discoverActivityHistory();
     }
     import('./features/employees.js').then(m => {
         if (typeof m.renderEmployees === 'function') m.renderEmployees();
@@ -333,6 +599,11 @@ function requestBrowserRestoreSync(reason: string): void {
 // same path for forward-compat and resolves to a signature-skip no-op today.
 function handleSettingsChange(msg: { cli?: string; projectDirs?: string[] | null; changedKeys?: string[] }): void {
     const changedKeys = Array.isArray(msg.changedKeys) ? msg.changedKeys : [];
+    if (changedKeys.includes('presentation')) {
+        void import('./features/presentation-preference.js')
+            .then(m => m.refreshPresentationSettings())
+            .catch(error => console.warn('[ws] presentation refresh failed', error));
+    }
     // Turning multi-session on or off changes what the SERVER puts on every event and
     // what this tab is subscribed to, and the two are decided at different times: the
     // session view is built once at boot and the channel carries the scope it produced.
@@ -763,6 +1034,8 @@ let snapshotReady: Promise<void> = Promise.resolve();
 let orcStateEpoch = 0;
 
 export function connect(): void {
+    activityStreamHealthy = false; suspendRuntimeAdmission();
+    nativeRequests.channelChanged();
     registerOrchestrateRestoreHooks();
     if (!channelWired) {
         channelWired = true;
@@ -779,6 +1052,8 @@ export function connect(): void {
 export const reopenChannel = connect;
 
 function handleChannelUp(transport: 'sse' | 'ws'): void {
+    activityStreamHealthy = transport === 'sse'; suspendRuntimeAdmission();
+    if (transport === 'sse') nativeRequests.sseOpened();
     console.log(`[${transport}] connected`);
     fallbackRetryDelayMs = 2000;
     clearChannelDownToastTimer(); // reconnected within grace — stay silent
@@ -813,6 +1088,7 @@ function handleChannelUp(transport: 'sse' | 'ws'): void {
 }
 
 function handleReplayGap(): void {
+    suspendRuntimeAdmission(); runtimeBufferLost = true;
     showChatRestoreIndicator('replay_gap');
     snapshotReady = import('./ui.js').then(async m => {
         try {
@@ -842,8 +1118,10 @@ function clearChannelDownToastTimer(): void {
 }
 
 function handleChannelDown(): void {
+    activityStreamHealthy = false; suspendRuntimeAdmission();
+    nativeRequests.unavailable();
     console.log('[channel] disconnected');
-    import('./ui.js').then(m => m.cleanupToolActivity());
+    cleanupToolActivity();
     if (channelDownToastTimer !== null) return; // earliest outage owns the deadline
     channelDownToastTimer = window.setTimeout(() => {
         channelDownToastTimer = null;
@@ -927,15 +1205,31 @@ function wireEventChannel(): void {
             .catch(err => console.warn('[widget] refresh failed:', (err as Error).message));
     });
     subscribe('*', null, (data) => {
+        nativeRequests.event(String(data['event']), data);
         const msg = { ...data, type: data['event'] } as unknown as WsMessage;
         handleServerEvent(msg);
     });
     onChannelOpen(() => handleChannelUp('sse'));
     onChannelDisconnect(() => handleChannelDown());
-    onChannelUnavailable(() => connectLegacyWebSocket());
+    onChannelUnavailable(() => {
+        activityStreamHealthy = false; suspendRuntimeAdmission();
+        nativeRequests.unavailable(); connectLegacyWebSocket();
+    });
 }
 
 function handleServerEvent(msg: WsMessage): void {
+    if (msg.type === 'agent_runtime') {
+        const event = parseRuntimeEvent(msg);
+        if (event) handleRuntimeEvent(event, msg.sseReplay === true);
+        return;
+    }
+    if (msg.type === 'agent_runtime_gap') {
+        const gap = msg as unknown as Record<string, unknown>;
+        const pair = parseActivityIdentity(gap);
+        if (pair && typeof gap['runId'] === 'string' && gap['runId'].length > 0 && gap['runId'].length <= 240)
+            handleActivityGap({ ...pair, runId: gap['runId'] });
+        return;
+    }
     // Hot-path first (devlog 260705_frontend_perf M5): agent_tool/agent_output
     // arrive many times per second during streaming — they head the chain so
     // each event pays 1-2 string compares instead of walking cold branches.
@@ -950,6 +1244,7 @@ function handleServerEvent(msg: WsMessage): void {
         // process block on the live placeholder.
         if (isFinalizedRun(toolRunId)) return;
         if (shouldDropReplayedTool(toolRunId, toolSeq, msg.sseReplay === true)) return;
+        ++liveRunRevision;
         // Employee mirror events carry the EMPLOYEE's run id — adopting it
         // would reset the boss text cursor and weaken replay protection
         // during interleave (260613 20 P2-i). Only boss tools adopt.
@@ -1004,10 +1299,11 @@ function handleServerEvent(msg: WsMessage): void {
             if (missing < outputText.length) outputText = outputText.slice(-missing);
             liveAppliedTextLen = msg.textLen;
         }
-        appendAgentText(outputText);
+        ++liveRunRevision; appendAgentText(outputText);
     } else if (msg.type === 'agent_status') {
         if (!msg.running && isRecentSteer()) return;
         if (msg.running && isRecentSteer()) clearSteer();
+        ++liveRunRevision;
         if (msg.running !== undefined) {
             setStatus(msg.running ? 'running' : 'idle');
         } else {
@@ -1055,27 +1351,19 @@ function handleServerEvent(msg: WsMessage): void {
             // Suppress agent_done from steered (killed) process.
             // Server sets steered:true; isRecentSteer is fallback for edge cases.
         } else {
-            const doneRunId = typeof msg.traceRunId === 'string' && msg.traceRunId ? msg.traceRunId : null;
-            // Replayed done of an already-finalized turn — drop, the history
-            // item exists. A done carrying a DIFFERENT run id than the live
-            // stream is a stale replay from a previous turn: finalizing here
-            // froze the in-flight block mid-turn (260612 duplicate-block RCA).
-            if (isFinalizedRun(doneRunId)) return;
-            if (doneRunId && liveTraceRunId && doneRunId !== liveTraceRunId) return;
-            markRunFinalized(doneRunId);
-            finalizeAgent(msg.text || '', msg.toolLog);
-            notifyUnreadResponse();
+            settleCompatibilityMessage(msg);
         }
     } else if (msg.type === 'orchestrate_done') {
-        markRunFinalized(null);
-        finalizeAgent(msg.text || '');
-        notifyUnreadResponse();
+        settleCompatibilityMessage(msg);
     } else if (msg.type === 'clear') {
+        ++liveRunRevision; disposeActivityHistory();
+        clearRuntimePresentation(); setLiveActivityIdentity(state.activityIdentity);
         cancelPostRender();
         cleanupToolActivity();
         getVirtualScroll().clear();
         const el = document.getElementById('chatMessages');
         if (el) el.innerHTML = '';
+        bindHistoryIdentity(); setActivityTranscript(state.activityIdentity?.sessionId ?? null, new Set());
         // Intentional clear — also wipe this tab's cached history. The cache is keyed by
         // location and working directory, NOT by execution scope, so it clears its own
         // current scope rather than the one the event carries: passing the server's scope
@@ -1102,6 +1390,10 @@ function handleServerEvent(msg: WsMessage): void {
     } else if (msg.type === 'memory_status') {
         import('./features/memory.js').then(m => m.refreshMemorySidebar());
     } else if (msg.type === 'steer_started') {
+        // Both modes continue one logical run. Metadata is not a final and a
+        // delayed receipt must not retire a newer turn in this conversation.
+        if (msg.mode === 'native-input' || msg.mode === 'cancel-reprompt'
+            || (liveTraceRunId && findLiveActivity(liveTraceRunId))) return;
         markSteered();
         markRunFinalized(null); // killed run — drop its replayed stream too
         finalizeAgent('');
@@ -1140,14 +1432,17 @@ function handleServerEvent(msg: WsMessage): void {
     } else if (msg.type === 'alert_escalation') {
         addSystemMsg(escapeHtml(msg.message || ''), 'tool-activity');
     } else if (msg.type === 'schedule_wakeup_failed') {
-        addSystemMsg(`⚠️ Wakeup failed — ${escapeHtml(String(msg.reason || ''))}: ${escapeHtml(msg.error || '')}`, 'tool-activity');
+        addSystemMsg(`⚠️ Wakeup failed — ${escapeHtml(String(msg.reason || ''))}: ${escapeHtml(String(msg.error || ''))}`, 'tool-activity');
     } else if (msg.type === 'goal_continuation_failed') {
-        addSystemMsg(`⚠️ Goal continuation failed: ${escapeHtml(msg.error || '')}`, 'tool-activity');
+        addSystemMsg(`⚠️ Goal continuation failed: ${escapeHtml(String(msg.error || ''))}`, 'tool-activity');
     } else if (msg.type === 'settings_change') {
         handleSettingsChange(msg as { cli?: string; projectDirs?: string[] | null; changedKeys?: string[] });
     } else if (msg.type === 'session_list') {
         handleSessionListBroadcast(msg);
     } else if (msg.type === 'session_switched' || msg.type === 'session_created') {
+        disposeActivityHistory();
+        suspendRuntimeAdmission(); clearRuntimePresentation();
+        nativeRequests.invalidateIdentity();
         // Reload messages for the new active session
         window.location.reload();
     }

package/public/manager/src/settings/fields/SelectField.tsx

@@ -94,14 +94,16 @@ export function SelectField({ id, label, value, options, onChange, disabled, err
             else setOpen(true);
             return;
         }
-        if (event.key === 'Escape') {
-            event.preventDefault();
-            setOpen(false);
-        }
     };
 
     return (
-        <div className="settings-field settings-field-select" ref={rootRef}>
+        <div className="settings-field settings-field-select" ref={rootRef} onKeyDown={(event) => {
+            if (event.key !== 'Escape' || !open) return;
+            event.preventDefault();
+            event.stopPropagation();
+            setOpen(false);
+            rootRef.current?.querySelector<HTMLButtonElement>('[role="combobox"]')?.focus();
+        }}>
             <span className="settings-field-label" id={labelId}>{label}</span>
             <button
                 id={id}

package/public/manager/src/settings/pages/Agent.tsx

@@ -453,13 +453,13 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                         });
                     }}
                 >
-                    <option value="steer">steer (기본) — 실행 중인 턴에 즉시 주입</option>
+                    <option value="steer">steer (기본) — 실행 중 지시 변경</option>
                     <option value="followup">followup — 끝나면 순서대로 실행</option>
                     <option value="collect">collect — 모아서 한 번에 실행</option>
                     <option value="interrupt">interrupt — 현재 실행을 중단하고 즉시 실행</option>
                 </select>
                 <span className="settings-field-hint">
-                    다중 세션이 켜져 있을 때 적용됩니다. steer는 jwc·codex-app 런타임에서 진행 중인 턴을 중단하지 않고 맥락을 유지한 채 주입하며, 그 외 런타임은 중단된 출력을 이어받아 즉시 리다이렉트(kill-steer)합니다. 대기열을 원하면 followup을 선택하세요.
+                    다중 세션이 켜져 있을 때 적용됩니다. jwc·codex-app은 같은 턴에 입력을 전달합니다. Cursor·Grok의 native 모드는 현재 요청의 취소와 정리가 끝난 뒤 같은 세션에 다시 요청합니다(cancel-reprompt). 그 외 런타임은 중단 후 새 실행으로 이어갑니다(kill-steer). 보존되는 맥락은 런타임에 따라 다릅니다. 끝난 뒤 실행하려면 followup을 선택하세요.
                 </span>
             </label>
             <CliProbeNotice status={cliStatus[draft.cli]} exhausted={cliStatusExhausted} />
@@ -556,6 +556,7 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
             />
             <PermissionQuickSection
                 value={draft.permissions}
+                configuredValue={settingsData.permissions}
                 onChange={(next) => {
                     setRuntimeDraft({ ...draft, permissions: next });
                     setEntry('permissions', {