@maudecode/talaria-web 1.16.1 → 1.18.0

package/dist/sessions/turn.js

@@ -12,29 +12,54 @@ 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 { COMPRESSION_RECOVERY_ACTION_START_FOCUSED, COMPRESSION_RECOVERY_TERMINAL_STATE, 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, splitDisplayText, joinReasoning, reasoningFieldsText, stoppedTurnContext, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, 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, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, 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 { countExchanges, fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
 import { WORKSPACE_BUSY_MESSAGE } from '../workspace/git.js';
+import { CHECKPOINT_STORE_BUSY_MESSAGE } from '../workspace/rollback.js';
 import { str } from '../util.js';
+import { toolEditDiff } from './tool-display.js';
+import { recordWakeupPause } from './wakeup-pause.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();
@@ -48,7 +73,7 @@ export function classifyProviderError(errStr, opts = {}) {
     if (['interrupted by user', 'response interrupted', 'operation interrupted', 'operation was interrupted', 'operation aborted', 'request was aborted', 'aborterror'].some((k) => lower.includes(k))) {
         return { label: 'Response interrupted', type: 'interrupted', hint: 'The run stopped before a provider response completed. If you did not cancel it, try again.' };
     }
-    const quota = ['insufficient_quota', 'insufficient credits', 'out of credits', 'credits exhausted', 'quota exceeded', 'usage limit', 'plan limit', 'billing'].some((k) => lower.includes(k));
+    const quota = ['insufficient_quota', 'insufficient credits', 'out of credits', 'credits exhausted', 'quota exceeded', 'usage limit', 'plan limit', 'billing', 'more credits', 'can only afford', 'fewer max_tokens', 'credit balance', 'exceeded your current quota', 'usage_limit_exceeded', 'reached the limit of messages', 'used up your usage'].some((k) => lower.includes(k));
     const poolEmpty = lower.includes('credential(s) exhausted') || lower.includes('credentials exhausted') || (lower.includes('credential') && lower.includes('exhausted'));
     const auth = !quota && !poolEmpty && (errStr.includes('401') || lower.includes('authentication') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('invalid_api_key') || lower.includes('no cookie auth credentials'));
     const notFound = errStr.includes('404') || lower.includes('not found') || lower.includes('does not exist') || lower.includes('model_not_found') || lower.includes('invalid model') || lower.includes('does not match any known model') || lower.includes('unknown model');
@@ -102,8 +127,6 @@ export function sniffImageMime(bytes, declared = '') {
         return 'image/bmp';
     return null;
 }
-const COMPRESSION_RECOVERY_TERMINAL_STATE = 'compression_exhausted';
-const COMPRESSION_RECOVERY_ACTION_START_FOCUSED = 'start_focused_continuation';
 /** Python `build_compression_recovery_payload` + `stamp_compression_exhausted_recovery`. */
 export function stampCompressionExhaustedRecovery(s, message, details) {
     const positive = (v) => { const n = Math.trunc(Number(v) || 0); return n > 0 ? n : 0; };
@@ -137,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')
@@ -162,8 +205,14 @@ 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();
+    /** The last adaptive title refresh per session; a successor turn's refresh runs after it (TAL-589). */
+    titleRefreshes = new Map();
     /**
      * TAL-364: what a Stop needs to write the turn's model context: its starting context, the prompt the Agent got, and
      * whether a settlement already used a canonical checkpoint (which marks the stop boundary; later work never replaces it).
@@ -187,6 +236,8 @@ export class TurnRunner {
             return { error: `Profile '${str(s.profile)}' is being deleted.`, _status: 409 };
         if (this.deps.workspaceBusy?.(opts.workspace))
             return { error: WORKSPACE_BUSY_MESSAGE, _status: 409 };
+        if (this.deps.checkpointStoreBusy?.(s.profile ?? null))
+            return { error: CHECKPOINT_STORE_BUSY_MESSAGE, _status: 409 };
         const locked = s.active_stream_id;
         if (locked) {
             if (this.registry.liveIds.has(locked) || this.registry.activeRuns.has(locked))
@@ -244,6 +295,10 @@ export class TurnRunner {
             response.effective_model_provider = opts.modelProvider;
         return response;
     }
+    /** Resolves once the stream's worker has ended (settled, failed, or torn down); it never rejects. */
+    finished(streamId) {
+        return this.workers.get(streamId) ?? Promise.resolve();
+    }
     /** Python `_checkpoint_user_message_for_eager_session_save`. */
     checkpointUserMessage(s, msg, attachments, startedAt, source, turnId) {
         const latest = s.messages[s.messages.length - 1];
@@ -262,7 +317,12 @@ export class TurnRunner {
         catch (error) {
             deps.log(`[webui] WARNING: run journal degraded for stream ${streamId}: ${error.message}`);
         }
+        const failure = { apperror: null, cancelled: false };
         const put = (event, data, meta = {}) => {
+            if (event === 'apperror')
+                failure.apperror = data;
+            else if (event === 'cancel')
+                failure.cancelled = true;
             for (const steerEvent of this.takeSteerEventsBefore(streamId, event))
                 put(steerEvent[0], steerEvent[1]);
             if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn'].includes(event))
@@ -309,13 +369,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);
-        const workspaceCtx = workspaceContextPrefix(opts.workspace);
+        // TAL-493: one state.db read builds the history and marks where this turn's own rows begin.
+        const startRead = deps.service().stateDbRead(s);
+        // TAL-578: an eager save already put this turn's prompt in the transcript; `user_message` carries it, so the history
+        // leaves it out.
+        const previousContext = structuredClone(deps.service().modelContext(s, startRead.rows)).filter((m) => m._turn_id !== streamId);
+        // 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 });
         // 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, historyLength: apiHistory.length, prompt: 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) ?? [];
@@ -329,6 +392,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.
@@ -338,7 +420,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(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)
@@ -346,14 +433,15 @@ export class TurnRunner {
         if (activeRun)
             activeRun.phase = 'running';
         const settledAt = { value: false };
-        let failed = false;
+        let succeeded = 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' });
             // Python: budgets, reasoning config, personality and delivery context come from the profile's config.yaml; the
-            // system message carries the frozen session workspace, the WebUI guidance rides as the ephemeral prompt.
+            // system message carries the frozen session workspace, the WebUI guidance rides as the ephemeral prompt with this
+            // turn's workspace (TAL-710: never a tag on the user's message, which the Agent can persist from memory).
             const cfg = (await deps.profileConfig?.(s.profile ?? null)) ?? {};
             // The sidecar's per-session YOLO state does not survive its restarts: push the local flag (either way) before
             // the turn so a stale sidecar-side enable cannot auto-approve a session the UI reports as guarded.
@@ -368,10 +456,9 @@ export class TurnRunner {
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
-            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', background: turnOrigin(opts.source) === 'background' }),
+                system_message: workspaceSystemMessage(str(s.created_workspace) || str(s.workspace)),
+                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personality: str(s.personality) || null, sessionId, profile: s.profile ?? null, workspace: opts.workspace, 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),
@@ -382,7 +469,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,
@@ -399,10 +486,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': {
@@ -411,6 +500,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':
@@ -433,23 +532,34 @@ export class TurnRunner {
                         case 'tool_complete': {
                             // 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;
+                            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;
                                 // 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 } : {}) });
+                                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.
@@ -490,11 +600,18 @@ 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;
             }
@@ -513,7 +630,10 @@ 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
@@ -534,31 +654,31 @@ 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);
+                this.persistError(s, streamId, classification.label, payload, activeTurnToken, resultMessages, result.provider);
                 // 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 = this.publicTerminalSession(s);
                 payload.session_id = s.session_id;
                 payload.old_session_id = sessionId;
                 for (const [event, data] of steerEvents)
                     put(event, data);
                 put('apperror', payload);
-                failed = true;
                 return;
             }
             // 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];
+                for (let i = resultMessages.length - 1; i >= 0; i -= 1) {
+                    const m = resultMessages[i];
                     if (m.role === 'assistant') {
                         answer = str(m.content);
                         break;
                     }
                 }
+                succeeded = true;
                 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' });
+                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 });
                 }
@@ -567,14 +687,36 @@ export class TurnRunner {
                 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);
+            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)
@@ -584,28 +726,29 @@ 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;
             s.pending_attachments = [];
             s.pending_started_at = null;
             s.pending_user_source = null;
+            // TAL-576: a turn that ran means the provider has usable credentials again.
+            s.process_wakeup_pause = null;
             const attachments = opts.attachments ?? [];
             if (attachments.length) {
                 for (let i = s.messages.length - 1; i >= 0; i -= 1) {
@@ -656,6 +799,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);
@@ -682,7 +828,7 @@ 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());
+            const doneSession = this.publicTerminalSession(s);
             // 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];
@@ -700,6 +846,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);
@@ -709,20 +857,21 @@ export class TurnRunner {
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
             this.startSteerFollowUp(sessionId, leftovers);
+            // 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)".
-            opts.onDone?.(lastAnswer(s.messages) || '(no answer produced)');
+            succeeded = true;
+            opts.onDone?.(lastAnswer(s.messages));
         }
         catch (error) {
             if (settledAt.value && !(error instanceof SidecarError)) {
                 deps.log(`[webui] ERROR settling turn ${streamId}\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
             }
-            failed = true;
             if (this.registry.cancelled.has(streamId)) {
                 this.finalizeCancelled(s, streamId, opts.ephemeral);
                 put('cancel', this.cancelFrame(sessionId));
@@ -749,7 +898,7 @@ export class TurnRunner {
                         put(event, data);
                     this.persistError(current, streamId, classification.label, payload, activeTurnToken);
                     if (!opts.ephemeral)
-                        payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
+                        payload.session = this.publicTerminalSession(current);
                 }
             }
             catch (persistError) {
@@ -763,51 +912,54 @@ export class TurnRunner {
             this.teardown(sessionId, streamId);
             // After persistence and teardown: a background route's failure cleanup deletes the hidden session, which must
             // not race the error writeback above (a re-saved session would resurface in the sidebar).
-            if (failed)
-                opts.onFailed?.();
+            if (!succeeded)
+                opts.onFailed?.(failure);
             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. 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(msgText, attachments, workspace, sessionId, imageMode) {
+        const withFiles = () => attachedFilesPrompt(msgText, 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));
@@ -842,6 +994,10 @@ export class TurnRunner {
         }
         return images ? [{ type: 'text', text: withFiles() }, ...parts] : withFiles();
     }
+    /** The settled session as a terminal frame carries it: the display window, redacted. */
+    publicTerminalSession(s) {
+        return redactSessionData(this.terminalSessionPayload(s), this.deps.redactEnabled());
+    }
     /**
      * 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.
@@ -858,13 +1014,28 @@ export class TurnRunner {
         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) {
+    /** `runtimeProvider`: the provider the Agent resolved for the turn, when it reported one. */
+    persistError(s, streamId, label, payload, activeTurnToken, agentRows = [], runtimeProvider = '') {
         const startedAt = s.pending_started_at;
+        // TAL-576: an automatic wakeup with no usable credentials pauses the next ones instead of failing each.
+        if (s.pending_user_source === 'process_wakeup' && payload.type === 'credential_pool_empty') {
+            // A profile whose home now escapes the profiles root (`profileHome` throws) records no pause; the error still persists.
+            let home = null;
+            try {
+                home = this.deps.profileHome(s.profile);
+            }
+            catch {
+                home = null;
+            }
+            if (home !== null)
+                recordWakeupPause(s, home, this.deps.now(), runtimeProvider, this.deps.configPath?.(home));
+        }
         this.materializePendingUserTurn(s, activeTurnToken, streamId);
         const duration = typeof startedAt === 'number' && startedAt > 0 ? Math.max(0, this.deps.now() - startedAt) : null;
         s.active_stream_id = null;
@@ -893,17 +1064,40 @@ 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());
+        // TAL-921: the next prompt remembers the turn's work; an exhausted compression's work would only overflow again. One
+        // read builds the context and settles, so a row committed in between is never covered without reaching either.
+        const read = this.deps.service().stateDbRead(s);
+        const context = payload.type === 'compression_exhausted' ? null : this.unsettledContext(streamId, agentRows, read);
+        if (context)
+            s.context_messages = context;
+        const stop = this.stopContexts.get(streamId);
+        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null, read });
         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 });
     }
+    /**
+     * TAL-921: the model context a turn that ends without its settled result leaves: the work its Agent reported, else the
+     * rows it committed past its starting read in `read`, the read its settlement uses.
+     */
+    unsettledContext(streamId, agentRows, read) {
+        const stop = this.stopContexts.get(streamId);
+        if (!stop)
+            return null;
+        const after = stop.stateDbStartId;
+        const stateRows = after === null ? [] : read.rows.filter((m) => typeof m._state_db_row_id === 'number' && m._state_db_row_id > after);
+        return this.deps.service().unsettledTurnContext({ ...stop, streamedText: (this.registry.partialText.get(streamId) ?? []).join(''), agentRows, stateRows });
+    }
     materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
         if (!s.hasPendingPrompt)
@@ -953,7 +1147,7 @@ export class TurnRunner {
         let snapshot = null;
         if (sessionId)
             try {
-                snapshot = redactSessionData(this.terminalSessionPayload(this.deps.store.get(sessionId)), this.deps.redactEnabled());
+                snapshot = this.publicTerminalSession(this.deps.store.get(sessionId));
             }
             catch {
                 snapshot = null;
@@ -988,24 +1182,41 @@ 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 = () => {
+        // TAL-921: one state.db read builds the context and settles the turn.
+        const settle = (read) => {
             if (!stop)
                 return null;
             if (canonical)
                 stop.checkpointed = true;
-            return stoppedTurnContext(stop.previousContext, checkpoint, stop.prompt, stop.msgText, (this.registry.partialText.get(streamId) ?? []).join(''), stop.historyLength);
+            return this.unsettledContext(streamId, checkpoint, read);
         };
         if (current.messages.some((m) => isCancelMarker(m)) && current.active_stream_id === null && !current.pending_user_message) {
             // The worker's canonical result can arrive after cancel() settled without a checkpoint (the interrupt reply failed
             // or timed out): it replaces this stream's context and never adds a second Stop row. A settlement that already had
             // one keeps it, so work the Agent finished after the Stop stays out.
-            const late = canonical && !stop.checkpointed && current.messages.some((m) => isCancelMarker(m) && m._turn_id === streamId) ? settle() : null;
-            if (late) {
-                current.context_messages = dedupeContext(late);
+            const ownStop = current.messages.some((m) => isCancelMarker(m) && m._turn_id === streamId);
+            // TAL-493: the worker's rows committed after the first settlement are covered by what it reports; others are kept.
+            if (ownStop && checkpoint) {
+                const read = this.deps.service().stateDbRead(current);
+                const late = canonical && !stop.checkpointed ? settle(read) : null;
+                if (late)
+                    current.context_messages = dedupeContext(late);
+                this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null, read });
                 try {
                     this.deps.store.save(current);
                 }
@@ -1017,7 +1228,8 @@ export class TurnRunner {
         }
         const startedAt = current.pending_started_at;
         this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at), streamId);
-        const context = settle();
+        const read = this.deps.service().stateDbRead(current);
+        const context = settle(read);
         if (context)
             current.context_messages = dedupeContext(context);
         current.active_stream_id = null;
@@ -1029,13 +1241,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, read });
         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 });
@@ -1045,7 +1260,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 {
@@ -1113,13 +1339,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 = '';
@@ -1132,6 +1359,15 @@ export class TurnRunner {
             return { title: fallback, status: `local_summary:${llmStatus}`, rawPreview };
         return { title: null, status: llmStatus || 'empty_title', rawPreview };
     }
+    /**
+     * TAL-591 (Python `_queue_generated_title_for_imported_session`): a CLI session a mutation claims while it still
+     * carries its default title gets the background title job at once instead of after its first WebUI turn.
+     */
+    async titleClaimed(s) {
+        if (!looksLikeDefaultCliTitle({ title: s.title, source_tag: s.source_tag, raw_source: s.raw_source, session_source: s.session_source, source_label: s.source_label }))
+            return;
+        await this.backgroundTitle(s, () => undefined).catch((error) => { this.deps.log(`[webui] imported session title failed for ${s.session_id}: ${error.message}`); });
+    }
     /** Python `_run_background_title_update` (spawned only when `_background_title_generation_inputs` is eligible). */
     async backgroundTitle(s, put) {
         const sessionId = s.session_id;
@@ -1145,13 +1381,22 @@ export class TurnRunner {
         const status = (status, reason = '', title = '', rawPreview = '') => {
             put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
         };
-        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
+        // Python ran the adaptive refresh only when the first-title job was not eligible.
+        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText) {
+            await this.refreshTitle(s, put, status);
             return;
+        }
         if (s.manual_title) {
             status('skipped', 'manual_title', placeholder);
             return;
         }
-        if (!this.deps.titleGenerationEnabled()) {
+        // 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;
         }
@@ -1172,6 +1417,9 @@ export class TurnRunner {
             current = this.deps.store.get(sessionId);
         }
         catch {
+            // A session deleted while the title prompt ran stays deleted.
+            if (this.deps.store.wasDeleted(sessionId))
+                return;
             current = s;
         }
         let effective = str(current.title).trim();
@@ -1200,6 +1448,71 @@ export class TurnRunner {
         else
             status('skipped', source || 'unchanged', effective, rawPreview);
     }
+    /**
+     * Python `_maybe_schedule_title_refresh` + `_run_background_title_refresh`: every N exchanges a generated title is
+     * regenerated from the latest exchange; a manual title is never touched.
+     */
+    async refreshTitle(s, put, status) {
+        const every = this.deps.titleRefreshEvery?.() ?? 0;
+        const exchanges = countExchanges(s.messages);
+        if (every <= 0 || exchanges <= 0 || exchanges % every !== 0)
+            return;
+        const [userText, assistantText] = latestExchangeSnippets(s.messages);
+        if (!userText || !assistantText)
+            return;
+        // Admission is released before title work, so an earlier turn's refresh may still be running: refreshes apply in
+        // turn order and each reads the title its predecessor wrote.
+        const sessionId = s.session_id;
+        const run = (this.titleRefreshes.get(sessionId) ?? Promise.resolve()).catch(() => undefined).then(() => this.applyTitleRefresh(sessionId, s, userText, assistantText, put, status));
+        this.titleRefreshes.set(sessionId, run);
+        try {
+            await run;
+        }
+        finally {
+            if (this.titleRefreshes.get(sessionId) === run)
+                this.titleRefreshes.delete(sessionId);
+        }
+    }
+    async applyTitleRefresh(sessionId, s, userText, assistantText, put, status) {
+        const read = () => { try {
+            return this.deps.store.get(sessionId);
+        }
+        catch {
+            return s;
+        } };
+        const latest = read();
+        const placeholder = str(latest.title).trim();
+        if (['Untitled', 'New Chat', ''].includes(placeholder) || latest.manual_title || !latest.llm_title_generated)
+            return;
+        const cfg = await this.deps.profileConfig?.(latest.profile ?? null);
+        if (!cfg || !titleGenerationEnabled(cfg)) {
+            status('refresh_skipped', cfg ? 'title_generation_disabled' : 'config_unavailable', placeholder);
+            return;
+        }
+        const { title: next, status: llmStatus, rawPreview } = await this.llmTitle(latest, userText, assistantText);
+        if (!next) {
+            status('refresh_skipped', llmStatus || 'empty', placeholder, rawPreview);
+            return;
+        }
+        const normalize = (value) => value.replace(/\s+/g, ' ').trim().toLowerCase();
+        if (normalize(next) === normalize(placeholder)) {
+            status('refresh_skipped', 'same_title', placeholder, rawPreview);
+            return;
+        }
+        const current = read();
+        // The user may have renamed the session while the title prompt ran.
+        if (current.manual_title || str(current.title).trim() !== placeholder) {
+            status('skipped', 'manual_title', str(current.title).trim());
+            return;
+        }
+        current.title = next;
+        markSessionTitleGenerated(current);
+        this.deps.store.save(current, { touchUpdatedAt: false });
+        await this.deps.syncTitle?.(current);
+        this.deps.events.publish('title', { profile: current.profile, sessionId });
+        status('refreshed', llmStatus, next, rawPreview);
+        put('title', { session_id: sessionId, title: next });
+    }
     // ── cancel / steer ───────────────────────────────────────────────────────
     /**
      * Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. `withdrawn` is the
@@ -1477,12 +1790,6 @@ export class TurnRunner {
             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, leftovers: [] };
     }
     /**
@@ -1709,7 +2016,9 @@ export class TurnRunner {
         const profileHome = this.deps.profileHome(s?.profile ?? null);
         let resolved = false;
         let withdrawn = false;
-        if (entry) {
+        if (entry?._injected === true)
+            resolved = Boolean(this.deps.pending.resolveApproval(sessionId, str(entry.approval_id)).entry);
+        else if (entry) {
             if (!sidecar)
                 return relayFailure('not running');
             try {
@@ -1811,6 +2120,11 @@ export class TurnRunner {
         const response = typeof reply === 'string' ? reply : clarifyReply(entry, reply);
         if (response === null)
             return { ok: false, invalid: true };
+        // A test-hook prompt has no parked Agent waiter: it is answered here.
+        if (entry._injected === true) {
+            this.deps.pending.resolveClarify(sessionId, str(entry.clarify_id));
+            return { ok: true, response };
+        }
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return { ok: false, error: 'The Agent sidecar is not running; retry in a moment.' };
@@ -1848,18 +2162,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) {