@maudecode/talaria-web 1.16.1 → 1.17.2

package/dist/sessions/turn.js

@@ -12,29 +12,52 @@ 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, 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, 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();
@@ -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,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();
     /**
@@ -309,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) ?? [];
@@ -329,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.
@@ -338,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)
@@ -382,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,
@@ -399,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': {
@@ -411,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':
@@ -433,23 +519,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 +587,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 +617,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,7 +641,7 @@ 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);
                 // 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());
@@ -549,8 +656,8 @@ export class TurnRunner {
             // 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;
@@ -558,7 +665,7 @@ export class TurnRunner {
                 }
                 opts.onDone?.(answer);
                 // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
-                put('done', { session: { session_id: sessionId, messages: (result.messages).map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer, 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 +674,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,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;
@@ -656,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);
@@ -700,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);
@@ -709,6 +842,8 @@ 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 });
@@ -769,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));
@@ -858,12 +997,13 @@ 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) {
+    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;
@@ -893,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 });
@@ -988,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 = () => {
@@ -1003,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);
                 }
@@ -1029,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 });
@@ -1045,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 {
@@ -1113,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 = '';
@@ -1151,7 +1326,13 @@ export class TurnRunner {
             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;
         }
@@ -1848,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) {