@maudecode/talaria-web 1.11.0 → 1.13.0

package/dist/sessions/turn.js

@@ -12,18 +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 { hydrateAnchorActivityScenes, withTurnIds } from './anchor.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 { agentSteerText, 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;
@@ -35,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.' };
     }
@@ -61,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)
@@ -139,8 +139,6 @@ export function explicitTextSignal(cfg) {
     return !['', 'auto'].includes(provider) || Boolean(str(vision.model).trim()) || Boolean(str(vision.base_url).trim());
 }
 export const GATEWAY_APPROVAL_RELAY_UNAVAILABLE = 'Gateway approval could not be relayed because the active run is unavailable. Reopen the session or retry after it reconnects.';
-/** Error classifications that are turn outcomes in their own right (not a generic failure). */
-const CLASSIFIED_OUTCOMES = new Set(['no_response', 'compression_exhausted', 'interrupted', 'cancelled']);
 export class TurnRunner {
     deps;
     writers = new Map();
@@ -153,6 +151,13 @@ export class TurnRunner {
     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;
     }
@@ -225,17 +230,7 @@ export class TurnRunner {
         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, _turn_id: turnId };
-        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) {
@@ -248,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))
@@ -264,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 */ }
             }
@@ -285,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;
         }
@@ -298,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 };
@@ -330,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);
@@ -379,25 +391,32 @@ export class TurnRunner {
                                 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 });
                             }
-                            if (str(data.tid))
-                                this.lastCompletedTool.set(streamId, str(data.tid));
-                            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 });
@@ -429,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;
             }
@@ -444,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 });
                 }
@@ -532,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 = [];
@@ -540,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;
                     }
                 }
@@ -624,11 +645,10 @@ 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 steerEvents)
                 put(event, payload);
@@ -660,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;
             }
@@ -777,8 +797,8 @@ 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 scened = hydrateAnchorActivityScenes(withTurnIds(s.messages), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true });
+        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;
@@ -804,9 +824,8 @@ export class TurnRunner {
         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 classified outcome the live frame reported stays on the row, so the settled scene says the same.
-        if (CLASSIFIED_OUTCOMES.has(str(payload.type)))
-            errorMessage._terminal_state = str(payload.type);
+        // 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));
@@ -873,22 +892,27 @@ export class TurnRunner {
             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;
@@ -908,18 +932,43 @@ 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;
+        }
         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()), _turn_id: streamId });
+        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);
@@ -946,6 +995,8 @@ 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);
@@ -1111,16 +1162,17 @@ 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) {
@@ -1132,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
@@ -1153,7 +1205,7 @@ export class TurnRunner {
             };
             for (const [event, data] of steerEvents)
                 emit(event, data);
-            emit('cancel', sessionId ? this.cancelFrame(sessionId) : this.cancelPayload());
+            emit('cancel', this.cancelFrame(sessionId));
             this.registry.streams.delete(streamId);
             this.registry.liveIds.delete(streamId);
         }
@@ -1411,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.' };
@@ -1431,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;