@maudecode/talaria-web 1.19.0 → 1.20.0

package/dist/sessions/turn.js

@@ -5,6 +5,7 @@
  * (Python `api/routes.py::_start_chat_stream_for_session`,
  * `api/streaming.py::_run_agent_streaming`, `cancel_stream`).
  */
+import { StartupTiming, timingOutcome } from '../startup-timing.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, fstatSync, readFileSync } from 'node:fs';
 import { openAnchoredFd } from '../workspace/fs.js';
@@ -12,33 +13,33 @@ import { isWithin, resolvePathLikePython } from '../workspace/paths.js';
 import { runtimeFailureDetails, SidecarError } from '../sidecar/client.js';
 import { HttpFailure, markSessionTitleGenerated } from './service.js';
 import { StreamRegistry, SessionChannels } from './streams.js';
-import { ChatUsageSchema, ConnectorOperationSnapshotSchema } from '@maudecode/talaria-web-contracts';
+import { TRANSCRIPT_WINDOW, ChatUsageSchema, ConnectorOperationSnapshotSchema } from '@maudecode/talaria-web-contracts';
+import { toolProgress } from './tool-display.js';
 import { catalogNames, connectorOperation } from '../tools/connectors.js';
 import { PendingPrompts, clarifyReply, isVaultPrompt, vaultReply } from './pending.js';
 import { COMPRESSION_RECOVERY_ACTION_START_FOCUSED, COMPRESSION_RECOVERY_TERMINAL_STATE, CONTEXT_USAGE_FIELDS, Session, contextUsage, forgetContextFigures, titleFrom } from './session.js';
-import { anchorMessageKey, compressionReference, markerSummary, visibleMessagesForAnchor } from './compress.js';
-import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactNestedMessageContainers, redactSessionData, redactString, withToolId } from '../redact.js';
+import { anchorMessageKey, markerSummary, visibleMessagesForAnchor } from './compress.js';
+import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactNestedMessageContainers, redactString, withToolId } from '../redact.js';
 import { dict, findPersonality } from '../config/agent-config.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
-import { messageWindowForDisplay, messagesForLimitedPayload, toolCallsForMessageWindow } from './window.js';
-import { UNSETTLED_TODO_KEY, attachTodoState, parseTodoToolResult } from './todo.js';
+import { UNSETTLED_TODO_KEY, parseTodoToolResult } from './todo.js';
 import { SessionNotices } from './notices.js';
 import { SessionGoals } from './goals.js';
