@maudecode/talaria-web 1.15.0 → 1.17.2

package/dist/sessions/turn.js

@@ -12,29 +12,57 @@ 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 { ChatUsageSchema } from '@maudecode/talaria-web-contracts';
 import { PendingPrompts, clarifyReply } from './pending.js';
 import { RunJournal } from './journal.js';
-import { CONTEXT_USAGE_FIELDS, Session, titleFrom } from './session.js';
-import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactSessionData, redactString, withToolId } from '../redact.js';
+import { CONTEXT_USAGE_FIELDS, Session, contextUsage, titleFrom } from './session.js';
+import { anchorMessageKey, compressionReference, markerSummary, visibleMessagesForAnchor } from './compress.js';
+import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactNestedMessageContainers, 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 { UNSETTLED_TODO_KEY, attachTodoState, parseTodoToolResult } from './todo.js';
 import { withSessionWireFlags } from './list.js';
 import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, escapeWorkspacePrefixPath, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withAttachmentObjects, withBodyExcerpts, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, stoppedTurnContext, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, workspaceContextPrefix, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } 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';
+import { toolEditDiff } from './tool-display.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
 const IMAGE_MODE_TIMEOUT_MS = 15_000;
 const TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT = 80;
+/** TAL-397: streamed text reports the live meter at most this often (seconds); a counter change reports at once. */
+const METERING_INTERVAL_S = 1;
 /** 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.' };
+/** The Agent's session counters onto a session's: a zero or missing reading keeps the figure it already has. */
+function applyAgentUsage(target, usage) {
+    if (usage.prompt_tokens > 0)
+        target.input_tokens = usage.prompt_tokens;
+    if (usage.completion_tokens > 0)
+        target.output_tokens = usage.completion_tokens;
+    if (usage.estimated_cost_usd !== null)
+        target.estimated_cost = usage.estimated_cost_usd;
+    if (usage.cache_read_tokens > 0)
+        target.cache_read_tokens = usage.cache_read_tokens;
+    if (usage.cache_write_tokens > 0)
+        target.cache_write_tokens = usage.cache_write_tokens;
+}
+/** TAL-397: the `metering` frame's counters, the same figures the session persists. */
+const meteringUsage = (c) => ({
+    input_tokens: c.input_tokens || 0, output_tokens: c.output_tokens || 0, estimated_cost: typeof c.estimated_cost === 'number' ? c.estimated_cost : null,
+    cache_read_tokens: c.cache_read_tokens || 0, cache_write_tokens: c.cache_write_tokens || 0,
+});
+/** `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));
@@ -60,7 +88,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: '' };
@@ -132,7 +160,27 @@ export function isGenericContinuationIntent(text) {
     const parts = normalized.split(' ');
     return parts.length > 0 && parts.length <= 2 && parts.every((p) => GENERIC_CONTINUATION_INTENTS.has(p));
 }
+/**
+ * Python `_aux_title_generation_enabled`: `auxiliary.title_generation.enabled` with the Agent's
+ * `is_truthy_value(default=True)` semantics. Missing/null enables; a string enables only as 1/true/yes/on.
+ */
+export function titleGenerationEnabled(cfg) {
+    const value = dict(dict(cfg.auxiliary).title_generation).enabled;
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === 'string')
+        return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+    // Python `bool()`: empty containers are false; any other number than zero (NaN included) is true.
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    if (typeof value === 'number')
+        return value !== 0;
+    return Boolean(value);
+}
 /** Python `_explicit_text_signal`: `agent.image_input_mode: text` or a configured `auxiliary.vision` backend. */
