@maudecode/talaria-web 1.14.0 → 1.16.1

package/dist/sessions/turn.js

@@ -14,7 +14,7 @@ import { HttpFailure, markSessionTitleGenerated } from './service.js';
 import { StreamRegistry, SessionChannels } from './streams.js';
 import { PendingPrompts, clarifyReply } from './pending.js';
 import { RunJournal } from './journal.js';
-import { Session, titleFrom } from './session.js';
+import { CONTEXT_USAGE_FIELDS, Session, titleFrom } from './session.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';
@@ -24,14 +24,22 @@ 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, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withAttachmentObjects, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
-import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, escapeWorkspacePrefixPath, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, joinReasoning, reasoningFieldsText, stoppedTurnContext, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
+import { mayBecomeSilentReply, turnOrigin, withBackgroundUpdates } from './background-updates.js';
+import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
+import { WORKSPACE_BUSY_MESSAGE } from '../workspace/git.js';
 import { str } from '../util.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
 const IMAGE_MODE_TIMEOUT_MS = 15_000;
 const TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT = 80;
+/** How long a user's message waits for a stopped background turn to unwind before its own turn is admitted. */
+const BACKGROUND_UNWIND_WAIT_MS = 30_000;
+const COMPRESSION_EXHAUSTED = { label: 'Context compression exhausted', type: 'compression_exhausted', hint: 'The conversation context is too large to compress safely. Start a new conversation or retry with a narrower task.' };
+/** `compressionExhausted`: the Agent flagged the turn itself, so its wording does not matter. */
 export function classifyProviderError(errStr, opts = {}) {
     const lower = errStr.toLowerCase();
+    if (opts.compressionExhausted)
+        return COMPRESSION_EXHAUSTED;
     if (opts.condition === 'credential_missing')
         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));
@@ -57,7 +65,7 @@ export function classifyProviderError(errStr, opts = {}) {
     if (notFound)
         return { label: 'Model not found', type: 'model_not_found', hint: 'The selected model was not found by the provider. Check the model ID in Settings or run `hermes model` to verify it exists for your provider.' };
     if (compressionExhausted)
-        return { label: 'Context compression exhausted', type: 'compression_exhausted', hint: 'The conversation context is too large to compress safely. Start a new conversation or retry with a narrower task.' };
+        return COMPRESSION_EXHAUSTED;
     if (opts.silentFailure)
         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: '' };