-import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
+import { turnTerminalState } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { agentBuildParams, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, toolOutcome, withAttachmentObjects, newestSettledReply, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, withDataUseRequirements, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, toolOutcome, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
 import { mayBecomeSilentReply, turnOrigin, recordBackgroundReview, recordBackgroundUpdate } from './background-updates.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 { startsBackgroundWork } from './background-tasks.js';
 import { recordWakeupPause } from './wakeup-pause.js';
 import { displayName } from '../providers/catalog.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;
 /** The Agent's content frames, which end a rate-limit wait (TAL-821) and a compression span (TAL-1006). A terminal frame ends the run, its wait, and its span. */
@@ -227,6 +228,7 @@ export class TurnRunner {
     /**
      * TAL-364: what a Stop needs to write the turn's model context: its starting context, the prompt the Agent got, and
      * whether a settlement already used a canonical checkpoint (which marks the stop boundary; later work never replaces it).
+     * TAL-1162: `startReadPending` while the turn's starting state.db read is still in flight.
      */
     /** TAL-364: a Stop's in-flight `chat.interrupt` reply (null when it failed), so a worker that settles first can use its checkpoint. */
     interrupts = new Map();
@@ -344,6 +346,25 @@ export class TurnRunner {
     }
     /** Python `_start_chat_stream_for_session`: persist pending state, register the channel, launch the worker. */
     async admit(session, opts, releaseStopHold = false) {
+        const timing = opts.timing ?? new StartupTiming(this.deps.log);
+        timing.identify(session.session_id);
+        timing.begin('admission');
+        try {
+            const response = await this.admitTimed(session, { ...opts, timing }, releaseStopHold);
+            if (response._status !== undefined)
+                timing.finish('refused');
+            else if (!response.stream_id || !this.workers.has(response.stream_id))
+                timing.finish('noop');
+            return response;
+        }
+        catch (error) {
+            timing.finish(timingOutcome(error));
+            throw error;
+        }
+    }
+    async admitTimed(session, opts, releaseStopHold) {
+        const timing = opts.timing;
+        const closeChecks = timing.begin('admission_checks');
         const s = session;
         const readOnly = (await this.deps.service().readOnlyReason(s));
         if (readOnly)
@@ -371,9 +392,13 @@ export class TurnRunner {
         }
         const accepted = isDict(s.extra.completion_acceptances) ? s.extra.completion_acceptances : {};
         if (opts.completionKeys?.length && opts.completionKeys.every((key) => typeof accepted[key] === 'string' && accepted[key])) {
+            timing.identify(s.session_id, str(accepted[opts.completionKeys[0]]));
+            timing.finish('noop');
             return { stream_id: str(accepted[opts.completionKeys[0]]), session_id: s.session_id };
         }
+        closeChecks();
         const streamId = randomUUID().replace(/-/g, '');
+        timing.identify(s.session_id, streamId);
         const wasHiddenEmpty = !s.messages.length && !s.context_messages.length && !s.hasPendingPrompt;
         const attachments = opts.attachments ?? [];
         // A background wakeup stays one in a forked session too (TAL-460).
@@ -384,6 +409,9 @@ export class TurnRunner {
         const compactionDue = !opts.ephemeral && sameRuntime && this.deps.service().compactionDue(s);
         if (!sameRuntime)
             forgetContextFigures(s);
+        const notificationOwner = this.deps.notificationOwner();
+        if (notificationOwner)
+            s.extra.notification_owner = notificationOwner;
         s.workspace = opts.workspace;
         s.model = opts.model;
         s.model_provider = opts.modelProvider;
@@ -418,7 +446,7 @@ export class TurnRunner {
         const admission = { stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral), origin: turnOrigin(source), admitting: true };
         this.registry.registerActiveRun(admission);
         try {
-            (await this.deps.store.save(s));
+            await timing.measure('admission_persistence', () => this.deps.store.save(s));
         }
         catch (error) {
             this.registry.activeRuns.delete(streamId);
@@ -431,16 +459,22 @@ export class TurnRunner {
         // A new chat appears in the list; every turn tells open clients a run started (TAL-434).
         this.deps.events.publish(wasHiddenEmpty ? 'session_new' : 'turn_started', { profile: s.profile, sessionId: s.session_id });
         try {
-            (await this.deps.workspaces.setLastWorkspace(opts.workspace, s.profile));
+            this.deps.onTurnStart?.(s.session_id);
+        }
+        catch { /* best effort */ }
+        try {
+            await timing.measure('workspace_persistence', () => this.deps.workspaces.setLastWorkspace(opts.workspace, s.profile));
         }
         catch { /* best effort */ }
         const channel = this.registry.create(streamId, s.session_id);
         admission.admitting = false;
         if (opts.goalRelated)
             this.registry.goalRelated.add(streamId);
+        timing.end('admission');
         const worker = this.run(s.session_id, streamId, channel, opts, compactionDue).catch((error) => {
+            timing.finish(timingOutcome(error));
             this.deps.log(`[webui] ERROR turn ${streamId} crashed\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        }).finally(() => { this.workers.delete(streamId); });
+        }).finally(() => { timing.finish(this.registry.cancelled.has(streamId) ? 'cancelled' : undefined); this.workers.delete(streamId); });
         this.workers.set(streamId, worker);
         const response = { stream_id: streamId, session_id: s.session_id, pending_started_at: s.pending_started_at, turn_id: streamId, title: s.title };
         if (opts.normalizedModel && opts.model)
@@ -463,6 +497,8 @@ export class TurnRunner {
     // ── worker ───────────────────────────────────────────────────────────────
     async run(sessionId, streamId, channel, opts, compactionDue) {
         const { deps } = this;
+        const timing = opts.timing;
+        const closePreparation = timing?.begin('worker_preparation');
         let writer = null;
         try {
             writer = (await deps.journal.writer(sessionId, streamId));
@@ -485,8 +521,11 @@ export class TurnRunner {
             if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn', 'run_status'].includes(event))
                 return;
             const terminal = ['done', 'cancel', 'apperror', 'error', 'stream_end'].includes(event);
-            if (terminal)
+            if (terminal) {
                 statusEnded = true;
+                for (const call of this.registry.liveToolCalls.get(streamId) ?? [])
+                    delete call.progress;
+            }
             if (CONTENT_EVENTS.has(event) || terminal)
                 providerPhase = null;
             if (event === 'rate_limit_wait')
@@ -527,6 +566,7 @@ export class TurnRunner {
                 return;
             // `cancel()` already wrote the terminal row and closed the stream: the worker's unwind adds no second one.
             if (event === 'cancel' && !this.registry.streams.has(streamId)) {
+                timing?.frame(event, data);
                 try {
                     deps.onTerminal?.(streamId, 'cancelled');
                 }
@@ -534,7 +574,7 @@ export class TurnRunner {
                 return;
             }
             let eventId = null;
-            if (writer) {
+            if (writer && event !== 'tool_progress') {
                 try {
                     eventId = (await writer.appendSseEvent(event, data, meta)).event_id;
                 }
@@ -544,6 +584,7 @@ export class TurnRunner {
                 }
             }
             channel.put([event, data, eventId, meta.redacted]);
+            timing?.frame(event, data);
             if (event === 'done' || event === 'cancel' || event === 'apperror' || event === 'error') {
                 // Relay's phase follows the turn outcome, so a background Live Activity ends as the app would end it.
                 const state = str(data.terminal_state);
@@ -565,24 +606,27 @@ export class TurnRunner {
             await this.teardown(sessionId, streamId);
             return;
         }
+        const notificationScope = { owner: str(s.extra.notification_owner) || 'local-owner', profile: s.profile ?? 'default' };
         const msgText = opts.msg;
-        const history = () => {
+        const history = async () => {
             // TAL-493: one state.db read builds the history and marks where this turn's own rows begin.
-            const startRead = deps.service().beginStateDbTurn(s);
+            const reading = deps.service().beginStateDbTurn(s);
+            // TAL-1162: the read runs on the state.db worker. Until it lands, a Stop settles from the local history with no
+            // starting id, as a turn whose starting read failed does.
+            const local = this.turnHistory(s, streamId, []);
+            this.stopContexts.set(streamId, { previousContext: local.previousContext, historyLength: local.apiHistory.length, prompt: msgText, msgText, checkpointed: false, stateDbStartId: null, stateDbStartGeneration: null, startReadPending: true });
+            const startRead = await reading;
             const previousMessages = structuredClone(s.messages);
-            // 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, issuedReasoningSince: s.reasoning_replay_from });
-            this.stopContexts.set(streamId, { previousContext, historyLength: apiHistory.length, prompt: msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null, stateDbStartGeneration: startRead.generation });
+            const { previousContext, apiHistory } = this.turnHistory(s, streamId, startRead.rows);
+            // A Stop that landed during the read already took the local entry.
+            if (!this.registry.cancelled.has(streamId))
+                this.stopContexts.set(streamId, { previousContext, historyLength: apiHistory.length, prompt: msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null, stateDbStartGeneration: startRead.generation, startReadPending: false });
             return { previousMessages, previousContext, apiHistory };
         };
         // Before the first await: a Stop can land at any point after admission.
-        let { previousMessages, previousContext, apiHistory } = history();
         const controller = new AbortController();
         this.abortControllers.set(streamId, controller);
+        let { previousMessages, previousContext, apiHistory } = await history();
         // TAL-1005: an over-threshold session compacts in its joinable compression job before the turn reads its history, so
         // a Stop ends only this wait and a resend joins the same job. The turn then reads the compacted session afresh.
         const compacted = await deps.service().ensureCompacted(sessionId, { turn: streamId, signal: controller.signal, due: compactionDue, onWait: async () => { (await put('compressing', { session_id: sessionId, message: 'Compressing context' })); } });
@@ -592,7 +636,7 @@ export class TurnRunner {
             }
             catch { /* the cancel or error path below reports a deleted session */ }
             ;
-            ({ previousMessages, previousContext, apiHistory } = history());
+            ({ previousMessages, previousContext, apiHistory } = await history());
             await put('compressed', this.compressedFrame(s));
         }
         const activeTurnToken = buildActiveTurnToken(streamId, s.pending_started_at);
@@ -684,10 +728,13 @@ export class TurnRunner {
             };
             // Python `_public_prefill_context_status`: the session-recall prefill hook was dropped with TAL-245, so the
             // context frame always reports the not-configured shape.
-            const persistentBefore = persistentStateSnapshot(deps.profileHome(s.profile));
+            const persistentHome = deps.profileHome(s.profile);
+            const persistentBefore = await persistentStateSnapshot(persistentHome);
             await put('context_status', { session_id: sessionId, prefill: { status: 'not_configured', source: 'none', label: '', message_count: 0 } });
-            // Setup awaits can outlive a gateway adoption; no await separates this read from dispatch.
-            deps.service().assertWritable(s);
+            // Setup awaits can outlive a gateway adoption, so the owner is rechecked right before dispatch.
+            await deps.service().assertWritable(s);
+            closePreparation?.();
+            timing?.emit('dispatch');
             agentDispatched = true;
             const result = await sidecar.call('chat.start', {
                 profile_home: deps.profileHome(s.profile), session_id: sessionId, stream_id: streamId, ...this.agentWorkspace(s, opts.workspace), model: opts.model ?? '', model_provider: opts.modelProvider,
@@ -696,14 +743,26 @@ export class TurnRunner {
                 ...(opts.connectCard ? { connect_card: true } : {}),
                 ...(opts.skillSecret ? { skill_secret: true } : {}),
             }, {
+                timing,
                 signal: controller.signal,
                 timeoutMs: 0,
                 onStream: (frame) => {
+                    timing?.observe('first_sidecar_output');
                     const receivedAt = deps.now();
                     streamWrites = streamWrites.then(async () => {
                         const publish = put;
                         const emitFrame = (event, data, meta = {}) => publish(event, data, { ...meta, createdAt: receivedAt });
                         const data = isDict(frame.data) ? frame.data : {};
+                        if ((frame.event === 'notice' || frame.event === 'notice_clear') && str(data.key).startsWith('startup-warning.')) {
+                            try {
+                                await deps.notifications.agentWarning(notificationScope, str(data.key), frame.event === 'notice' ? { text: str(data.text), level: data.level } : null);
+                            }
+                            catch (error) {
+                                // Notification storage must not turn a successful Agent result into a failed chat.
+                                deps.log(`[webui] startup warning persistence failed for ${sessionId}: ${String(error)}`);
+                            }
+                            return;
+                        }
                         switch (frame.event) {
                             case 'token': {
                                 tokenSent = true;
@@ -761,11 +820,23 @@ export class TurnRunner {
                                 await emitFrame('tool', publicToolFrame(withToolId(data, toolIds.get(call)), redacted), { redacted });
                                 return;
                             }
+                            case 'tool_progress': {
+                                if (statusEnded || this.registry.cancelled.has(streamId))
+                                    return;
+                                const tc = liveToolCalls.findLast((call) => !call.done && call.tid === data.tool_call_id && Boolean(data.tool_call_id));
+                                if (!tc)
+                                    return;
+                                const redacted = deps.redactEnabled();
+                                tc.progress = toolProgress({ ...data, message: typeof data.message === 'string' ? redactString(data.message, redacted) : null });
+                                await emitFrame('tool_progress', { id: toolIds.get(tc), progress: tc.progress }, { redacted });
+                                return;
+                            }
                             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, todo_result: todoResult, result_diff: resultDiff, display_metadata: displayMetadata, ...complete } = data;
-                                const outcome = toolOutcome(rawResult);
+                                const outcome = toolOutcome(rawResult, data.name);
+                                complete.progress = null;
                                 complete.is_error = outcome.is_error;
                                 if (rawResult !== undefined)
                                     complete.result_view = outcome.result_view;
@@ -780,8 +851,10 @@ export class TurnRunner {
                                     if (startedAt !== undefined)
                                         complete.duration = Math.round(Math.max(0, receivedAt - 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 } : {}), ...(editDiff ? { edit_diff: editDiff } : {}) });
+                                    Object.assign(tc, { done: true, progress: null, snippet: data.preview, is_error: complete.is_error, duration: complete.duration ?? null, ...(complete.result_view ? { result_view: complete.result_view } : {}), ...(editDiff ? { edit_diff: editDiff } : {}) });
                                 }
+                                if (startsBackgroundWork(data.name, rawResult))
+                                    deps.onBackgroundWork?.(sessionId, s.profile ?? null);
                                 const id = (tc && toolIds.get(tc)) || str(data.tid) || mintToolId();
                                 this.lastCompletedTool.set(streamId, id);
                                 const redacted = deps.redactEnabled();
@@ -899,6 +972,19 @@ export class TurnRunner {
             result.messages = withImages(result.messages);
             if (result.context_messages)
                 result.context_messages = withImages(result.context_messages);
+            // Snapshot IO must finish before the cancellation/ownership gates and final transcript writeback.
+            let persistentChanges = null;
+            if (!opts.ephemeral && result.status === 'completed' && !this.registry.cancelled.has(streamId)) {
+                try {
+                    persistentChanges = persistentStateChanges(persistentBefore, await persistentStateSnapshot(persistentHome));
+                }
+                catch (error) {
+                    deps.log(`[webui] persistent state change detection failed for ${sessionId}: ${error.message}`);
+                }
+            }
+            // TAL-1162: the settlement's one state.db read runs on the worker before the gates below decide, so a Stop that
+            // lands during it takes the cancel path instead of racing this writeback.
+            const settlement = await deps.service().settlementRead(s);
             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.
@@ -948,7 +1034,7 @@ export class TurnRunner {
                 await this.steerRewrites.get(streamId);
                 const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, str(result.pending_steer), 'followup');
                 followUp = leftovers;
-                await this.persistError(s, streamId, classification.label, payload, activeTurnToken, resultMessages, result.provider);
+                await this.persistError(s, settlement, 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 = (await this.publicTerminalSession(s));
@@ -1087,7 +1173,7 @@ 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).
-            this.settleStateDb(s, streamId, agentRows, { previousContext });
+            this.settleStateDb(s, streamId, agentRows, { previousContext, read: settlement });
             recordBackgroundReview(s, streamId);
             await deps.store.save(s);
             deps.pending.clearApprovals(sessionId);
@@ -1095,10 +1181,9 @@ export class TurnRunner {
             deps.events.publish('session_done', { profile: s.profile, sessionId: s.session_id });
             // Python `_persistent_state_changes`: toast memory/skill files the agent wrote during the turn.
             try {
-                const changes = persistentStateChanges(persistentBefore, persistentStateSnapshot(deps.profileHome(s.profile)));
-                if (changes.memory_saved)
+                if (persistentChanges?.memory_saved)
                     (await put('state_saved', { session_id: sessionId, kind: 'memory', action: 'saved' }));
-                for (const change of changes.skills)
+                for (const change of persistentChanges?.skills ?? [])
                     (await put('state_saved', { session_id: sessionId, kind: 'skill', action: change.action, name: change.name }));
             }
             catch (error) {
@@ -1159,9 +1244,11 @@ export class TurnRunner {
             await opts.onDone?.(lastAnswer(s.messages));
         }
         catch (error) {
+            timing?.fail(error);
             await streamWrites;
             const readOnly = !agentDispatched ? (await deps.service().readOnlyReason(s)) : null;
             if (readOnly) {
+                timing?.fail({ status: 403 });
                 ownershipRefused = true;
                 if (this.registry.writebackOwners.get(sessionId) === streamId && s.active_stream_id === streamId) {
                     // Cancellation persists the prompt and a Stop row; an unstarted, refused turn must add neither.
@@ -1177,6 +1264,8 @@ export class TurnRunner {
             if (settledAt.value && !(error instanceof SidecarError)) {
                 deps.log(`[webui] ERROR settling turn ${streamId}\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
             }
+            // TAL-1162: the error's settlement read runs on the worker before the gates below decide.
+            const settlement = await deps.service().settlementRead(s);
             if (this.registry.cancelled.has(streamId)) {
                 await this.finalizeCancelled(s, streamId, opts.ephemeral);
                 await put('cancel', (await this.cancelFrame(sessionId)));
@@ -1201,7 +1290,7 @@ export class TurnRunner {
                 if (current.active_stream_id === streamId) {
                     for (const [event, data] of this.takeSteerEventsBefore(streamId, 'apperror'))
                         (await put(event, data));
-                    await this.persistError(current, streamId, classification.label, payload, activeTurnToken);
+                    await this.persistError(current, settlement, streamId, classification.label, payload, activeTurnToken);
                     if (!opts.ephemeral)
                         payload.session = (await this.publicTerminalSession(current));
                 }
@@ -1306,29 +1395,7 @@ export class TurnRunner {
     }
     /** The settled session as a terminal frame carries it: the display window, redacted. */
     async publicTerminalSession(s) {
-        return redactSessionData((await 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.
-     */
-    async terminalSessionPayload(s) {
-        const payload = (await this.deps.service().wireRow(s));
-        payload.automatic_turns_held = (await this.automaticTurnsHeld(s.session_id));
-        payload.notices = this.sessionNotices(s.session_id);
-        payload.goal = this.sessionGoal(s.session_id);
-        const service = this.deps.service();
-        const scened = (await service.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes((await service.backgroundUpdates(s, withMarkerKinds(withTurnIds(withAttachmentObjects(s.messages)), s))), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true })));
-        const [window, offset] = messageWindowForDisplay(scened, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
-        const limited = messagesForLimitedPayload(withBodyExcerpts(withDisplayMedia(window, (await service.mediaProjector(s))), s.active_stream_id, newestSettledReply(scened, s.active_stream_id), offset));
-        payload.messages = limited;
-        payload.message_count = s.messages.length;
-        payload._messages_offset = offset;
-        payload._messages_truncated = offset > 0;
-        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;
+        return this.deps.service().windowedDetail(s, TRANSCRIPT_WINDOW);
     }
     /** TAL-540, Python `_live_usage_snapshot`: a finished compression's frame, with the counters and the ring's post-compression figures, so clients update before `done`. */
     compressedFrame(s) {
@@ -1349,7 +1416,8 @@ export class TurnRunner {
     }
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
     /** `runtimeProvider`: the provider the Agent resolved for the turn, when it reported one. */
-    async persistError(s, streamId, label, payload, activeTurnToken, agentRows = [], runtimeProvider = '') {
+    /** `read`: the settlement's one state.db read, taken before the caller's gates decided (TAL-1162). */
+    async persistError(s, read, 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') {
@@ -1392,7 +1460,6 @@ export class TurnRunner {
         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;
@@ -1409,11 +1476,19 @@ export class TurnRunner {
         this.deps.pending.clearClarifies(s.session_id);
         this.deps.events.publish('session_error', { profile: s.profile, sessionId: s.session_id });
     }
+    /** The model history a turn starts from: the session's context merged with `stateRows`, without the turn's own rows. */
+    turnHistory(s, streamId, stateRows) {
+        // 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(this.deps.service().modelContext(s, stateRows)).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).
+        return { previousContext, apiHistory: sanitizeMessagesForApi(previousContext, { preserveApiContent: true, issuedReasoningSince: s.reasoning_replay_from }) };
+    }
     /** Every terminal path carries the same starting read's id and generation into settlement. */
-    settleStateDb(s, streamId, agentRows, opts = {}) {
+    settleStateDb(s, streamId, agentRows, opts) {
         const stop = this.stopContexts.get(streamId);
-        const service = this.deps.service();
-        service.settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? opts.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null, startGeneration: stop?.stateDbStartGeneration ?? null, read: opts.read ?? service.stateDbRead(s) });
+        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? opts.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null, startGeneration: stop?.stateDbStartGeneration ?? null, read: opts.read });
     }
     /**
      * TAL-921: the model context a turn that ends without its settled result leaves: the work its Agent reported, else the
@@ -1498,8 +1573,20 @@ export class TurnRunner {
         catch {
             return false;
         }
+        // TAL-921: one state.db read builds the context and settles the turn. TAL-1162: it runs on the state.db worker, before
+        // any gate below decides.
+        const read = await this.deps.service().settlementRead(current);
+        if (this.registry.writebackOwners.get(s.session_id) !== streamId)
+            return false;
         if (current.active_stream_id !== null && current.active_stream_id !== streamId)
             return false;
+        const stop = this.stopContexts.get(streamId);
+        if (stop?.startReadPending) {
+            // TAL-1162: the Stop landed before the turn's starting read did, so the Agent never ran: every row this later read
+            // holds predates the turn, and the context the turn would have started from keeps them. No row is its own work.
+            const { previousContext, apiHistory } = this.turnHistory(current, streamId, read.rows);
+            Object.assign(stop, { previousContext, historyLength: apiHistory.length, startReadPending: false });
+        }
         if (ephemeral) {
             try {
                 await this.deps.store.delete(current.session_id, { tombstone: false });
@@ -1514,7 +1601,7 @@ export class TurnRunner {
         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.settleStateDb(current, streamId, checkpoint);
+                this.settleStateDb(current, streamId, checkpoint, { read });
                 try {
                     (await this.deps.store.save(current));
                 }
@@ -1524,10 +1611,8 @@ export class TurnRunner {
             }
             return true;
         }
-        const stop = this.stopContexts.get(streamId);
         const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
-        // TAL-921: one state.db read builds the context and settles the turn.
-        const settle = (read) => {
+        const settle = () => {
             if (!stop)
                 return null;
             if (canonical)
@@ -1541,8 +1626,7 @@ export class TurnRunner {
             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;
+                const late = canonical && !stop.checkpointed ? settle() : null;
                 if (late)
                     current.context_messages = dedupeContext(late);
                 this.settleStateDb(current, streamId, checkpoint, { read });
@@ -1557,8 +1641,7 @@ export class TurnRunner {
         }
         const startedAt = current.pending_started_at;
         this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at), streamId);
-        const read = this.deps.service().stateDbRead(current);
-        const context = settle(read);
+        const context = settle();
         if (context)
             current.context_messages = dedupeContext(context);
         this.clearPendingTurn(current);
@@ -1641,6 +1724,7 @@ export class TurnRunner {
         await service.deps.warmSessionModelRepair?.(s.profile);
         const [model, provider] = service.turnModel(s);
         const [qa, prompts] = titlePrompts(userText, assistantText);
+        const source = [...s.messages, ...s.context_messages, ...await service.stateDbRows(s)];
         let status = 'llm_error_aux';
         for (const [idx, prompt] of prompts.entries()) {
             if ((await this.deps.service().isReadOnly(s)))
@@ -1649,7 +1733,7 @@ export class TurnRunner {
             try {
                 const result = await sidecar.call('aux.complete', {
                     profile_home: this.deps.profileHome(s.profile), task: 'title_generation',
-                    messages: [{ role: 'system', content: prompt }, { role: 'user', content: qa }], max_tokens: 64,
+                    messages: withDataUseRequirements([{ role: 'system', content: prompt }, { role: 'user', content: qa }], source), max_tokens: 64,
                     main_runtime: { model: model ?? '', provider }, main_fallback: true,
                 });
                 raw = str(result.text);
@@ -1680,9 +1764,10 @@ export class TurnRunner {
     async refine(s, focus) {
         if (!s)
             return 'Nothing to refine yet — send a message first.';
+        const context = await this.deps.service().readModelContext(s);
         if (s.active_stream_id)
             return 'Agent is running — wait for the turn to finish, then /refine.';
-        const messages = sanitizeMessagesForApi(this.deps.service().modelContext(s), { preserveApiContent: true, issuedReasoningSince: s.reasoning_replay_from });
+        const messages = sanitizeMessagesForApi(context, { preserveApiContent: true, issuedReasoningSince: s.reasoning_replay_from });
         if (!messages.length)
             return 'Nothing to refine yet — the conversation is empty.';
         // Like a turn: no agent is built in a profile whose home is going away.
@@ -1693,7 +1778,7 @@ export class TurnRunner {
             throw new SidecarError('The Agent sidecar is not running; /refine is unavailable until it starts.', { condition: 'sidecar_unavailable' });
         const [model, provider] = this.deps.service().turnModel(s);
         const cfg = (await this.deps.profileConfig?.(s.profile ?? null)) ?? {};
-        this.deps.service().assertWritable(s);
+        await this.deps.service().assertWritable(s);
         return (await sidecar.call('chat.refine', {
             profile_home: this.deps.profileHome(s.profile), session_id: s.session_id, messages, focus, model: model ?? '', model_provider: provider,
             enabled_toolsets: this.deps.toolsetsFor(s), ...agentBuildParams(cfg, 'webui', provider, this.deps.env ?? {}),
@@ -1721,7 +1806,7 @@ export class TurnRunner {
         let rawPreview = '';
         if (assistantText)
             ({ title: next, status: llmStatus, rawPreview } = await this.llmTitle(s, userText, assistantText));
-        this.deps.service().assertWritable(s);
+        await this.deps.service().assertWritable(s);
         if (next)
             return { title: next, status: llmStatus, rawPreview };
         const fallback = fallbackTitleFromExchange(userText, assistantText);
@@ -2243,7 +2328,7 @@ export class TurnRunner {
         let decision;
         try {
             // The workspace the turn ran in, unrecovered: the Agent pauses the goal rather than run its gates anywhere else.
-            this.deps.service().assertWritable(s);
+            await this.deps.service().assertWritable(s);
             decision = await sidecar.call('goals.evaluate', { session_id: sessionId, profile_home: this.deps.profileHome(s.profile), last_response: lastResponse, user_initiated: true, workspace: str(s.workspace) || undefined });
         }
         catch (error) {
@@ -2300,6 +2385,11 @@ export class TurnRunner {
         const open = r.state === 'pending';
         return { steer_id: r.steer_id, text: r.display_text, submitted_at: r.created_at, state: r.state, actions: { edit: open, cancel: open, send_now: open && r.can_redirect } };
     }
+    liveToolProgress(streamId) {
+        if (this.registry.cancelled.has(streamId))
+            return [];
+        return (this.registry.liveToolCalls.get(streamId) ?? []).filter((call) => !call.done && call.progress).map((call) => ({ ...call, id: str(call.tid) }));
+    }
     runStatus(streamId) {
         return this.runStatuses.get(streamId) ?? null;
     }
@@ -2422,7 +2512,7 @@ export class TurnRunner {
     }
     // ── approvals / clarify ──────────────────────────────────────────────────
     async respondApproval(sessionId, choice, approvalId, enableYolo) {
-        if (this.deps.service().owner?.isOwned(sessionId)) {
+        if (await this.deps.service().owner?.isOwned(sessionId)) {
             if (enableYolo)
                 throw new HttpFailure(403, 'Change approval policy through the owning Agent');
             await this.deps.service().owner.respond(sessionId, 'approval', approvalId, choice);
@@ -2551,7 +2641,7 @@ export class TurnRunner {
      * did not acknowledge (prompt retained).
      */
     async respondClarify(sessionId, clarifyId, reply) {
-        if (this.deps.service().owner?.isOwned(sessionId)) {
+        if (await this.deps.service().owner?.isOwned(sessionId)) {
             await this.deps.service().owner.respond(sessionId, 'clarify', clarifyId, reply);
             return { ok: true };
         }