+const isImageAttachment = (att) => Boolean(str(att.path).trim()) && str(att.mime).trim().startsWith('image/');
 export function explicitTextSignal(cfg) {
     const agent = dict(cfg.agent);
     if (str(agent.image_input_mode ?? 'auto').trim().toLowerCase() === 'text')
@@ -157,6 +205,10 @@ export class TurnRunner {
     steerRewrites = new Map();
     deferredPendingSteer = new Map();
     lastCompletedTool = new Map();
+    /** TAL-397: each running turn's live counters, once the Agent reported any; an error or cancel persists them too. */
+    liveUsage = new Map();
+    /** TAL-397: each running turn's latest todo list, which an error or cancel keeps on the session. */
+    liveTodos = 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();
     /**
@@ -180,6 +232,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))
@@ -302,13 +356,16 @@ export class TurnRunner {
         }
         const msgText = opts.msg;
         const previousMessages = structuredClone(s.messages);
-        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);
+        // TAL-493: one state.db read builds the history and marks where this turn's own rows begin.
+        const startRead = deps.service().stateDbRead(s);
+        const previousContext = structuredClone(deps.service().modelContext(s, startRead.rows));
+        // Python `_sanitize_messages_for_agent`: the model never sees display-only rows or a replayed cancelled prompt, and
+        // the Agent gets back the exact bytes it sent (TAL-541).
+        const apiHistory = sanitizeMessagesForApi(previousContext, { preserveApiContent: true });
         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 });
+        this.stopContexts.set(streamId, { previousContext: previousContext.filter((m) => m._turn_id !== streamId), historyLength: apiHistory.length, prompt: workspaceCtx + msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null });
         const activeTurnToken = buildActiveTurnToken(streamId, s.pending_started_at);
         const sidecar = deps.sidecar();
         const partialText = this.registry.partialText.get(streamId) ?? [];
@@ -322,6 +379,25 @@ export class TurnRunner {
         const toolStartedAt = new WeakMap();
         let tokenSent = false;
         let firstTokenAt = null;
+        // TAL-397: the live meter. Counters start from the session's and follow the Agent's; the rate counts text deltas.
+        const liveUsage = { input_tokens: s.input_tokens, output_tokens: s.output_tokens, estimated_cost: s.estimated_cost, cache_read_tokens: s.cache_read_tokens, cache_write_tokens: s.cache_write_tokens };
+        const meter = { deltas: 0, first: 0, last: 0, sentAt: null };
+        const putMetering = (force) => {
+            const now = deps.now();
+            if (!force && meter.sentAt !== null && now - meter.sentAt < METERING_INTERVAL_S)
+                return;
+            meter.sentAt = now;
+            const tps = meter.deltas && meter.last > meter.first ? Math.round((meter.deltas / (meter.last - meter.first)) * 10) / 10 : null;
+            put('metering', { session_id: sessionId, usage: meteringUsage(liveUsage), tps, tps_available: tps !== null, estimated: false });
+        };
+        const meterDelta = () => {
+            const now = deps.now();
+            if (!meter.deltas)
+                meter.first = now;
+            meter.last = now;
+            meter.deltas += 1;
+            putMetering(false);
+        };
         // 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.
@@ -331,7 +407,12 @@ export class TurnRunner {
         let capturedTerminalError = null;
         const controller = new AbortController();
         this.abortControllers.set(streamId, controller);
-        const userMessage = await this.buildUserMessage(workspaceCtx, msgText, opts.attachments ?? [], opts.workspace, sessionId, s, opts, controller.signal);
+        const attachments = opts.attachments ?? [];
+        // TAL-545: one image mode decides both this turn's upload and the replayed history, which a text-mode turn sends
+        // without native images; only a turn with an image on either side asks for it.
+        const imageMode = attachments.some(isImageAttachment) || hasNativeImages(apiHistory) ? await this.imageInputMode(sessionId, s, opts, controller.signal) : null;
+        const userMessage = this.buildUserMessage(workspaceCtx, msgText, attachments, opts.workspace, sessionId, imageMode);
+        const conversationHistory = imageMode === 'text' ? withoutNativeImages(apiHistory) : apiHistory;
         // The prompt the Agent actually gets, native image parts included.
         const stop = this.stopContexts.get(streamId);
         if (stop)
@@ -375,7 +456,7 @@ export class TurnRunner {
             put('context_status', { session_id: sessionId, prefill: { status: 'not_configured', source: 'none', label: '', message_count: 0 } });
             const result = await sidecar.call('chat.start', {
                 profile_home: deps.profileHome(s.profile), session_id: sessionId, stream_id: streamId, workspace: opts.workspace, model: opts.model ?? '', model_provider: opts.modelProvider,
-                user_message: userMessage, ...turnContext, conversation_history: apiHistory, enabled_toolsets: deps.toolsetsFor(s),
+                user_message: userMessage, ...turnContext, conversation_history: conversationHistory, enabled_toolsets: deps.toolsetsFor(s), ...(msgText ? { persist_user_message: msgText } : {}), ...(opts.ephemeral ? { ephemeral: true } : {}),
             }, {
                 signal: controller.signal,
                 timeoutMs: 0,
@@ -392,10 +473,12 @@ export class TurnRunner {
                             partialText.push(str(data.text));
                             if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
                                 heldText += str(data.text);
+                                meterDelta();
                                 return;
                             }
                             put('token', { text: heldText + str(data.text) });
                             heldText = '';
+                            meterDelta();
                             return;
                         }
                         case 'reasoning': {
@@ -404,6 +487,16 @@ export class TurnRunner {
                             reasoningText.push(str(data.text));
                             // Python `reasoning_event_payload`: bold or first-line titles ride on the delta they complete.
                             put('reasoning', titles.prepare(reasoningEventPayload(str(data.text), reasoningText.join(''))));
+                            meterDelta();
+                            return;
+                        }
+                        case 'usage': {
+                            const usage = ChatUsageSchema.safeParse(data);
+                            if (usage.success) {
+                                applyAgentUsage(liveUsage, usage.data);
+                                this.liveUsage.set(streamId, liveUsage);
+                            }
+                            putMetering(true);
                             return;
                         }
                         case 'steer_pending':
@@ -424,20 +517,36 @@ export class TurnRunner {
                             return;
                         }
                         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;
+                            // 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, todo_result: todoResult, result_diff: resultDiff, ...complete } = data;
+                            const outcome = toolOutcome(rawResult);
+                            complete.is_error = outcome.is_error;
+                            if (rawResult !== undefined)
+                                complete.result_view = outcome.result_view;
+                            // TAL-448: a file edit's change, counted over the whole diff the sidecar forwards; redacted with the frame.
+                            const editDiff = toolEditDiff(data.name, { diff: resultDiff });
+                            if (editDiff)
+                                complete.edit_diff = editDiff;
                             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 } : {}), ...(editDiff ? { edit_diff: editDiff } : {}) });
                             }
                             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 });
+                            // TAL-397: the todo tool's result is the session's new list; the settled session derives the same one.
+                            const todos = data.name === 'todo' ? parseTodoToolResult(todoResult) : null;
+                            if (todos) {
+                                todos.ts = deps.now();
+                                this.liveTodos.set(streamId, todos);
+                                put('todo_state', redactNestedMessageContainers({ ...todos, session_id: sessionId, stream_id: streamId, source: 'live' }, redacted));
+                            }
                             return;
                         }
                         // Python: the live chat frame carries the queue head plus depth, not the entry that just arrived.
@@ -447,6 +556,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);
@@ -470,33 +587,21 @@ export class TurnRunner {
                 },
             });
             settledAt.value = true;
+            // TAL-545: every transcript the Agent hands back settles with the history's images, not the request's projection.
+            const withImages = (rows) => withNativeImagesRestored(rows, conversationHistory, apiHistory);
+            result.messages = withImages(result.messages);
+            if (result.context_messages)
+                result.context_messages = withImages(result.context_messages);
             if (this.registry.cancelled.has(streamId) || result.status === 'cancelled') {
                 // 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);
+                applyAgentUsage(liveUsage, result.usage);
+                this.liveUsage.set(streamId, liveUsage);
+                this.finalizeCancelled(s, streamId, opts.ephemeral, interrupted?.checkpoint ? withImages(interrupted.checkpoint) : result.messages);
                 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 {
@@ -512,18 +617,23 @@ export class TurnRunner {
             s = current;
             // Python `_maybe_inject_max_iteration_summary_fallback`: an exhausted tool budget leaves the closing
             // explanation in `final_response` only, so it becomes the turn's assistant answer before anything else reads it.
-            const resultMessages = result.tool_limit_reached ? injectMaxIterationSummaryFallback(result.messages, result.final_response) : result.messages;
+            const withFallback = (rows) => (result.tool_limit_reached ? injectMaxIterationSummaryFallback(rows, result.final_response) : rows);
+            const withoutRequest = (rows) => (result.tool_limit_reached ? withoutMaxIterationSummaryRequest(rows, result.max_iterations_summary_request, msgText) : rows);
+            const agentRows = withFallback(result.messages);
+            const resultMessages = withoutRequest(agentRows);
             // Python `_assistant_reply_added_after_current_turn`: replayed history never counts as this turn's answer (the
             // 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, attachments: opts.attachments ?? [] });
-            const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
+            // 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 is sent next.
@@ -531,8 +641,10 @@ export class TurnRunner {
                 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());
+                this.persistError(s, streamId, classification.label, payload, activeTurnToken, resultMessages);
+                // 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)
@@ -541,21 +653,57 @@ 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 = resultMessages.length - 1; i >= 0; i -= 1) {
+                    const m = resultMessages[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: resultMessages.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 ──
+            // TAL-539: after a mid-turn compression the model context is the sidecar's pruned copy, settled like the transcript.
+            const pruned = result.compressed ? result.context_messages ?? null : null;
+            const context = withoutToolImages(pruned ? withoutRequest(withFallback(pruned)) : resultMessages);
+            let estimate = result.compressed ? result.post_compression_context_tokens_estimate ?? null : null;
+            // The sidecar estimated its own rows; a tool-limit settlement or stripped screenshots (TAL-544) that changed them move
+            // the estimate by the difference.
+            if (pruned && estimate !== null && context !== pruned) {
+                try {
+                    const [before, after] = await Promise.all([pruned, context].map((messages) => sidecar.call('models.estimate_tokens', { messages })));
+                    estimate = Math.max(1, estimate + after.tokens - before.tokens);
+                }
+                catch {
+                    estimate = null;
+                }
+            }
             // The Agent's last pending-steer text settles the remaining steers before the turn is written back.
             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);
-            }
+            s.messages = withoutToolImages(mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] }));
+            s.context_messages = dedupeContext(context);
             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' });
+                s.post_compression_context_tokens_estimate = estimate;
+                // TAL-540: the anchor is the last visible row before this turn (never its eager checkpoint); the merged transcript
+                // holds no compaction marker, so the summary is the model context's newest one.
+                const before = visibleMessagesForAnchor(previousMessages.filter((m) => m._turn_id !== streamId));
+                const after = visibleMessagesForAnchor(s.messages);
+                const anchorIdx = before.length ? before.length - 1 : after.length ? 0 : null;
+                s.compression_anchor_visible_idx = anchorIdx;
+                s.compression_anchor_message_key = anchorMessageKey(anchorIdx !== null && anchorIdx < after.length ? after[anchorIdx] : after.at(-1));
+                s.compression_anchor_summary = markerSummary(s.context_messages);
             }
             const now = deps.now();
             for (const m of s.messages)
@@ -565,22 +713,21 @@ export class TurnRunner {
             const usage = result.usage;
             const prevInputTokens = s.input_tokens || 0;
             const prevCacheReadTokens = s.cache_read_tokens || 0;
-            if (usage.prompt_tokens > 0)
-                s.input_tokens = usage.prompt_tokens;
-            if (usage.completion_tokens > 0)
-                s.output_tokens = usage.completion_tokens;
-            if (usage.estimated_cost_usd !== null)
-                s.estimated_cost = usage.estimated_cost_usd;
-            if (usage.cache_read_tokens > 0)
-                s.cache_read_tokens = usage.cache_read_tokens;
-            if (usage.cache_write_tokens > 0)
-                s.cache_write_tokens = usage.cache_write_tokens;
+            applyAgentUsage(s, usage);
             if (typeof result.context.context_length === 'number')
                 s.context_length = result.context.context_length;
             if (typeof result.context.threshold_tokens === 'number')
                 s.threshold_tokens = result.context.threshold_tokens;
             if (typeof result.context.last_prompt_tokens === 'number')
                 s.last_prompt_tokens = result.context.last_prompt_tokens;
+            if (result.compressed) {
+                // TAL-540, Python `_live_usage_snapshot`: the counters and the ring's post-compression figures, so clients update before `done`.
+                const usage = {
+                    ...meteringUsage(s), context_length: s.context_length ?? 0, threshold_tokens: s.threshold_tokens ?? 0, last_prompt_tokens: s.last_prompt_tokens ?? 0,
+                    post_compression_context_tokens_estimate: s.post_compression_context_tokens_estimate, ...contextUsage(s, () => deps.service().deps.contextLengthFor(s.model, s.model_provider)),
+                };
+                put('compressed', { session_id: sessionId, old_session_id: sessionId, new_session_id: sessionId, continuation_session_id: sessionId, message: 'Compression finished', usage });
+            }
             s.tool_calls = extractToolCallsFromMessages(s.messages, liveToolCalls, s.tool_calls);
             s.active_stream_id = null;
             s.pending_user_message = null;
@@ -611,12 +758,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();
@@ -637,6 +784,9 @@ export class TurnRunner {
                 }
             }
             this.persistConsumedSteers(s, streamId, previousStartedAt(s, activeRun), now);
+            // TAL-493: the rows this turn's Agent wrote to state.db are now in the transcript, so the merge must not replay them
+            // (all of them, the dropped summary request too).
+            deps.service().settleStateDb(s, { turnId: streamId, previousContext: this.stopContexts.get(streamId)?.previousContext ?? previousContext, agentRows, startId: this.stopContexts.get(streamId)?.stateDbStartId ?? null });
             deps.store.save(s);
             deps.pending.clearApprovals(sessionId);
             deps.pending.clearClarifies(sessionId);
@@ -681,6 +831,8 @@ export class TurnRunner {
             };
             if (result.tool_limit_reached)
                 donePayload.terminal_reason = 'max_iterations';
+            // TAL-397: the live meter ends on the persisted counters and turn rate.
+            put('metering', { session_id: sessionId, usage: meteringUsage(s), tps: doneUsage.tps ?? null, tps_available: doneUsage.tps !== undefined, estimated: false });
             put('done', donePayload);
             for (const [event, payload] of steerEvents)
                 put(event, payload);
@@ -690,22 +842,16 @@ export class TurnRunner {
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
             this.startSteerFollowUp(sessionId, leftovers);
-            await this.backgroundTitle(s, put);
+            // Before the title work, so a generated title's own state.db sync lands after this one's provisional title.
+            await deps.syncUsage?.(s, usedModel || null);
+            // 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)) {
@@ -737,7 +883,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) {
@@ -757,45 +904,49 @@ export class TurnRunner {
         }
     }
     /**
-     * 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. 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.
+     * Python `_resolve_image_input_mode`: the Agent's image mode for this turn's model under its profile config, or null
+     * when it is unknown (no sidecar, a cancel, a failed lookup). A canonical "text" is honoured only with an explicit
+     * text signal or a model KNOWN to be text-only; an unknown/custom model forwards natively and lets the Agent's retry
+     * guard downgrade.
      */
-    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 withFiles();
+    async imageInputMode(sessionId, s, opts, signal) {
         const sidecar = this.deps.sidecar();
-        if (!sidecar)
-            return withFiles();
         // A cancel that landed before this point is final: never start the lookup or wait on it.
-        if (signal.aborted)
-            return text;
+        if (!sidecar || signal.aborted)
+            return null;
+        // The session's provider before the Agent canonicalizes it, so a `custom:<name>` override entry still matches.
+        const provider = str(opts.modelProvider ?? s.model_provider);
         try {
             // A cancelled turn must not sit behind this lookup: the abort wins the race and `run()` then takes the cancelled path.
-            const lookup = sidecar.call('text.image_mode', { profile_home: this.deps.profileHome(s.profile), provider: str(opts.modelProvider ?? s.model_provider), model: str(opts.model ?? s.model) }, { signal, timeoutMs: IMAGE_MODE_TIMEOUT_MS });
+            const lookup = sidecar.call('text.image_mode', { profile_home: this.deps.profileHome(s.profile), provider, model: str(opts.model ?? s.model), requested_provider: provider }, { signal, timeoutMs: IMAGE_MODE_TIMEOUT_MS });
             const mode = await Promise.race([lookup, new Promise((_, reject) => { if (signal.aborted) {
                     reject(new Error('turn cancelled'));
                     return;
                 } signal.addEventListener('abort', () => { reject(new Error('turn cancelled')); }, { once: true }); })]);
-            // Python `_resolve_image_input_mode`: a canonical "text" is honoured only with an explicit text signal or a model
-            // KNOWN to be text-only; an unknown/custom model forwards natively and lets the Agent's retry guard downgrade.
-            if (mode.mode !== 'native') {
-                const cfg = (await this.deps.profileConfig?.(s.profile ?? null)) ?? {};
-                if (explicitTextSignal(cfg) || mode.supports_vision === false)
-                    return withFiles();
-            }
+            if (mode.mode === 'native')
+                return 'native';
+            const cfg = (await this.deps.profileConfig?.(s.profile ?? null)) ?? {};
+            return explicitTextSignal(cfg) || mode.supports_vision === false ? 'text' : 'native';
         }
         catch (error) {
             if (!signal.aborted)
                 this.deps.log(`[webui] image mode lookup failed for ${sessionId}: ${error.message}`);
-            return withFiles();
+            return null;
         }
+    }
+    /**
+     * Python `_build_user_message`: image attachments are embedded as native `image_url` parts only when the turn's
+     * image mode 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. 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.
+     */
+    buildUserMessage(workspaceCtx, msgText, attachments, workspace, sessionId, imageMode) {
+        const text = workspaceCtx + msgText;
+        const withFiles = () => attachedFilesPrompt(text, attachments);
+        const candidates = attachments.filter(isImageAttachment);
+        if (!candidates.length || imageMode !== 'native')
+            return withFiles();
         const parts = [];
         let images = 0;
         const roots = [workspace, this.deps.attachmentDir(sessionId)].map((r) => resolvePathLikePython(r));
@@ -835,21 +986,24 @@ export class TurnRunner {
      * msg_limit=` (renderable rows, limited payload shape, windowed tool calls, todo state) with the full count.
      */
     terminalSessionPayload(s) {
-        const payload = withSessionWireFlags(s.compact({ contextLengthFor: this.deps.service().deps.contextLengthFor }), this.registry.liveIds);
+        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);
-        const scened = withBodyExcerpts(this.deps.service().backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withTurnIds(withAttachmentObjects(s.messages)), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true })), s.active_stream_id);
+        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;
         payload._messages_truncated = offset > 0;
-        attachTodoState(payload, s.messages);
+        attachTodoState(payload, s.messages, s.extra[UNSETTLED_TODO_KEY]);
         payload.tool_calls = toolCallsForMessageWindow(s.tool_calls, offset, limited.length);
+        payload.compression_reference = compressionReference(s, scened);
         return payload;
     }
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
-    persistError(s, streamId, label, payload, activeTurnToken) {
+    persistError(s, streamId, label, payload, activeTurnToken, agentRows = []) {
         const startedAt = s.pending_started_at;
         this.materializePendingUserTurn(s, activeTurnToken, streamId);
         const duration = typeof startedAt === 'number' && startedAt > 0 ? Math.max(0, this.deps.now() - startedAt) : null;
@@ -879,13 +1033,18 @@ export class TurnRunner {
         else if (payload.type === 'interrupted')
             errorMessage.provider_details_label = 'Interruption details';
         s.messages.push(errorMessage);
+        this.keepLiveState(s, streamId);
         this.persistConsumedSteers(s, streamId, startedAt, this.deps.now());
+        const stop = this.stopContexts.get(streamId);
+        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null });
         try {
             this.deps.store.save(s);
         }
         catch (error) {
             this.deps.log(`[webui] WARNING: failed to save error turn for ${s.session_id}: ${error.message}`);
         }
+        // The kept live counters are the session's usage now, so the insights row follows them (the runtime logs failures).
+        void this.deps.syncUsage?.(s, str(s.model) || null);
         this.deps.pending.clearApprovals(s.session_id);
         this.deps.pending.clearClarifies(s.session_id);
         this.deps.events.publish('session_error', { profile: s.profile, sessionId: s.session_id });
@@ -974,8 +1133,19 @@ export class TurnRunner {
         // 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)
+        if (quiet && current.active_stream_id === null) {
+            // TAL-493: rows its worker committed while unwinding are covered by what it reports; others are kept.
+            if (checkpoint) {
+                this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: this.stopContexts.get(streamId)?.previousContext ?? [], agentRows: checkpoint, startId: this.stopContexts.get(streamId)?.stateDbStartId ?? null });
+                try {
+                    this.deps.store.save(current);
+                }
+                catch {
+                    return false;
+                }
+            }
             return true;
+        }
         const stop = this.stopContexts.get(streamId);
         const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
         const settle = () => {
@@ -989,9 +1159,13 @@ export class TurnRunner {
             // 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) {
+            const ownStop = current.messages.some((m) => isCancelMarker(m) && m._turn_id === streamId);
+            const late = canonical && !stop.checkpointed && ownStop ? settle() : null;
+            if (late)
                 current.context_messages = dedupeContext(late);
+            // TAL-493: the worker's rows committed after the first settlement are covered by what it reports; others are kept.
+            if (late || (ownStop && checkpoint)) {
+                this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null });
                 try {
                     this.deps.store.save(current);
                 }
@@ -1015,13 +1189,16 @@ export class TurnRunner {
             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.keepLiveState(current, streamId);
         this.persistConsumedSteers(current, streamId, startedAt, this.deps.now());
+        this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null });
         try {
             this.deps.store.save(current);
         }
         catch {
             return false;
         }
+        void this.deps.syncUsage?.(current, str(current.model) || null);
         this.deps.pending.clearApprovals(current.session_id);
         this.deps.pending.clearClarifies(current.session_id);
         this.deps.events.publish('session_cancel', { profile: current.profile, sessionId: current.session_id });
@@ -1031,7 +1208,18 @@ export class TurnRunner {
     emitToSession(sessionId, event, data) {
         this.sessionPuts.get(sessionId)?.(event, data);
     }
+    /** TAL-397: a turn that ends without its result keeps what the live stream already showed: counters and todo list. */
+    keepLiveState(s, streamId) {
+        const usage = this.liveUsage.get(streamId);
+        if (usage)
+            Object.assign(s, usage);
+        const todos = this.liveTodos.get(streamId);
+        if (todos)
+            s.extra[UNSETTLED_TODO_KEY] = todos;
+    }
     teardown(sessionId, streamId) {
+        this.liveUsage.delete(streamId);
+        this.liveTodos.delete(streamId);
         const writer = this.writers.get(streamId);
         if (writer) {
             try {
@@ -1099,13 +1287,14 @@ export class TurnRunner {
         }
         return { title: '', status, rawPreview: '' };
     }
-    /** Python `generate_session_title_for_session`: on-demand title from the persisted transcript; never touches `llm_title_generated`. */
+    /**
+     * Python `generate_session_title_for_session`: on-demand title from the persisted transcript; never touches
+     * `llm_title_generated`. An explicit regenerate runs even with `auxiliary.title_generation.enabled` off (TAL-531).
+     */
     async generateTitle(s, opts = {}) {
         const [userText, assistantText] = opts.preferLatest ? latestExchangeSnippets(s.messages) : firstExchangeSnippets(s.messages, { scanPastConsecutiveUsers: true });
         if (!userText)
             return { title: null, status: 'empty_user_message', rawPreview: '' };
-        if (!this.deps.titleGenerationEnabled())
-            return { title: null, status: 'title_generation_disabled', rawPreview: '' };
         let next = '';
         let llmStatus = 'empty_assistant_message';
         let rawPreview = '';
@@ -1131,65 +1320,66 @@ export class TurnRunner {
         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;
+        }
+        // A missing config.yaml reads as `{}` (enabled); an unreadable one cannot confirm the user has not opted out.
+        const cfg = await this.deps.profileConfig?.(s.profile ?? null);
+        if (!cfg) {
+            status('skipped', 'config_unavailable', placeholder);
+            return;
+        }
+        if (!titleGenerationEnabled(cfg)) {
+            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';
-                }
+            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;
             }
-            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;
-                }
-                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 });
-            }
-            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 ───────────────────────────────────────────────────────
     /**
@@ -1503,6 +1693,60 @@ export class TurnRunner {
         }
         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 }))
@@ -1645,6 +1889,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');
@@ -1656,8 +1901,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) {
@@ -1680,10 +1930,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)
@@ -1736,6 +2010,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);
 }
@@ -1743,18 +2029,6 @@ function previousStartedAt(s, run) {
 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;
-    for (const m of messages) {
-        const key = messageIdentity(m);
-        if (key !== null && key === lastKey && m.role === 'assistant')
-            continue;
-        out.push(m);
-        lastKey = key;
-    }
-    return out;
-}
 export { HttpFailure };
 /** Where a consumed steer goes: past the tool results of the call it followed, else past the turn's prompt. */
 function roundDuration(seconds) {