@@ -148,6 +156,11 @@ export class TurnRunner {
     abortControllers = new Map();
     steers = new Map();
     consumedSteers = new Map();
+    /** Per stream: steer, withdraw and Send now run one at a time, so each sees the queue the Agent holds. */
+    steerChains = new Map();
+    /** Streams whose Agent steer queue a withdraw or Send now is rewriting right now, and the pending text seen meanwhile. */
+    steerRewrites = new Map();
+    deferredPendingSteer = 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();
@@ -158,6 +171,8 @@ export class TurnRunner {
     /** 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();
+    /** Each turn's worker, so a stopped background turn can be awaited before the user's turn takes the session. */
+    workers = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -170,6 +185,8 @@ export class TurnRunner {
             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 };
+        if (this.deps.workspaceBusy?.(opts.workspace))
+            return { error: WORKSPACE_BUSY_MESSAGE, _status: 409 };
         const locked = s.active_stream_id;
         if (locked) {
             if (this.registry.liveIds.has(locked) || this.registry.activeRuns.has(locked))
@@ -184,9 +201,10 @@ export class TurnRunner {
                 return { error: 'session already has an active stream', active_stream_id: blocking, _status: 409 };
         }
         const streamId = randomUUID().replace(/-/g, '');
-        const wasHiddenEmpty = !s.messages.length && !s.context_messages.length && !s.pending_user_message;
+        const wasHiddenEmpty = !s.messages.length && !s.context_messages.length && !s.hasPendingPrompt;
         const attachments = opts.attachments ?? [];
-        const source = str(s.source_tag).toLowerCase() === 'fork' ? 'fork' : (opts.source ?? 'webui');
+        // A background wakeup stays one in a forked session too (TAL-460).
+        const source = opts.source !== 'process_wakeup' && str(s.source_tag).toLowerCase() === 'fork' ? 'fork' : (opts.source ?? 'webui');
         s.workspace = opts.workspace;
         s.model = opts.model;
         s.model_provider = opts.modelProvider;
@@ -214,10 +232,11 @@ export class TurnRunner {
         const channel = this.registry.create(streamId, s.session_id);
         if (opts.goalRelated)
             this.registry.goalRelated.add(streamId);
-        this.registry.registerActiveRun({ stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral) });
-        void this.run(s.session_id, streamId, channel, opts).catch((error) => {
+        this.registry.registerActiveRun({ stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral), origin: turnOrigin(source) });
+        const worker = 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)}`);
-        });
+        }).finally(() => { this.workers.delete(streamId); });
+        this.workers.set(streamId, worker);
         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;
@@ -246,7 +265,7 @@ export class TurnRunner {
         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))
+            if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn'].includes(event))
                 return;
             // `cancel()` already wrote the terminal row and closed the stream: the worker's unwind adds no second one.
             if (event === 'cancel' && !this.registry.streams.has(streamId)) {
@@ -290,11 +309,7 @@ export class TurnRunner {
         }
         const msgText = opts.msg;
         const previousMessages = structuredClone(s.messages);
-        // Python `reconciled_state_db_messages_for_session(prefer_context=True)`: the model history is the owner context
-        // extended append-only with the Agent's state.db rows (a CLI continuation of this session reaches the model), except
-        // for a compressed context whose anchor cannot be verified — that stays context-only.
-        const localContext = s.context_messages.length ? s.context_messages : s.messages.filter((m) => !m._error && !m._partial);
-        const previousContext = structuredClone(localContext.some((m) => isContextCompressionMarker(m)) ? localContext : deps.service().mergedTranscript(s, localContext));
+        const previousContext = structuredClone(deps.service().modelContext(s));
         // 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);
@@ -314,6 +329,11 @@ export class TurnRunner {
         const toolStartedAt = new WeakMap();
         let tokenSent = false;
         let firstTokenAt = null;
+        // TAL-460: a background turn's text is held back while it could still be a silence marker, so one never flashes by.
+        // ponytail: checks the turn's whole text, so a marker after earlier prose streams until the settled row hides it;
+        // check the last text segment instead if that shows up.
+        const holdSilence = turnOrigin(opts.source) === 'background';
+        let heldText = '';
         const titles = new ReasoningTitleTracker();
         let capturedTerminalError = null;
         const controller = new AbortController();
@@ -327,6 +347,8 @@ export class TurnRunner {
             activeRun.phase = 'running';
         const settledAt = { value: false };
         let failed = false;
+        // TAL-424: steers an errored turn ended without taking, sent as one follow-up turn once this one is torn down.
+        let followUp = [];
         try {
             if (!sidecar)
                 throw new SidecarError('The Agent sidecar is not running; chat is unavailable until it starts.', { condition: 'sidecar_unavailable' });
@@ -349,7 +371,7 @@ export class TurnRunner {
             const frozenWorkspace = str(s.created_workspace) || str(s.workspace);
             const turnContext = {
                 system_message: workspaceSystemMessage(frozenWorkspace),
-                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personality: str(s.personality) || null, sessionId, profile: s.profile ?? null, workspace: frozenWorkspace, hermesHome: deps.profileHome(s.profile), homeDisplay: deps.homeDisplay?.() ?? '~/.hermes' }),
+                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personality: str(s.personality) || null, sessionId, profile: s.profile ?? null, workspace: frozenWorkspace, hermesHome: deps.profileHome(s.profile), homeDisplay: deps.homeDisplay?.() ?? '~/.hermes', background: turnOrigin(opts.source) === 'background' }),
                 max_iterations: processWakeupMaxIterations(maxIterationsFromConfig(cfg), opts.source ?? 'webui', deps.env ?? {}),
                 max_tokens: maxTokensFromConfig(cfg),
                 reasoning_config: reasoningConfigFromConfig(cfg, opts.modelProvider ?? s.model_provider ?? null),
@@ -375,7 +397,12 @@ export class TurnRunner {
                             if (stable !== null)
                                 put('reasoning', { text: '', titles: stable });
                             partialText.push(str(data.text));
-                            put('token', { text: str(data.text) });
+                            if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
+                                heldText += str(data.text);
+                                return;
+                            }
+                            put('token', { text: heldText + str(data.text) });
+                            heldText = '';
                             return;
                         }
                         case 'reasoning': {
@@ -387,9 +414,12 @@ export class TurnRunner {
                             return;
                         }
                         case 'steer_pending':
-                            for (const record of this.takeConsumedSteers(streamId, str(data.text), { keepLeftovers: true }))
-                                put('steer_consumed', record);
-                            this.saveConsumedSteers(sessionId, streamId);
+                            // TAL-424: while a withdraw or Send now rewrites the Agent's queue its pending text is ambiguous; it settles after.
+                            if (this.steerRewrites.has(streamId)) {
+                                this.deferredPendingSteer.set(streamId, str(data.text));
+                                return;
+                            }
+                            this.settleConsumedSteers(sessionId, streamId, str(data.text));
                             return;
                         case 'tool': {
                             const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
@@ -401,15 +431,20 @@ export class TurnRunner {
                             return;
                         }
                         case 'tool_complete': {
-                            // TAL-313: the server decides failure from the sidecar's raw result, which never leaves the server.
+                            // TAL-313: the server decides failure from the sidecar's raw result, which never leaves the server; TAL-315: so
+                            // are its display sections, which keep the stderr and exit code the flat preview drops.
                             const { raw_result: rawResult, ...complete } = data;
-                            complete.is_error = toolOutcome(rawResult).is_error;
+                            const outcome = toolOutcome(rawResult);
+                            complete.is_error = outcome.is_error;
+                            if (rawResult !== undefined)
+                                complete.result_view = outcome.result_view;
                             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 });
+                                // TAL-315: the decided view too, so a failed or cancelled turn's snapshot keeps the sections shown live.
+                                Object.assign(tc, { done: true, snippet: data.preview, is_error: complete.is_error, duration: complete.duration ?? null, ...(complete.result_view ? { result_view: complete.result_view } : {}) });
                             }
                             const id = (tc && toolIds.get(tc)) || str(data.tid) || mintToolId();
                             this.lastCompletedTool.set(streamId, id);
@@ -424,6 +459,14 @@ export class TurnRunner {
                             put('approval', { ...(pending ?? data), pending_count });
                             return;
                         }
+                        // TAL-514: the Agent stopped waiting on an approval (answer, timeout, or interrupt); withdraw its copy.
+                        case 'approval_resolved': {
+                            if (!str(data.approval_id))
+                                return;
+                            deps.pending.resolveApproval(sessionId, str(data.approval_id));
+                            put(...this.approvalHeadFrame(sessionId));
+                            return;
+                        }
                         case 'clarify': {
                             deps.pending.submitClarify(sessionId, { ...data, session_id: sessionId, kind: 'clarify' });
                             const head = deps.pending.clarifyHeadFrame(sessionId);
@@ -455,25 +498,6 @@ export class TurnRunner {
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
-            if (opts.ephemeral) {
-                let answer = '';
-                for (let i = result.messages.length - 1; i >= 0; i -= 1) {
-                    const m = result.messages[i];
-                    if (m.role === 'assistant') {
-                        answer = str(m.content);
-                        break;
-                    }
-                }
-                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, terminal_state: answer.trim() ? 'completed' : 'no_response' });
-                try {
-                    rmSync(deps.store.pathFor(sessionId), { force: true });
-                }
-                catch { /* ignore */ }
-                deps.store.sessions.delete(sessionId);
-                return;
-            }
             // Writeback only while this stream still owns the session (Python `_stream_writeback_is_current`).
             let current;
             try {
@@ -494,19 +518,26 @@ 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(), turnId: streamId });
-            const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
+            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] });
+            // TAL-512: a btw answer must be a reply this turn added: everything before it is the parent's replayed history.
+            const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || (!opts.ephemeral && !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.
-            const stalePartial = result.result_status === 'partial' && !assistantAdded;
-            if (result.status === 'error' || (!assistantAdded && !tokenSent) || stalePartial) {
-                const classification = classifyProviderError(lastErr, { silentFailure: !lastErr });
+            // Python `_agent_result_terminal_failure`: the Agent's failed, partial, or compression-exhausted result ends the turn
+            // even after text streamed; only a partial with no error text and a final answer still completes.
+            const agentFailed = result.failed || result.compression_exhausted || (result.partial && (Boolean(lastErr) || !assistantAdded));
+            if (result.status === 'error' || agentFailed || (!assistantAdded && (!tokenSent || opts.ephemeral))) {
+                const classification = classifyProviderError(lastErr, { silentFailure: !lastErr, compressionExhausted: result.compression_exhausted });
                 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));
+                // Settle the steers first so the persisted turn carries every consumed one; the Agent's pending text is sent next.
+                // A withdraw or Send now still in flight finishes first, so the settlement sees the queue it left.
+                await this.steerRewrites.get(streamId);
+                const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, str(result.pending_steer), 'followup');
+                followUp = leftovers;
                 this.persistError(s, streamId, classification.label, payload, activeTurnToken);
-                payload.session = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
+                // TAL-512: a btw error carries no session: its journaled frame must not keep a copy of the parent conversation.
+                if (!opts.ephemeral)
+                    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)
@@ -515,17 +546,32 @@ export class TurnRunner {
                 failed = true;
                 return;
             }
+            // TAL-512: a btw turn passes the failure check above first, so its last assistant row is this turn's reply.
+            if (opts.ephemeral) {
+                let answer = '';
+                for (let i = result.messages.length - 1; i >= 0; i -= 1) {
+                    const m = result.messages[i];
+                    if (m.role === 'assistant') {
+                        answer = str(m.content);
+                        break;
+                    }
+                }
+                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, terminal_state: answer.trim() ? 'completed' : 'no_response' });
+                try {
+                    rmSync(deps.store.pathFor(sessionId), { force: true });
+                }
+                catch { /* ignore */ }
+                deps.store.sessions.delete(sessionId);
+                return;
+            }
             // ── settle the transcript ──
             // 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 });
+            await this.steerRewrites.get(streamId);
+            const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, result.pending_steer, 'followup');
+            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] });
             s.context_messages = dedupeContext(resultMessages);
-            for (const m of s.messages) {
-                if (m.role !== 'assistant')
-                    continue;
-                if (typeof m.content === 'string')
-                    m.content = stripXmlToolCalls(m.content);
-            }
             if (result.compressed) {
                 s.compression_anchor_visible_idx = Math.max(0, previousMessages.length - 1);
                 put('compressed', { session_id: sessionId, old_session_id: sessionId, new_session_id: sessionId, continuation_session_id: sessionId, message: 'Compression finished' });
@@ -567,7 +613,8 @@ export class TurnRunner {
                     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)))
+                        // An attachment-only prompt has no text to match: only this turn's own row takes its files.
+                        if (msgText ? content.includes(base.slice(0, 60)) || msgText.includes(content.slice(0, 60)) : m._turn_id === streamId)
                             m.attachments = [...attachments];
                         break;
                     }
@@ -583,12 +630,12 @@ export class TurnRunner {
                 asstIdx += 1;
                 if (turnIdx < prevAssistants)
                     continue;
-                const existing = str(m.reasoning);
+                // The settled row keeps its own fields: only its prose and its inline thinking (into `reasoning`) are rewritten.
                 if (typeof m.content === 'string' && m.content) {
-                    const [content, merged] = splitThinkingFromContent(m.content, existing);
+                    const [content, inline] = splitDisplayText(m.content);
                     m.content = content;
-                    if (merged)
-                        m.reasoning = merged;
+                    if (inline)
+                        m.reasoning = joinReasoning([reasoningFieldsText({ reasoning: m.reasoning }), inline]);
                 }
                 if (turnIdx === prevAssistants && reasoning.trim() && !m.reasoning)
                     m.reasoning = reasoning.trim();
@@ -635,6 +682,10 @@ export class TurnRunner {
                 cache_hit_percent: cacheHit(cacheReadTokens, inputTokens), turn_cache_hit_percent: cacheHit(turnCacheRead, turnInput), duration_seconds: Math.round(duration * 1000) / 1000,
                 context_length: s.context_length ?? 0, threshold_tokens: s.threshold_tokens ?? 0, last_prompt_tokens: s.last_prompt_tokens ?? 0,
             };
+            const doneSession = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
+            // TAL-299: the ring's figures match the terminal session's (and a detail reload's).
+            for (const key of CONTEXT_USAGE_FIELDS)
+                doneUsage[key] = doneSession[key];
             if (usage.completion_tokens && duration > 0)
                 doneUsage.tps = Math.round((usage.completion_tokens / duration) * 10) / 10;
             if (firstTokenAt !== null)
@@ -643,7 +694,7 @@ export class TurnRunner {
             if (usedModel)
                 doneUsage.used_model = usedModel;
             const donePayload = {
-                session: redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled()),
+                session: doneSession,
                 usage: doneUsage,
                 terminal_state: turnTerminalState(s.messages, streamId),
             };
@@ -657,22 +708,15 @@ export class TurnRunner {
             // worker before its daemon-thread title generation).
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
-            await this.backgroundTitle(s, put);
+            this.startSteerFollowUp(sessionId, leftovers);
+            // Title work and the goal judge run side by side; `stream_end` follows both, so their frames reach the stream.
+            const work = await Promise.allSettled([this.backgroundTitle(s, put), this.continueGoal(s, streamId, put)]);
+            put('stream_end', { session_id: sessionId });
+            for (const r of work)
+                if (r.status === 'rejected')
+                    throw r.reason;
             // Python: the last non-error assistant reply with content, else "(no answer produced)".
-            if (opts.onDone) {
-                let answer = '';
-                for (let i = s.messages.length - 1; i >= 0; i -= 1) {
-                    const m = s.messages[i];
-                    if (m.role !== 'assistant' || m._error)
-                        continue;
-                    const text = messageText(m.content).trim();
-                    if (text) {
-                        answer = text;
-                        break;
-                    }
-                }
-                opts.onDone(answer || '(no answer produced)');
-            }
+            opts.onDone?.(lastAnswer(s.messages) || '(no answer produced)');
         }
         catch (error) {
             if (settledAt.value && !(error instanceof SidecarError)) {
@@ -704,7 +748,8 @@ export class TurnRunner {
                     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());
+                    if (!opts.ephemeral)
+                        payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
                 }
             }
             catch (persistError) {
@@ -720,21 +765,26 @@ export class TurnRunner {
             // not race the error writeback above (a re-saved session would resurface in the sidebar).
             if (failed)
                 opts.onFailed?.();
+            this.startSteerFollowUp(sessionId, followUp);
         }
     }
     /**
      * Python `_build_user_message`: image attachments are embedded as native `image_url` parts only when the Agent's
      * resolved image mode for this model is `native` (text mode routes them through the Agent's vision tool path), and
-     * only after the bytes are read through an anchored descriptor and sniffed as a real image format.
+     * only after the bytes are read through an anchored descriptor and sniffed as a real image format. Every attached
+     * file is also named by path after the text (TAL-276), so an attachment-only turn still gives the model a request
+     * and its transcript row a distinct identity.
      */
     async buildUserMessage(workspaceCtx, msgText, attachments, workspace, sessionId, s, opts, signal) {
         const text = workspaceCtx + msgText;
+        const named = attachments.map((att) => str(att.path).trim()).filter(Boolean).map(escapeWorkspacePrefixPath);
+        const withFiles = () => (named.length ? `${text}\n\n[Attached files: ${named.join(', ')}]` : text);
         const candidates = attachments.filter((att) => str(att.path).trim() && str(att.mime).trim().startsWith('image/'));
         if (!candidates.length)
-            return text;
+            return withFiles();
         const sidecar = this.deps.sidecar();
         if (!sidecar)
-            return text;
+            return withFiles();
         // A cancel that landed before this point is final: never start the lookup or wait on it.
         if (signal.aborted)
             return text;
@@ -750,15 +800,15 @@ export class TurnRunner {
             if (mode.mode !== 'native') {
                 const cfg = (await this.deps.profileConfig?.(s.profile ?? null)) ?? {};
                 if (explicitTextSignal(cfg) || mode.supports_vision === false)
-                    return text;
+                    return withFiles();
             }
         }
         catch (error) {
             if (!signal.aborted)
                 this.deps.log(`[webui] image mode lookup failed for ${sessionId}: ${error.message}`);
-            return text;
+            return withFiles();
         }
-        const parts = [{ type: 'text', text }];
+        const parts = [];
         let images = 0;
         const roots = [workspace, this.deps.attachmentDir(sessionId)].map((r) => resolvePathLikePython(r));
         for (const att of candidates) {
@@ -790,17 +840,20 @@ export class TurnRunner {
                 closeSync(fd);
             }
         }
-        return images ? parts : text;
+        return images ? [{ type: 'text', text: withFiles() }, ...parts] : withFiles();
     }
     /**
      * Python `_session_payload_with_terminal_window`: the same visible-message window contract as `GET /api/session?
      * msg_limit=` (renderable rows, limited payload shape, windowed tool calls, todo state) with the full count.
      */
     terminalSessionPayload(s) {
-        const payload = withSessionWireFlags(s.compact(), this.registry.liveIds);
-        const scened = hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(withAttachmentObjects(s.messages)), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true });
+        const payload = withSessionWireFlags(s.compact({ contextLengthFor: this.deps.service().deps.contextLengthFor, modelOptionFor: this.deps.service().deps.modelOptionFor }), this.registry.liveIds);
+        payload.assistant_name = this.deps.service().assistantName(s);
+        payload.workspace_name = this.deps.service().workspaceNames()(s);
+        const service = this.deps.service();
+        const scened = service.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withMarkerKinds(withTurnIds(withAttachmentObjects(s.messages))), s), 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);
+        const limited = messagesForLimitedPayload(withBodyExcerpts(withDisplayMedia(window, service.mediaProjector(s)), s.active_stream_id));
         payload.messages = limited;
         payload.message_count = s.messages.length;
         payload._messages_offset = offset;
@@ -853,7 +906,7 @@ export class TurnRunner {
     }
     materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
-        if (!pendingText)
+        if (!s.hasPendingPrompt)
             return false;
         const recoveredTs = typeof s.pending_started_at === 'number' && s.pending_started_at > 0 ? s.pending_started_at : this.deps.now();
         const source = s.pending_user_source ?? 'webui';
@@ -932,6 +985,11 @@ export class TurnRunner {
             this.deps.store.sessions.delete(current.session_id);
             return true;
         }
+        // TAL-460: a background turn stops quietly: its prompt and model context are kept, but no partial and no Stop row,
+        // and its first settlement is final.
+        const quiet = this.registry.activeRuns.get(streamId)?.origin === 'background';
+        if (quiet && current.active_stream_id === null)
+            return true;
         const stop = this.stopContexts.get(streamId);
         const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
         const settle = () => {
@@ -967,8 +1025,10 @@ export class TurnRunner {
         current.pending_attachments = [];
         current.pending_started_at = null;
         current.pending_user_source = null;
-        this.appendPartialSnapshot(current, streamId);
-        current.messages.push({ role: 'assistant', content: '', _error: true, _terminal_state: 'cancelled', timestamp: Math.trunc(this.deps.now()), _turn_id: streamId });
+        if (!quiet) {
+            this.appendPartialSnapshot(current, 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);
@@ -1077,83 +1137,83 @@ export class TurnRunner {
         const sessionId = s.session_id;
         const placeholder = str(s.title).trim();
         const invalidExisting = looksInvalidGeneratedTitle(s.title);
-        const eligible = ['Untitled', 'New Chat', ''].includes(placeholder) || placeholder === titleFrom(s.messages, '') || invalidExisting;
+        // A claimed CLI session still carrying its default `<Source> Session` title is retitled like a new chat (TAL-256).
+        const defaultTitle = (session) => looksLikeDefaultCliTitle({ title: session.title, source_tag: session.source_tag, raw_source: session.raw_source, session_source: session.session_source, source_label: session.source_label });
+        const eligible = ['Untitled', 'New Chat', ''].includes(placeholder) || placeholder === titleFrom(s.messages, '') || invalidExisting || defaultTitle(s);
         const [userText, assistantText] = firstExchangeSnippets(s.messages);
         // Python `_put_title_status`: empty reason/title/raw_preview keys are omitted.
         const status = (status, reason = '', title = '', rawPreview = '') => {
             put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
         };
-        try {
-            if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
-                return;
-            if (s.manual_title) {
-                status('skipped', 'manual_title', placeholder);
-                return;
+        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
+            return;
+        if (s.manual_title) {
+            status('skipped', 'manual_title', placeholder);
+            return;
+        }
+        if (!this.deps.titleGenerationEnabled()) {
+            status('skipped', 'title_generation_disabled', placeholder);
+            return;
+        }
+        const generated = await this.llmTitle(s, userText, assistantText);
+        const { status: llmStatus, rawPreview } = generated;
+        let next = generated.title;
+        let source = llmStatus;
+        if (!next) {
+            const fallback = fallbackTitleFromExchange(userText, assistantText);
+            if (fallback && !isGenericFallbackTitle(fallback)) {
+                next = fallback;
+                source = 'fallback';
             }
-            if (!this.deps.titleGenerationEnabled()) {
-                status('skipped', 'title_generation_disabled', placeholder);
+        }
+        const fallbackReason = source === 'fallback' && llmStatus ? `local_summary:${llmStatus}` : 'local_summary';
+        let current = s;
+        try {
+            current = this.deps.store.get(sessionId);
+        }
+        catch {
+            current = s;
+        }
+        let effective = str(current.title).trim();
+        let wrote = false;
+        if (next) {
+            const stillAuto = effective === placeholder || ['Untitled', 'New Chat', ''].includes(effective) || effective === titleFrom(current.messages, '') || looksInvalidGeneratedTitle(current.title) || defaultTitle(current);
+            if (current.manual_title || !stillAuto) {
+                status('skipped', 'manual_title', effective);
                 return;
             }
-            const generated = await this.llmTitle(s, userText, assistantText);
-            const { status: llmStatus, rawPreview } = generated;
-            let next = generated.title;
-            let source = llmStatus;
-            if (!next) {
-                const fallback = fallbackTitleFromExchange(userText, assistantText);
-                if (fallback && !isGenericFallbackTitle(fallback)) {
-                    next = fallback;
-                    source = 'fallback';
-                }
-            }
-            const fallbackReason = source === 'fallback' && llmStatus ? `local_summary:${llmStatus}` : 'local_summary';
-            let current = s;
-            try {
-                current = this.deps.store.get(sessionId);
-            }
-            catch {
-                current = s;
-            }
-            let effective = str(current.title).trim();
-            let wrote = false;
-            if (next) {
-                const stillAuto = effective === placeholder || ['Untitled', 'New Chat', ''].includes(effective) || effective === titleFrom(current.messages, '') || looksInvalidGeneratedTitle(current.title);
-                if (current.manual_title || !stillAuto) {
-                    status('skipped', 'manual_title', effective);
-                    return;
-                }
-                if (next !== effective) {
-                    current.title = next;
-                    markSessionTitleGenerated(current);
-                    this.deps.store.save(current, { touchUpdatedAt: false });
-                    // Python `sync_session_title` after generation: the state.db row follows when `sync_to_insights` is on.
-                    await this.deps.syncTitle?.(current);
-                    this.deps.events.publish('title', { profile: current.profile, sessionId });
-                    effective = next;
-                    wrote = true;
-                }
-            }
-            if (wrote) {
-                status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
-                put('title', { session_id: sessionId, title: effective });
+            if (next !== effective) {
+                current.title = next;
+                markSessionTitleGenerated(current);
+                this.deps.store.save(current, { touchUpdatedAt: false });
+                // Python `sync_session_title` after generation: the state.db row follows when `sync_to_insights` is on.
+                await this.deps.syncTitle?.(current);
+                this.deps.events.publish('title', { profile: current.profile, sessionId });
+                effective = next;
+                wrote = true;
             }
-            else
-                status('skipped', source || 'unchanged', effective, rawPreview);
         }
-        finally {
-            put('stream_end', { session_id: sessionId });
+        if (wrote) {
+            status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
+            put('title', { session_id: sessionId, title: effective });
         }
+        else
+            status('skipped', source || 'unchanged', effective, rawPreview);
     }
     // ── cancel / steer ───────────────────────────────────────────────────────
-    /** Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. */
+    /**
+     * Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. `withdrawn` is the
+     * `steer_withdrawn` (stopped) this Stop emitted, for the cancel response (TAL-426).
+     */
     async cancel(streamId) {
         const channel = this.registry.peek(streamId);
         const run = this.registry.activeRuns.get(streamId);
         if (!channel && !run)
-            return false;
+            return { cancelled: false, withdrawn: [] };
         // Python popped the run before its title work: a cancel that lands after `done` (while the title prompts still run)
         // is not a cancellation, so it neither journals a `cancel` frame nor marks the completed run interrupted.
         if (!run && this.settledStreams.has(streamId))
-            return false;
+            return { cancelled: false, withdrawn: [] };
         const sessionId = this.registry.ownerSessionId(streamId) ?? run?.session_id ?? null;
         this.registry.cancelled.add(streamId);
         if (run) {
@@ -1174,7 +1234,9 @@ export class TurnRunner {
         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) : [];
+        // TAL-424: a Stop withdraws the steers the Agent never took, with their text, and starts nothing after.
+        await this.steerRewrites.get(streamId);
+        const steerEvents = (this.steers.get(streamId) ?? []).length ? this.finalizeSteers(streamId, leftover, 'stopped').events : [];
         if (sessionId) {
             let current = null;
             try {
@@ -1210,6 +1272,21 @@ export class TurnRunner {
             this.registry.liveIds.delete(streamId);
         }
         this.abortControllers.get(streamId)?.abort();
+        const withdrawn = steerEvents.filter(([event]) => event === 'steer_withdrawn').map(([, data]) => data);
+        return { cancelled: true, withdrawn };
+    }
+    /**
+     * TAL-460: a user's message never joins a background turn. That turn stops quietly (`finalizeCancelled`) and its worker
+     * unwinds before the user's turn is admitted, so two Agent runs never share the session. True when one was stopped.
+     */
+    async yieldBackgroundTurn(sessionId) {
+        const streamId = this.registry.activeRunStreamForSession(sessionId);
+        if (!streamId || this.registry.activeRuns.get(streamId)?.origin !== 'background')
+            return false;
+        await this.cancel(streamId);
+        let timer;
+        await Promise.race([this.workers.get(streamId), new Promise((resolve) => { timer = setTimeout(resolve, BACKGROUND_UNWIND_WAIT_MS); })]);
+        clearTimeout(timer);
         return true;
     }
     async steer(sessionId, text, displayText, steerId) {
@@ -1234,7 +1311,10 @@ export class TurnRunner {
             return { accepted: false, fallback: 'no_cached_agent', stream_id: null };
         // Register provisionally before the RPC: the Agent may apply the steer and finish the turn before the steer
         // reply arrives, and the turn's finalisation must then already see the record. A rejection removes it again.
-        const record = { steer_id: steerId, session_id: sessionId, stream_id: activeStreamId, text, display_text: displayText || text, created_at: this.deps.now() };
+        return this.withSteerChain(activeStreamId, () => this.steerInto(sidecar, sessionId, activeStreamId, text, displayText, steerId));
+    }
+    async steerInto(sidecar, sessionId, activeStreamId, text, displayText, steerId) {
+        const record = { steer_id: steerId, session_id: sessionId, stream_id: activeStreamId, text, display_text: displayText || text, created_at: this.deps.now(), state: 'pending', can_redirect: false };
         const records = this.steers.get(activeStreamId) ?? [];
         records.push(record);
         this.steers.set(activeStreamId, records);
@@ -1259,6 +1339,12 @@ export class TurnRunner {
         // An accepted steer whose turn finalised while the reply was in flight was already reported by that finalisation.
         if (!result.accepted)
             withdraw();
+        else {
+            record.can_redirect = result.can_redirect === true;
+            // TAL-424: every client shows it until the Agent takes it (unless it already did while the reply was in flight).
+            if (this.steers.get(activeStreamId)?.includes(record))
+                this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+        }
         return { accepted: result.accepted, fallback: result.accepted ? null : (result.fallback ?? 'not_running'), stream_id: activeStreamId, steer_id: steerId };
     }
     /** Python `_webui_steer_events_before` for terminal frames: cancel/apperror flush consumed steers and leftovers first. */
@@ -1267,7 +1353,7 @@ export class TurnRunner {
             return [];
         if (!(this.steers.get(streamId) ?? []).length)
             return [];
-        return this.finalizeSteerEvents(streamId, '');
+        return this.finalizeSteers(streamId, '', 'stopped').events;
     }
     /** Python `_pending_webui_steer_suffix_start`: the pending text is the newline-joined tail of the records; earlier ones are consumed. */
     static pendingSteerSuffixStart(records, pendingText) {
@@ -1280,15 +1366,15 @@ export class TurnRunner {
         }
         return null;
     }
-    consumedSteerPayload(record) {
+    consumedSteerPayload(record, opts = {}) {
         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 });
+            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, ...(opts.redirected ? { redirected: true } : {}) });
             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 };
+        return { steer_id: record.steer_id, session_id: record.session_id, stream_id: record.stream_id, display_text: record.display_text, created_at: record.created_at, 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
@@ -1309,7 +1395,14 @@ export class TurnRunner {
             };
             // 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];
+            let agentRow = agentRows.find((i) => agentSteerText(s.messages[i]) === steer.agent_text.trim()) ?? agentRows[0];
+            // A Send now redirect is recorded as a plain user row of the turn: that row becomes the steer too.
+            if (steer.redirected) {
+                const prompt = s.messages.findIndex((m) => m._turn_id === streamId && m.role === 'user' && !m._steer);
+                const own = s.messages.findIndex((m, i) => i > prompt && m._turn_id === streamId && m.role === 'user' && !m._steer && messageText(m.content).trim() === steer.agent_text.trim());
+                // Never another steer's row: without its own correction row (the Agent joins two redirects) it gets a new one.
+                agentRow = own >= 0 ? own : undefined;
+            }
             if (agentRow === undefined)
                 s.messages.splice(steerInsertIndex(s.messages, streamId, steer.after_tool_call_id), 0, row);
             else
@@ -1364,22 +1457,235 @@ export class TurnRunner {
             return [];
         return records.slice(0, start).map((r) => this.consumedSteerPayload(r));
     }
-    /** Terminal steer bookkeeping for cancel/error paths: consumed records first, then `pending_steer_leftover` for the rest. */
-    finalizeSteerEvents(streamId, leftoverText) {
+    /**
+     * Terminal steer bookkeeping: the records the Agent no longer holds are consumed; the rest it never took are either
+     * `stopped` (withdrawn with their text for the composer) or returned as one `followup` turn's texts (TAL-424).
+     */
+    finalizeSteers(streamId, leftoverText, mode) {
         const records = this.steers.get(streamId) ?? [];
         this.steers.delete(streamId);
-        const start = TurnRunner.pendingSteerSuffixStart(records, leftoverText);
-        if (start === null)
-            return leftoverText ? [['pending_steer_leftover', { stream_id: streamId, text: leftoverText }]] : [];
-        const events = records.slice(0, start).map((r) => ['steer_consumed', this.consumedSteerPayload(r)]);
-        const leftovers = records.slice(start);
-        for (const r of leftovers)
-            events.push(['pending_steer_leftover', { ...r, leftover_at: this.deps.now() }]);
-        const matched = leftovers.map((r) => r.text).join('\n');
+        // Text that ends with none of these steers is another surface's: the Agent took every one of them.
+        const start = TurnRunner.pendingSteerSuffixStart(records, leftoverText) ?? records.length;
+        const consumed = records.slice(0, start);
+        const left = records.slice(start);
+        const matched = left.map((r) => r.text).join('\n');
         const unmatched = matched ? leftoverText.slice(0, leftoverText.length - matched.length).replace(/\n+$/, '') : leftoverText;
+        const events = consumed.map((r) => ['steer_consumed', this.consumedSteerPayload(r)]);
+        for (const r of left)
+            events.push(['steer_withdrawn', { steer_id: r.steer_id, reason: mode, text: r.display_text }]);
+        if (mode === 'followup')
+            return { events, leftovers: [...(unmatched ? [unmatched] : []), ...left.map((r) => r.text)] };
+        if (unmatched)
+            events.push(['steer_withdrawn', { steer_id: null, reason: 'stopped', text: unmatched }]);
+        // ponytail: legacy `pending_steer_leftover` keeps today's Web and App from losing a stopped steer (they requeue it);
+        // drop it once TAL-425 / TAL-426 put `steer_withdrawn` text back in the composer.
+        for (const r of left)
+            events.push(['pending_steer_leftover', { steer_id: r.steer_id, stream_id: streamId, text: r.text, display_text: r.display_text, leftover_at: this.deps.now() }]);
         if (unmatched)
             events.push(['pending_steer_leftover', { stream_id: streamId, text: unmatched }]);
-        return events;
+        return { events, leftovers: [] };
+    }
+    /**
+     * TAL-424: the steers a finished turn never took go on as one follow-up turn, sent once by the server for every client.
+     * Should another turn already hold the session, they steer into that one instead, so no text is lost.
+     */
+    startSteerFollowUp(sessionId, texts) {
+        if (!texts.length)
+            return;
+        let s;
+        try {
+            s = this.deps.store.get(sessionId);
+        }
+        catch {
+            return;
+        }
+        const msg = texts.join('\n');
+        const started = this.start(s, { msg, attachments: [], workspace: s.workspace, model: s.model, modelProvider: s.model_provider });
+        if (!started._status || started._status < 400)
+            return;
+        if (started._status === 409 && started.active_stream_id) {
+            void this.steer(sessionId, msg, msg, `steer-${randomUUID()}`).then((r) => {
+                if (r.accepted !== true)
+                    this.deps.log(`[webui] WARNING: steer follow-up for ${sessionId} was not accepted (${str(r.fallback)}); text: ${msg.slice(0, 200)}`);
+            });
+            return;
+        }
+        this.deps.log(`[webui] WARNING: steer follow-up for ${sessionId} not started (${String(started._status)}): ${str(started.error)}`);
+    }
+    /**
+     * TAL-396 (Agent gateway `_post_turn_goal_continuation`): after every turn settles, the Agent's GoalManager judges it
+     * while a goal is active and the server starts the continuation turn it asks for. Any turn counts, so a resumed or
+     * persisted goal picks up from the next user message. A user turn that took the session meanwhile runs first and is
+     * judged next. A stopped or failed turn never gets here, so the run ends there.
+     */
+    async continueGoal(s, streamId, put) {
+        const sidecar = this.deps.sidecar();
+        const lastResponse = lastAnswer(s.messages);
+        // The Agent never drives a goal from an empty reply.
+        if (!sidecar || !lastResponse)
+            return;
+        const sessionId = s.session_id;
+        // Only a known goal turn shows progress up front; any other turn shows nothing unless a goal turns out to be active.
+        const goalTurn = this.registry.goalRelated.has(streamId);
+        if (goalTurn)
+            put('goal', { session_id: sessionId, state: 'evaluating', message: 'Evaluating goal progress…', message_key: 'goal_evaluating_progress' });
+        let decision;
+        try {
+            decision = await sidecar.call('goals.evaluate', { session_id: sessionId, profile_home: this.deps.profileHome(s.profile), last_response: lastResponse, user_initiated: true });
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: goal evaluation failed for ${sessionId}: ${error.message}`);
+            if (goalTurn)
+                put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' });
+            return;
+        }
+        if (!goalTurn && decision.verdict === 'inactive')
+            return;
+        const prompt = str(decision.continuation_prompt).trim();
+        const proceed = decision.should_continue && Boolean(prompt);
+        const status = { message: decision.message, message_key: decision.message_key, message_args: decision.message_args ?? [], decision: decision.verdict };
+        put('goal', { session_id: sessionId, state: proceed ? 'continuing' : 'idle', ...status });
+        if (!proceed)
+            return;
+        let current;
+        try {
+            current = this.deps.store.get(sessionId);
+        }
+        catch {
+            return;
+        }
+        const started = this.start(current, { msg: prompt, attachments: [], workspace: current.workspace, model: current.model, modelProvider: current.model_provider, goalRelated: true });
+        if (started._status === 409 && started.active_stream_id) {
+            this.registry.goalRelated.add(started.active_stream_id);
+            return;
+        }
+        if (started._status !== undefined && started._status >= 400) {
+            this.deps.log(`[webui] WARNING: goal continuation for ${sessionId} not started (${String(started._status)}): ${str(started.error)}`);
+            put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' });
+            return;
+        }
+        put('goal_continue', { session_id: sessionId, state: 'continuing', continuation_prompt: prompt, text: prompt, stream_id: str(started.stream_id), ...status });
+    }
+    /** The Agent's pending steer text settles which steers it has taken: those become `steer_consumed` and their rows. */
+    settleConsumedSteers(sessionId, streamId, pendingText) {
+        for (const record of this.takeConsumedSteers(streamId, pendingText, { keepLeftovers: true }))
+            this.emitToSession(sessionId, 'steer_consumed', record);
+        this.saveConsumedSteers(sessionId, streamId);
+    }
+    /** What every client shows for a pending steer; the server decides which actions it offers. */
+    pendingSteerView(r) {
+        const open = r.state === 'pending';
+        return { steer_id: r.steer_id, text: r.display_text, submitted_at: r.created_at, state: r.state, actions: { edit: open, cancel: open, send_now: open && r.can_redirect } };
+    }
+    /** TAL-424: the active stream's pending steers, oldest first (session detail `pending_steers`). */
+    pendingSteers(streamId) {
+        return (this.steers.get(streamId) ?? []).map((r) => this.pendingSteerView(r));
+    }
+    withSteerChain(streamId, fn) {
+        const run = (this.steerChains.get(streamId) ?? Promise.resolve()).then(fn);
+        const settled = run.catch(() => undefined).then(() => { if (this.steerChains.get(streamId) === settled)
+            this.steerChains.delete(streamId); });
+        this.steerChains.set(streamId, settled);
+        return run;
+    }
+    /**
+     * A withdraw or Send now on one pending steer of the session's active stream. `rewrite` asks the sidecar to change the
+     * Agent's queue and says whether it did; pending text the Agent reported meanwhile is settled after, unless the queue
+     * changed (the next report then reflects it).
+     */
+    async rewriteSteer(sessionId, steerId, fallback, rewrite) {
+        let s = null;
+        try {
+            s = this.deps.store.get(sessionId, { metadataOnly: true });
+        }
+        catch {
+            s = null;
+        }
+        const streamId = s?.active_stream_id;
+        const sidecar = this.deps.sidecar();
+        if (!streamId || !sidecar)
+            return fallback;
+        return this.withSteerChain(streamId, async () => {
+            const records = this.steers.get(streamId) ?? [];
+            const index = records.findIndex((r) => r.steer_id === steerId);
+            if (index < 0 || records[index].state !== 'pending')
+                return fallback;
+            // In flight before the sidecar call, so a pending-text report racing its reply is deferred too.
+            let finished = () => undefined;
+            this.steerRewrites.set(streamId, new Promise((resolve) => { finished = resolve; }));
+            let outcome = { result: fallback, changed: false };
+            try {
+                outcome = await rewrite(sidecar, streamId, records, index);
+            }
+            catch {
+                outcome = { result: fallback, changed: false };
+            }
+            finally {
+                this.steerRewrites.delete(streamId);
+                finished();
+                const deferred = this.deferredPendingSteer.get(streamId);
+                this.deferredPendingSteer.delete(streamId);
+                if (deferred !== undefined && !outcome.changed)
+                    this.settleConsumedSteers(sessionId, streamId, deferred);
+            }
+            return outcome.result;
+        });
+    }
+    dropSteer(streamId, record) {
+        const records = this.steers.get(streamId);
+        const index = records?.indexOf(record) ?? -1;
+        if (records && index >= 0)
+            records.splice(index, 1);
+    }
+    /**
+     * TAL-424 Edit and Cancel: take a pending steer back before the Agent takes it. `withdrawn: false` (and nothing
+     * emitted) when it is unknown, already taken or being sent; a taken one then settles as consumed.
+     */
+    withdrawSteer(sessionId, steerId, reason) {
+        return this.rewriteSteer(sessionId, steerId, { withdrawn: false }, async (sidecar, streamId, records, index) => {
+            const record = records[index];
+            const reply = await sidecar.call('chat.steer_withdraw', { stream_id: streamId, pending: records.map((r) => r.text), index });
+            if (!reply.withdrawn)
+                return { result: { withdrawn: false }, changed: false };
+            this.dropSteer(streamId, record);
+            this.emitToSession(sessionId, 'steer_withdrawn', { steer_id: record.steer_id, reason, text: record.display_text });
+            return { result: { withdrawn: true, text: record.display_text }, changed: true };
+        });
+    }
+    /**
+     * TAL-424 Send now: deliver a pending steer with the Agent's redirect. A model request restarts with it (consumed at
+     * once); during tools it goes last on the Agent's queue and stays `sending_now` until taken; with nothing live it
+     * stays pending.
+     */
+    sendSteerNow(sessionId, steerId) {
+        return this.rewriteSteer(sessionId, steerId, { redirected: false }, async (sidecar, streamId, records, index) => {
+            const record = records[index];
+            if (!record.can_redirect)
+                return { result: { redirected: false }, changed: false };
+            const reply = await sidecar.call('chat.steer_now', { stream_id: streamId, pending: records.map((r) => r.text), index });
+            if (!reply.withdrawn)
+                return { result: { redirected: false }, changed: false };
+            if (!reply.redirected) {
+                // The Agent's queue changed meanwhile, so it went back last: clients follow the new order.
+                if (reply.requeued === 'last') {
+                    this.dropSteer(streamId, record);
+                    records.push(record);
+                    this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+                }
+                return { result: { redirected: false }, changed: true };
+            }
+            this.dropSteer(streamId, record);
+            if (reply.delivery === 'steer') {
+                record.state = 'sending_now';
+                records.push(record);
+                this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+            }
+            else {
+                this.emitToSession(sessionId, 'steer_consumed', this.consumedSteerPayload(record, { redirected: true }));
+                this.saveConsumedSteers(sessionId, streamId);
+            }
+            return { result: { redirected: true }, changed: true };
+        });
     }
     // ── approvals / clarify ──────────────────────────────────────────────────
     async respondApproval(sessionId, choice, approvalId, enableYolo) {
@@ -1402,6 +1708,7 @@ export class TurnRunner {
         }
         const profileHome = this.deps.profileHome(s?.profile ?? null);
         let resolved = false;
+        let withdrawn = false;
         if (entry) {
             if (!sidecar)
                 return relayFailure('not running');
@@ -1413,8 +1720,13 @@ export class TurnRunner {
                 this.deps.log(`[webui] approval relay failed for ${sessionId}: ${error.message}`);
                 return relayFailure(str(error.message));
             }
-            if (resolved && entry)
+            if (resolved)
                 this.deps.pending.resolveApproval(sessionId, str(entry.approval_id));
+            else {
+                // TAL-514: a rejected answer can mean the Agent already stopped waiting on this card; drop what it no longer holds.
+                await this.reconcileApprovals(sessionId, sidecar);
+                withdrawn = !this.deps.pending.hasApprovalId(sessionId, str(entry.approval_id));
+            }
         }
         let yoloEnabled;
         if (enableYolo) {
@@ -1437,10 +1749,34 @@ export class TurnRunner {
             yoloEnabled = true;
             this.deps.pending.clearApprovals(sessionId);
         }
+        if (withdrawn)
+            return { ok: true, choice, stale_cleared: true, pending_count: this.deps.pending.approvalPending(sessionId).pending_count, ...(enableYolo ? { yolo_enabled: yoloEnabled } : {}) };
         if (!found && !this.deps.pending.hasPendingApproval(sessionId))
             return { ok: true, choice, stale_cleared: true, ...(enableYolo ? { yolo_enabled: yoloEnabled } : {}) };
         return { ok: resolved || !approvalId, choice, ...(enableYolo && (resolved || !approvalId) ? { yolo_enabled: yoloEnabled } : {}) };
     }
+    /** The live chat frame after approvals were withdrawn: the new queue head, or `approval_cleared` once none is left. */
+    approvalHeadFrame(sessionId) {
+        const { pending, pending_count } = this.deps.pending.approvalPending(sessionId);
+        return pending ? ['approval', { ...pending, pending_count }] : ['approval_cleared', { session_id: sessionId, pending_count: 0 }];
+    }
+    /**
+     * Drop mirrored approvals the Agent no longer holds; a failed read keeps them (the card stays answerable). Only
+     * entries queued before the read are candidates: one the Agent parks meanwhile can be missing from its snapshot.
+     */
+    async reconcileApprovals(sessionId, sidecar) {
+        const before = this.deps.pending.approvalRequestIds(sessionId);
+        let live;
+        try {
+            live = new Set((await sidecar.call('approval.pending', { session_id: sessionId })).pending.map((p) => str(p.request_id)));
+        }
+        catch (error) {
+            this.deps.log(`[webui] approval reconcile failed for ${sessionId}: ${error.message}`);
+            return;
+        }
+        if (this.deps.pending.dropApprovals(sessionId, new Set(before.filter((id) => !live.has(id)))).length)
+            this.emitToSession(sessionId, ...this.approvalHeadFrame(sessionId));
+    }
     withYoloLock(sessionId, fn) {
         const run = (this.yoloChains.get(sessionId) ?? Promise.resolve()).then(fn);
         const settled = run.catch(() => undefined).then(() => { if (this.yoloChains.get(sessionId) === settled)
@@ -1493,6 +1829,18 @@ export class TurnRunner {
         return { ok: true, response };
     }
 }
+/** The turn's answer: the last non-error assistant reply with content. */
+function lastAnswer(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (m.role !== 'assistant' || m._error)
+            continue;
+        const text = messageText(m.content).trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
 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);
 }