@maudecode/talaria-web 0.0.0 → 1.12.1

package/dist/sessions/turn.js

@@ -12,17 +12,19 @@ import { isWithin, resolvePathLikePython } from '../workspace/paths.js';
 import { SidecarError } from '../sidecar/client.js';
 import { HttpFailure, markSessionTitleGenerated } from './service.js';
 import { StreamRegistry, SessionChannels } from './streams.js';
-import { PendingPrompts } from './pending.js';
+import { PendingPrompts, clarifyReply } from './pending.js';
 import { RunJournal } from './journal.js';
 import { Session, titleFrom } from './session.js';
-import { buildActiveTurnToken, redactSessionData, redactString } from '../redact.js';
+import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactSessionData, redactString, withToolId } from '../redact.js';
 import { dict } from '../config/agent-config.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
 import { messageWindowForDisplay, messagesForLimitedPayload, toolCallsForMessageWindow } from './window.js';
 import { attachTodoState } from './todo.js';
+import { withSessionWireFlags } from './list.js';
+import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { assistantReplyAddedAfterCurrentTurn, buildPartialMessage, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stripXmlToolCalls, workspaceContextPrefix } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
 import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
 import { str } from '../util.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
@@ -34,7 +36,7 @@ export function classifyProviderError(errStr, opts = {}) {
         return { label: 'Authentication failed', type: 'auth_mismatch', hint: 'The selected model may not be supported by your configured provider or your API key is invalid. Run `hermes model` in your terminal to update credentials, then restart the WebUI.' };
     const cancelled = ['cancelled by user', 'canceled by user', 'user cancelled', 'user canceled', 'task cancelled', 'task canceled', 'cancellederror'].some((k) => lower.includes(k));
     if (cancelled)
-        return { label: 'Task cancelled', type: 'cancelled', hint: cancelledTurnHint() };
+        return { label: 'Task cancelled', type: 'cancelled', hint: '' };
     if (['interrupted by user', 'response interrupted', 'operation interrupted', 'operation was interrupted', 'operation aborted', 'request was aborted', 'aborterror'].some((k) => lower.includes(k))) {
         return { label: 'Response interrupted', type: 'interrupted', hint: 'The run stopped before a provider response completed. If you did not cancel it, try again.' };
     }
@@ -60,12 +62,11 @@ export function classifyProviderError(errStr, opts = {}) {
         return { label: 'No response from provider', type: 'no_response', hint: 'The provider returned no content and no error. This often means a usage/rate limit was hit silently. Check provider status, switch providers via `hermes model`, or try again in a moment.' };
     return { label: 'Error', type: 'error', hint: '' };
 }
-export function cancelledTurnHint(agentName = 'Hermes') {
-    return `${agentName} stopped this turn at your request. Send a new message to continue.`;
-}
+/** Error classifications that are turn outcomes in their own right; every other one ends the turn as `error`. */
+const CLASSIFIED_OUTCOMES = new Set(['no_response', 'compression_exhausted', 'interrupted', 'cancelled']);
 export function providerErrorPayload(message, errType, hint = '', redact = true) {
     const safe = redact ? redactString(message).trim() : message;
-    const payload = { message: safe || message, type: errType };
+    const payload = { message: safe || message, type: errType, terminal_state: CLASSIFIED_OUTCOMES.has(errType) ? errType : 'error' };
     if (hint)
         payload.hint = hint;
     if (safe)
@@ -146,8 +147,17 @@ export class TurnRunner {
     yoloChains = new Map();
     abortControllers = new Map();
     steers = new Map();
+    consumedSteers = new Map();
+    lastCompletedTool = new Map();
     /** Streams whose run completed (`done` emitted) and only await title work; a late cancel is a no-op for these. */
     settledStreams = new Set();
+    /**
+     * TAL-364: what a Stop needs to write the turn's model context: its starting context, the prompt the Agent got, and
+     * whether a settlement already used a canonical checkpoint (which marks the stop boundary; later work never replaces it).
+     */
+    /** TAL-364: a Stop's in-flight `chat.interrupt` reply (null when it failed), so a worker that settles first can use its checkpoint. */
+    interrupts = new Map();
+    stopContexts = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -156,6 +166,8 @@ export class TurnRunner {
     /** Python `_start_chat_stream_for_session`: persist pending state, register the channel, launch the worker. */
     start(session, opts) {
         const s = session;
+        if (this.deps.updateInProgress?.())
+            return { error: 'Web is updating. Retry after it restarts.', _status: 503 };
         if (this.deps.profileDeleting?.(s.profile ?? null))
             return { error: `Profile '${str(s.profile)}' is being deleted.`, _status: 409 };
         const locked = s.active_stream_id;
@@ -190,7 +202,7 @@ export class TurnRunner {
                 s.title = provisional;
         }
         if (this.deps.saveMode() === 'eager')
-            this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source);
+            this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source, streamId);
         this.deps.store.save(s);
         this.registry.writebackOwners.set(s.session_id, streamId);
         if (wasHiddenEmpty)
@@ -206,7 +218,7 @@ export class TurnRunner {
         void this.run(s.session_id, streamId, channel, opts).catch((error) => {
             this.deps.log(`[webui] ERROR turn ${streamId} crashed\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
         });
-        const response = { stream_id: streamId, session_id: s.session_id, pending_started_at: s.pending_started_at, turn_id: null, title: s.title };
+        const response = { stream_id: streamId, session_id: s.session_id, pending_started_at: s.pending_started_at, turn_id: streamId, title: s.title };
         if (opts.normalizedModel && opts.model)
             response.effective_model = opts.model;
         if (opts.modelProvider)
@@ -214,21 +226,11 @@ export class TurnRunner {
         return response;
     }
     /** Python `_checkpoint_user_message_for_eager_session_save`. */
-    checkpointUserMessage(s, msg, attachments, startedAt, source) {
+    checkpointUserMessage(s, msg, attachments, startedAt, source, turnId) {
         const latest = s.messages[s.messages.length - 1];
         if (latest?.role === 'user' && messageText(latest.content).split(/\s+/).join(' ') === msg.split(/\s+/).join(' '))
             return;
-        const user = { role: 'user', content: msg };
-        const token = buildActiveTurnToken(s.active_stream_id, startedAt);
-        if (token)
-            user._active_turn_token = token;
-        if (source !== 'webui')
-            user._source = source;
-        if (typeof startedAt === 'number' && startedAt > 0)
-            user.timestamp = startedAt;
-        if (attachments.length)
-            user.attachments = [...attachments];
-        s.messages.push(user);
+        s.messages.push(pendingUserRow(msg, attachments, startedAt, source, turnId));
     }
     // ── worker ───────────────────────────────────────────────────────────────
     async run(sessionId, streamId, channel, opts) {
@@ -241,7 +243,7 @@ export class TurnRunner {
         catch (error) {
             deps.log(`[webui] WARNING: run journal degraded for stream ${streamId}: ${error.message}`);
         }
-        const put = (event, data) => {
+        const put = (event, data, meta = {}) => {
             for (const steerEvent of this.takeSteerEventsBefore(streamId, event))
                 put(steerEvent[0], steerEvent[1]);
             if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'pending_steer_leftover'].includes(event))
@@ -257,16 +259,20 @@ export class TurnRunner {
             let eventId = null;
             if (writer) {
                 try {
-                    eventId = writer.appendSseEvent(event, data).event_id;
+                    eventId = writer.appendSseEvent(event, data, meta).event_id;
                 }
                 catch (error) {
+                    this.registry.degradedJournals.add(streamId);
                     deps.log(`[webui] WARNING: run journal append failed for ${streamId}/${event}: ${error.message}`);
                 }
             }
-            channel.put([event, data, eventId]);
+            channel.put([event, data, eventId, meta.redacted]);
             if (event === 'done' || event === 'cancel' || event === 'apperror' || event === 'error') {
+                // Relay's phase follows the turn outcome, so a background Live Activity ends as the app would end it.
+                const state = str(data.terminal_state);
+                const phase = state === 'completed' || state === 'tool_limit_reached' ? 'completed' : event === 'cancel' || state === 'cancelled' ? 'cancelled' : 'failed';
                 try {
-                    deps.onTerminal?.(streamId, event === 'done' ? 'completed' : event === 'cancel' ? 'cancelled' : 'failed');
+                    deps.onTerminal?.(streamId, phase);
                 }
                 catch { /* best effort */ }
             }
@@ -278,7 +284,7 @@ export class TurnRunner {
             s = deps.store.get(sessionId);
         }
         catch {
-            put('apperror', { type: 'error', message: 'Session not found', session_id: sessionId });
+            put('apperror', { type: 'error', terminal_state: 'error', message: 'Session not found', session_id: sessionId });
             this.teardown(sessionId, streamId);
             return;
         }
@@ -291,19 +297,32 @@ export class TurnRunner {
         const previousContext = structuredClone(localContext.some((m) => isContextCompressionMarker(m)) ? localContext : deps.service().mergedTranscript(s, localContext));
         // Python `_sanitize_messages_for_api`: the model never sees display-only rows or a replayed cancelled prompt.
         const apiHistory = sanitizeMessagesForApi(previousContext);
+        const workspaceCtx = workspaceContextPrefix(opts.workspace);
+        // Before the first await: a Stop can land at any point after admission.
+        // An eager save already put this turn's prompt in the transcript; the Stop fallback appends it once itself.
+        this.stopContexts.set(streamId, { previousContext: previousContext.filter((m) => m._turn_id !== streamId), historyLength: apiHistory.length, prompt: workspaceCtx + msgText, msgText, checkpointed: false });
         const activeTurnToken = buildActiveTurnToken(streamId, s.pending_started_at);
         const sidecar = deps.sidecar();
         const partialText = this.registry.partialText.get(streamId) ?? [];
         const reasoningText = this.registry.reasoningText.get(streamId) ?? [];
         const liveToolCalls = this.registry.liveToolCalls.get(streamId) ?? [];
+        // Each call's public `id`: the Agent's call id, else one minted here that its completion inherits through the pairing.
+        const toolIds = new WeakMap();
+        let mintedToolIds = 0;
+        const mintToolId = () => `tool-${streamId}-${String(++mintedToolIds)}`;
+        // When the server received each call's start frame: its completion's `duration` is measured from it.
+        const toolStartedAt = new WeakMap();
         let tokenSent = false;
         let firstTokenAt = null;
         const titles = new ReasoningTitleTracker();
         let capturedTerminalError = null;
         const controller = new AbortController();
         this.abortControllers.set(streamId, controller);
-        const workspaceCtx = workspaceContextPrefix(opts.workspace);
         const userMessage = await this.buildUserMessage(workspaceCtx, msgText, opts.attachments ?? [], opts.workspace, sessionId, s, opts, controller.signal);
+        // The prompt the Agent actually gets, native image parts included.
+        const stop = this.stopContexts.get(streamId);
+        if (stop)
+            stop.prompt = userMessage;
         if (activeRun)
             activeRun.phase = 'running';
         const settledAt = { value: false };
@@ -323,8 +342,8 @@ export class TurnRunner {
             // Last yield before `chat.start`: a cancel that landed during the attachment, config or YOLO awaits must not
             // start an Agent turn (the client also refuses an already-aborted signal outright).
             if (this.registry.cancelled.has(streamId)) {
-                this.finalizeCancelled(s, streamId, 'Task cancelled before start.', opts.ephemeral);
-                put('cancel', this.cancelPayload('Cancelled before start'));
+                this.finalizeCancelled(s, streamId, opts.ephemeral);
+                put('cancel', this.cancelFrame(sessionId));
                 return;
             }
             const frozenWorkspace = str(s.created_workspace) || str(s.workspace);
@@ -370,24 +389,34 @@ export class TurnRunner {
                         case 'steer_pending':
                             for (const record of this.takeConsumedSteers(streamId, str(data.text), { keepLeftovers: true }))
                                 put('steer_consumed', record);
+                            this.saveConsumedSteers(sessionId, streamId);
                             return;
-                        case 'tool':
-                            liveToolCalls.push({ name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false });
-                            put('tool', data);
+                        case 'tool': {
+                            const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
+                            liveToolCalls.push(call);
+                            toolIds.set(call, call.tid || mintToolId());
+                            toolStartedAt.set(call, deps.now());
+                            const redacted = deps.redactEnabled();
+                            put('tool', publicToolFrame(withToolId(data, toolIds.get(call)), redacted), { redacted });
                             return;
-                        case 'tool_complete':
-                            for (let i = liveToolCalls.length - 1; i >= 0; i -= 1) {
-                                const tc = liveToolCalls[i];
-                                if (tc.done)
-                                    continue;
-                                if ((str(data.tid) && tc.tid === str(data.tid)) || (!tc.tid && tc.name === data.name)) {
-                                    tc.done = true;
-                                    tc.snippet = data.preview;
-                                    break;
-                                }
+                        }
+                        case 'tool_complete': {
+                            // TAL-313: the server decides failure from the sidecar's raw result, which never leaves the server.
+                            const { raw_result: rawResult, ...complete } = data;
+                            complete.is_error = toolOutcome(rawResult).is_error;
+                            const tc = liveToolCalls[completedToolIndex(liveToolCalls, str(data.tid), data.name)];
+                            if (tc) {
+                                const startedAt = toolStartedAt.get(tc);
+                                if (startedAt !== undefined)
+                                    complete.duration = Math.round(Math.max(0, deps.now() - startedAt) * 1000) / 1000;
+                                Object.assign(tc, { done: true, snippet: data.preview, is_error: complete.is_error, duration: complete.duration ?? null });
                             }
-                            put('tool_complete', data);
+                            const id = (tc && toolIds.get(tc)) || str(data.tid) || mintToolId();
+                            this.lastCompletedTool.set(streamId, id);
+                            const redacted = deps.redactEnabled();
+                            put('tool_complete', publicToolFrame(withToolId(complete, id), redacted), { redacted });
                             return;
+                        }
                         // Python: the live chat frame carries the queue head plus depth, not the entry that just arrived.
                         case 'approval': {
                             deps.pending.submitApproval(sessionId, { ...data, session_id: sessionId });
@@ -419,7 +448,10 @@ export class TurnRunner {
             });
             settledAt.value = true;
             if (this.registry.cancelled.has(streamId) || result.status === 'cancelled') {
-                this.finalizeCancelled(s, streamId, 'Task cancelled.', opts.ephemeral);
+                // The Stop's pre-interrupt snapshot is the boundary, even when its reply lands after this result (the sidecar
+                // answers each request on its own thread); without one, the Agent's interrupted result is its canonical transcript.
+                const interrupted = await this.interrupts.get(streamId);
+                this.finalizeCancelled(s, streamId, opts.ephemeral, interrupted?.checkpoint ?? result.messages);
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
@@ -434,7 +466,7 @@ export class TurnRunner {
                 }
                 opts.onDone?.(answer);
                 // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
-                put('done', { session: { session_id: sessionId, messages: (result.messages).map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer });
+                put('done', { session: { session_id: sessionId, messages: (result.messages).map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer, terminal_state: answer.trim() ? 'completed' : 'no_response' });
                 try {
                     rmSync(deps.store.pathFor(sessionId), { force: true });
                 }
@@ -462,7 +494,7 @@ export class TurnRunner {
             // sidecar reports `completed` whenever a failed run still carries messages).
             // Python's second chance: a turn that emitted no new row still counts when the merged transcript it produced
             // ends on a final answer (the current user row or trailing tool activity makes it "lacking").
-            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now() });
+            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
             const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
             const lastErr = result.error ?? capturedTerminalError ?? '';
             // Python `_turn_transcript_lacks_final_assistant_answer`: a partial result with no final answer is a silent failure even if tokens streamed.
@@ -471,16 +503,22 @@ export class TurnRunner {
                 const classification = classifyProviderError(lastErr, { silentFailure: !lastErr });
                 const errStr = lastErr || `${classification.label}.`;
                 const payload = providerErrorPayload(errStr, classification.type, classification.hint, deps.redactEnabled());
+                // Settle the steers first so the persisted turn carries every consumed one; the Agent's pending text stays a leftover.
+                const steerEvents = this.finalizeSteerEvents(streamId, str(result.pending_steer));
                 this.persistError(s, streamId, classification.label, payload, activeTurnToken);
                 payload.session = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
                 payload.session_id = s.session_id;
                 payload.old_session_id = sessionId;
+                for (const [event, data] of steerEvents)
+                    put(event, data);
                 put('apperror', payload);
                 failed = true;
                 return;
             }
             // ── settle the transcript ──
-            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now() });
+            // The Agent's last pending-steer text settles the remaining steers before the turn is written back.
+            const steerEvents = this.finalizeSteerEvents(streamId, result.pending_steer);
+            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
             s.context_messages = dedupeContext(resultMessages);
             for (const m of s.messages) {
                 if (m.role !== 'assistant')
@@ -516,7 +554,7 @@ export class TurnRunner {
                 s.threshold_tokens = result.context.threshold_tokens;
             if (typeof result.context.last_prompt_tokens === 'number')
                 s.last_prompt_tokens = result.context.last_prompt_tokens;
-            s.tool_calls = extractToolCallsFromMessages(s.messages, liveToolCalls);
+            s.tool_calls = extractToolCallsFromMessages(s.messages, liveToolCalls, s.tool_calls);
             s.active_stream_id = null;
             s.pending_user_message = null;
             s.pending_attachments = [];
@@ -524,14 +562,13 @@ export class TurnRunner {
             s.pending_user_source = null;
             const attachments = opts.attachments ?? [];
             if (attachments.length) {
-                const names = attachments.map((a) => str(a.name || a.filename)).filter(Boolean);
                 for (let i = s.messages.length - 1; i >= 0; i -= 1) {
                     const m = s.messages[i];
                     if (m.role === 'user') {
                         const content = messageText(m.content);
                         const base = msgText.includes('\n\n[Attached files:') ? (msgText.split('\n\n[Attached files:')[0] ?? '').trim() : msgText;
                         if (content.includes(base.slice(0, 60)) || msgText.includes(content.slice(0, 60)))
-                            m.attachments = names;
+                            m.attachments = [...attachments];
                         break;
                     }
                 }
@@ -565,9 +602,13 @@ export class TurnRunner {
                         m._turnTps = Math.round((usage.completion_tokens / duration) * 10) / 10;
                     if (result.model)
                         m._usedModel = result.model;
+                    // The live `done` frame says the tool budget ran out; the persisted row says so too, so a reload agrees.
+                    if (result.tool_limit_reached && m._turn_id === streamId)
+                        m._terminal_state = 'tool_limit_reached';
                     break;
                 }
             }
+            this.persistConsumedSteers(s, streamId, previousStartedAt(s, activeRun), now);
             deps.store.save(s);
             deps.pending.clearApprovals(sessionId);
             deps.pending.clearClarifies(sessionId);
@@ -604,13 +645,12 @@ export class TurnRunner {
             const donePayload = {
                 session: redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled()),
                 usage: doneUsage,
+                terminal_state: turnTerminalState(s.messages, streamId),
             };
-            if (result.tool_limit_reached) {
-                donePayload.terminal_state = 'tool_limit_reached';
+            if (result.tool_limit_reached)
                 donePayload.terminal_reason = 'max_iterations';
-            }
             put('done', donePayload);
-            for (const [event, payload] of this.finalizeSteerEvents(streamId, result.pending_steer))
+            for (const [event, payload] of steerEvents)
                 put(event, payload);
             // The turn is over: release admission before the title work so a follow-up message is accepted while the
             // (up to two) title prompts run; the channel and journal stay open for the `title` events (Python retired the
@@ -640,7 +680,7 @@ export class TurnRunner {
             }
             failed = true;
             if (this.registry.cancelled.has(streamId)) {
-                this.finalizeCancelled(s, streamId, 'Task cancelled.', opts.ephemeral);
+                this.finalizeCancelled(s, streamId, opts.ephemeral);
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
@@ -661,6 +701,8 @@ export class TurnRunner {
                     current = s;
                 }
                 if (current.active_stream_id === streamId) {
+                    for (const [event, data] of this.takeSteerEventsBefore(streamId, 'apperror'))
+                        put(event, data);
                     this.persistError(current, streamId, classification.label, payload, activeTurnToken);
                     payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
                 }
@@ -755,8 +797,9 @@ export class TurnRunner {
      * msg_limit=` (renderable rows, limited payload shape, windowed tool calls, todo state) with the full count.
      */
     terminalSessionPayload(s) {
-        const payload = s.compact({ includeRuntime: true, activeStreamIds: this.registry.liveIds });
-        const [window, offset] = messageWindowForDisplay(s.messages, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
+        const payload = withSessionWireFlags(s.compact(), this.registry.liveIds);
+        const scened = hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(s.messages), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true });
+        const [window, offset] = messageWindowForDisplay(scened, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
         const limited = messagesForLimitedPayload(window);
         payload.messages = limited;
         payload.message_count = s.messages.length;
@@ -769,7 +812,7 @@ export class TurnRunner {
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
     persistError(s, streamId, label, payload, activeTurnToken) {
         const startedAt = s.pending_started_at;
-        this.materializePendingUserTurn(s, activeTurnToken);
+        this.materializePendingUserTurn(s, activeTurnToken, streamId);
         const duration = typeof startedAt === 'number' && startedAt > 0 ? Math.max(0, this.deps.now() - startedAt) : null;
         s.active_stream_id = null;
         s.pending_user_message = null;
@@ -778,9 +821,11 @@ export class TurnRunner {
         s.pending_user_source = null;
         this.appendPartialSnapshot(s, streamId);
         const hint = str(payload.hint);
-        const errorMessage = { role: 'assistant', content: `**${label}:** ${str(payload.message) || label}${hint ? `\n\n*${hint}*` : ''}`, timestamp: Math.trunc(this.deps.now()), _error: true };
+        const errorMessage = { role: 'assistant', content: `**${label}:** ${str(payload.message) || label}${hint ? `\n\n*${hint}*` : ''}`, timestamp: Math.trunc(this.deps.now()), _error: true, _turn_id: streamId };
         if (duration !== null)
             errorMessage._turnDuration = Math.round(duration * 1000) / 1000;
+        // The outcome the live frame reported stays on the row, so the settled scene says the same.
+        errorMessage._terminal_state = str(payload.terminal_state) || 'error';
         if (payload.type === 'compression_exhausted') {
             // Python `stamp_compression_exhausted_recovery`: durable recovery metadata on the session, the marker, and the frame.
             const recovery = stampCompressionExhaustedRecovery(s, str(payload.message) || label, str(payload.details));
@@ -795,6 +840,7 @@ export class TurnRunner {
         else if (payload.type === 'interrupted')
             errorMessage.provider_details_label = 'Interruption details';
         s.messages.push(errorMessage);
+        this.persistConsumedSteers(s, streamId, startedAt, this.deps.now());
         try {
             this.deps.store.save(s);
         }
@@ -805,7 +851,7 @@ export class TurnRunner {
         this.deps.pending.clearClarifies(s.session_id);
         this.deps.events.publish('session_error', { profile: s.profile, sessionId: s.session_id });
     }
-    materializePendingUserTurn(s, activeTurnToken) {
+    materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
         if (!pendingText)
             return false;
@@ -816,7 +862,7 @@ export class TurnRunner {
             for (let i = s.messages.length - 1; i >= 0; i -= 1) {
                 const m = s.messages[i];
                 if (m.role === 'user' && m._active_turn_token === activeTurnToken) {
-                    if (!s.messages.slice(i + 1).some((later) => later.role === 'user'))
+                    if (!s.messages.slice(i + 1).some((later) => later.role === 'user' && !later._steer))
                         return false;
                     break;
                 }
@@ -826,7 +872,7 @@ export class TurnRunner {
         // Python `_synthesize_user_message_on_cancel`: a worker that already merged this prompt (same text, not older than the pending start) wins.
         if (last?.role === 'user' && messageText(last.content).trim() === pendingText.trim() && Math.trunc(Number(last.timestamp)) >= Math.trunc(recoveredTs))
             return false;
-        const recovered = { role: 'user', content: pendingText, timestamp: recoveredTs, _recovered: true };
+        const recovered = { role: 'user', content: pendingText, timestamp: recoveredTs, _recovered: true, _turn_id: turnId };
         if (source !== 'webui')
             recovered._source = source;
         if (attachments.length)
@@ -840,27 +886,33 @@ export class TurnRunner {
         const partial = buildPartialMessage((this.registry.partialText.get(streamId) ?? []).join(''), (this.registry.reasoningText.get(streamId) ?? []).join(''), this.registry.liveToolCalls.get(streamId) ?? [], this.deps.now());
         if (!partial)
             return;
+        partial._turn_id = streamId;
         const key = messageIdentity(partial);
         if (key !== null && s.messages.some((m) => m._partial && messageIdentity(m) === key))
             return;
         s.messages.push(partial);
     }
-    cancelPayload(message = 'Cancelled by user') {
-        return { type: 'cancelled', message, hint: cancelledTurnHint(this.deps.agentName()) };
-    }
-    /** Python `_emit_cancel_event`: the terminal frame carries the settled session so tabs can render the partial without a reload. */
+    /**
+     * Python `_emit_cancel_event`: the terminal frame carries the settled session so tabs can render the partial without a
+     * reload. TAL-364: no copy — clients show their one localized status for the `cancelled` outcome.
+     */
     cancelFrame(sessionId) {
         let snapshot = null;
-        try {
-            snapshot = redactSessionData(this.terminalSessionPayload(this.deps.store.get(sessionId)), this.deps.redactEnabled());
-        }
-        catch {
-            snapshot = null;
-        }
-        return { ...this.cancelPayload(), status: 'cancelled', session_id: sessionId, ...(snapshot ? { session: snapshot } : {}) };
+        if (sessionId)
+            try {
+                snapshot = redactSessionData(this.terminalSessionPayload(this.deps.store.get(sessionId)), this.deps.redactEnabled());
+            }
+            catch {
+                snapshot = null;
+            }
+        return { type: 'cancelled', status: 'cancelled', terminal_state: 'cancelled', ...(sessionId ? { session_id: sessionId } : {}), ...(snapshot ? { session: snapshot } : {}) };
     }
-    /** Python `_finalize_cancelled_turn`/`_persist_cancelled_turn`: only while this stream still owns writeback. */
-    finalizeCancelled(s, streamId, message, ephemeral) {
+    /**
+     * Python `_finalize_cancelled_turn`/`_persist_cancelled_turn`: only while this stream still owns writeback. TAL-364: the
+     * turn's model context keeps what the Agent had captured (`checkpoint`, its canonical transcript) and the prose that
+     * streamed, so the next request continues from it; the terminal row carries the outcome and no copy.
+     */
+    finalizeCancelled(s, streamId, ephemeral, checkpoint = null) {
         if (this.registry.writebackOwners.get(s.session_id) !== streamId)
             return false;
         let current = s;
@@ -880,17 +932,44 @@ export class TurnRunner {
             this.deps.store.sessions.delete(current.session_id);
             return true;
         }
-        if (current.messages.some((m) => m._error && str(m.content).startsWith('**Task cancelled:**')) && current.active_stream_id === null && !current.pending_user_message)
+        const stop = this.stopContexts.get(streamId);
+        const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
+        const settle = () => {
+            if (!stop)
+                return null;
+            if (canonical)
+                stop.checkpointed = true;
+            return stoppedTurnContext(stop.previousContext, checkpoint, stop.prompt, stop.msgText, (this.registry.partialText.get(streamId) ?? []).join(''), stop.historyLength);
+        };
+        if (current.messages.some((m) => isCancelMarker(m)) && current.active_stream_id === null && !current.pending_user_message) {
+            // The worker's canonical result can arrive after cancel() settled without a checkpoint (the interrupt reply failed
+            // or timed out): it replaces this stream's context and never adds a second Stop row. A settlement that already had
+            // one keeps it, so work the Agent finished after the Stop stays out.
+            const late = canonical && !stop.checkpointed && current.messages.some((m) => isCancelMarker(m) && m._turn_id === streamId) ? settle() : null;
+            if (late) {
+                current.context_messages = dedupeContext(late);
+                try {
+                    this.deps.store.save(current);
+                }
+                catch {
+                    return false;
+                }
+            }
             return true;
-        this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at));
+        }
+        const startedAt = current.pending_started_at;
+        this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at), streamId);
+        const context = settle();
+        if (context)
+            current.context_messages = dedupeContext(context);
         current.active_stream_id = null;
         current.pending_user_message = null;
         current.pending_attachments = [];
         current.pending_started_at = null;
         current.pending_user_source = null;
         this.appendPartialSnapshot(current, streamId);
-        const text = message.trim().endsWith('.') ? message.trim() : `${message.trim()}.`;
-        current.messages.push({ role: 'assistant', content: `**Task cancelled:** ${text}\n\n*${cancelledTurnHint(this.deps.agentName())}*`, _error: true, provider_details: text, provider_details_label: 'Cancellation details', timestamp: Math.trunc(this.deps.now()) });
+        current.messages.push({ role: 'assistant', content: '', _error: true, _terminal_state: 'cancelled', timestamp: Math.trunc(this.deps.now()), _turn_id: streamId });
+        this.persistConsumedSteers(current, streamId, startedAt, this.deps.now());
         try {
             this.deps.store.save(current);
         }
@@ -916,7 +995,11 @@ export class TurnRunner {
             this.writers.delete(streamId);
         }
         this.abortControllers.delete(streamId);
+        this.interrupts.delete(streamId);
+        this.stopContexts.delete(streamId);
         this.steers.delete(streamId);
+        this.consumedSteers.delete(streamId);
+        this.lastCompletedTool.delete(streamId);
         this.settledStreams.delete(streamId);
         this.registry.retire(streamId, this.deps.now());
         this.registry.forgetOwner(streamId);
@@ -1079,16 +1162,19 @@ export class TurnRunner {
         }
         // Python `_finalize_webui_steers` drained the Agent's pending steer text at cancel time: the interrupt reply
         // carries it so queued steers settle as consumed / leftover before the terminal row.
-        let leftover = '';
-        const sidecar = this.deps.sidecar();
-        if (sidecar) {
-            try {
-                leftover = str((await sidecar.call('chat.interrupt', { stream_id: streamId }, { timeoutMs: 5_000 })).pending_steer);
-            }
-            catch {
-                leftover = '';
-            }
+        // A duplicate Stop (another tab, a retried request) shares the first interrupt: its snapshot is the boundary, and a
+        // later interrupt finds the run already unwinding.
+        let interrupt = this.interrupts.get(streamId);
+        if (!interrupt) {
+            const sidecar = this.deps.sidecar();
+            interrupt = sidecar ? sidecar.call('chat.interrupt', { stream_id: streamId }, { timeoutMs: 5_000 }).catch(() => null) : Promise.resolve(null);
+            this.interrupts.set(streamId, interrupt);
         }
+        const reply = await interrupt;
+        const leftover = str(reply?.pending_steer);
+        const checkpoint = reply?.checkpoint ?? null;
+        // Settle the steers first so the persisted cancel carries every consumed one.
+        const steerEvents = (this.steers.get(streamId) ?? []).length ? this.finalizeSteerEvents(streamId, leftover) : [];
         if (sessionId) {
             let current = null;
             try {
@@ -1098,7 +1184,7 @@ export class TurnRunner {
                 current = null;
             }
             if (current?.active_stream_id === streamId) {
-                this.finalizeCancelled(current, streamId, 'Task cancelled.', run?.ephemeral);
+                this.finalizeCancelled(current, streamId, run?.ephemeral, checkpoint);
             }
         }
         // The worker may already have written its terminal row while the interrupt was in flight; the stream is then
@@ -1117,10 +1203,9 @@ export class TurnRunner {
                 }
                 channel.put([event, data, eventId]);
             };
-            if ((this.steers.get(streamId) ?? []).length)
-                for (const [event, data] of this.finalizeSteerEvents(streamId, leftover))
-                    emit(event, data);
-            emit('cancel', sessionId ? this.cancelFrame(sessionId) : this.cancelPayload());
+            for (const [event, data] of steerEvents)
+                emit(event, data);
+            emit('cancel', this.cancelFrame(sessionId));
             this.registry.streams.delete(streamId);
             this.registry.liveIds.delete(streamId);
         }
@@ -1196,7 +1281,70 @@ export class TurnRunner {
         return null;
     }
     consumedSteerPayload(record) {
-        return { ...record, agent_text: record.text, text: record.display_text || record.text, consumed_at: this.deps.now() };
+        const consumedAt = this.deps.now();
+        const afterToolCallId = this.lastCompletedTool.get(record.stream_id) ?? null;
+        const consumed = this.consumedSteers.get(record.stream_id) ?? [];
+        if (!consumed.some((c) => c.steer_id === record.steer_id)) {
+            consumed.push({ steer_id: record.steer_id, text: record.display_text || record.text, agent_text: record.text, submitted_at: record.created_at, consumed_at: consumedAt, after_tool_call_id: afterToolCallId });
+            this.consumedSteers.set(record.stream_id, consumed);
+        }
+        return { ...record, agent_text: record.text, text: record.display_text || record.text, consumed_at: consumedAt, after_tool_call_id: afterToolCallId };
+    }
+    /**
+     * Consumed steers become display-only `_steer` user rows at their causal place in the turn: after the tool results of
+     * the call that had completed when the Agent took them (else right after the turn's prompt), in consumption order,
+     * each with the phase it ended. Returns where the last phase starts. Replaces the turn's earlier placement, so the
+     * mid-turn save and the terminal one agree. Leftover steers are not persisted.
+     */
+    placeConsumedSteers(s, streamId, startedAt) {
+        const steers = this.consumedSteers.get(streamId) ?? [];
+        if (!steers.length)
+            return null;
+        s.messages = s.messages.filter((m) => !(m._steer && m._turn_id === streamId));
+        let boundary = typeof startedAt === 'number' && startedAt > 0 ? startedAt : steers[0].submitted_at;
+        for (const steer of steers) {
+            const row = {
+                role: 'user', content: steer.text, timestamp: steer.consumed_at, _turn_id: streamId,
+                _steer: { steer_id: steer.steer_id, submitted_at: steer.submitted_at, consumed_at: steer.consumed_at, phase_duration: roundDuration(steer.consumed_at - boundary) },
+            };
+            // An Agent that records the steer it delivered does so at its exact place: that row becomes the steer, not a copy.
+            const agentRows = s.messages.flatMap((m, i) => (m._turn_id === streamId && agentSteerText(m) !== null ? [i] : []));
+            const agentRow = agentRows.find((i) => agentSteerText(s.messages[i]) === steer.agent_text.trim()) ?? agentRows[0];
+            if (agentRow === undefined)
+                s.messages.splice(steerInsertIndex(s.messages, streamId, steer.after_tool_call_id), 0, row);
+            else
+                s.messages[agentRow] = row;
+            boundary = steer.consumed_at;
+        }
+        return boundary;
+    }
+    /** A steer is saved as it enters the stream, so a reload mid-turn already has it; the terminal save re-places it. */
+    saveConsumedSteers(sessionId, streamId) {
+        let s;
+        try {
+            s = this.deps.store.get(sessionId);
+        }
+        catch {
+            return;
+        }
+        if (s.active_stream_id !== streamId || this.placeConsumedSteers(s, streamId, s.pending_started_at) === null)
+            return;
+        try {
+            this.deps.store.save(s, { touchUpdatedAt: false });
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: failed to save consumed steer for ${sessionId}: ${error.message}`);
+        }
+    }
+    /** Terminal placement: the turn's rows are final now, and its last reply carries the final phase. */
+    persistConsumedSteers(s, streamId, startedAt, endedAt) {
+        const boundary = this.placeConsumedSteers(s, streamId, startedAt);
+        this.consumedSteers.delete(streamId);
+        if (boundary === null)
+            return;
+        const last = s.messages.findLast((m) => m.role === 'assistant' && m._turn_id === streamId);
+        if (last)
+            last._final_phase_duration = roundDuration(endedAt - boundary);
     }
     /**
      * Python `_take_consumed_webui_steers` (live, `keepLeftovers`) and `_finalize_webui_steers` (terminal): records the
@@ -1315,11 +1463,18 @@ export class TurnRunner {
             return this.deps.service().setYolo(sessionId, false);
         });
     }
-    /** `stale` when no such prompt is queued; `ok:false` without `stale` when the sidecar did not acknowledge (prompt retained). */
-    async respondClarify(sessionId, clarifyId, response) {
+    /**
+     * `reply` is the raw Agent reply or keyed step answers the server shapes for the prompt. `stale` when no such
+     * prompt is queued; `invalid` when the answers do not fit its steps; `ok:false` without either when the sidecar
+     * did not acknowledge (prompt retained).
+     */
+    async respondClarify(sessionId, clarifyId, reply) {
         const entry = this.deps.pending.peekClarify(sessionId, clarifyId);
         if (!entry)
             return { ok: false, stale: true };
+        const response = typeof reply === 'string' ? reply : clarifyReply(entry, reply);
+        if (response === null)
+            return { ok: false, invalid: true };
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return { ok: false, error: 'The Agent sidecar is not running; retry in a moment.' };
@@ -1335,12 +1490,16 @@ export class TurnRunner {
         const { head } = this.deps.pending.resolveClarify(sessionId, str(entry.clarify_id));
         if (head)
             this.emitToSession(sessionId, 'clarify', head);
-        return { ok: true };
+        return { ok: true, response };
     }
 }
 function previousStartedAt(s, run) {
     return typeof s.pending_started_at === 'number' && s.pending_started_at > 0 ? s.pending_started_at : (run?.started_at ?? Date.now() / 1000);
 }
+/** A persisted Stop row: TAL-364 marks its outcome; older rows carry only their English copy. */
+function isCancelMarker(m) {
+    return m._error === true && (m._terminal_state === 'cancelled' || str(m.content).startsWith('**Task cancelled:**'));
+}
 function dedupeContext(messages) {
     const out = [];
     let lastKey = null;
@@ -1354,4 +1513,35 @@ function dedupeContext(messages) {
     return out;
 }
 export { HttpFailure };
+/** Where a consumed steer goes: past the tool results of the call it followed, else past the turn's prompt. */
+function roundDuration(seconds) {
+    return Math.round(Math.max(0, seconds) * 1000) / 1000;
+}
+function steerInsertIndex(messages, turnId, afterToolCallId) {
+    // OpenAI-style `tool_calls` and Anthropic-style `tool_use` content blocks both name the call a steer followed.
+    const callIds = (m) => [
+        ...(Array.isArray(m.tool_calls) ? m.tool_calls : []).map((tc) => str(tc.id) || str(tc.call_id) || str(tc.tool_call_id)),
+        ...(Array.isArray(m.content) ? m.content : []).flatMap((part) => (isDict(part) && part.type === 'tool_use' ? [str(part.id)] : [])),
+    ];
+    // The steer followed that call's result: right after its row (a `tool` row, or a user row of `tool_result` blocks), even
+    // when the same assistant message made later calls; steers already placed there keep their consumption order.
+    const answers = (m) => (m.role === 'tool' && (str(m.tool_call_id) || str(m.tool_use_id)) === afterToolCallId)
+        || (m.role === 'user' && Array.isArray(m.content) && m.content.some((part) => isDict(part) && part.type === 'tool_result' && str(part.tool_use_id) === afterToolCallId));
+    const result = afterToolCallId ? messages.findIndex((m) => m._turn_id === turnId && answers(m)) : -1;
+    if (result !== -1) {
+        let i = result + 1;
+        while (i < messages.length && messages[i]._turn_id === turnId && messages[i]._steer)
+            i += 1;
+        return i;
+    }
+    let at = afterToolCallId ? messages.findIndex((m) => m._turn_id === turnId && m.role === 'assistant' && callIds(m).includes(afterToolCallId)) : -1;
+    if (at === -1)
+        at = messages.findIndex((m) => m._turn_id === turnId && m.role === 'user' && !m._steer);
+    if (at === -1)
+        return messages.length;
+    let i = at + 1;
+    while (i < messages.length && messages[i]._turn_id === turnId && (messages[i].role === 'tool' || messages[i]._steer))
+        i += 1;
+    return i;
+}
 //# sourceMappingURL=turn.js.map