@maudecode/talaria-web 1.18.0 → 1.20.0

package/dist/sessions/turn.js

@@ -5,40 +5,45 @@
  * (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, rmSync } from 'node:fs';
+import { closeSync, fstatSync, readFileSync } from 'node:fs';
 import { openAnchoredFd } from '../workspace/fs.js';
 import { isWithin, resolvePathLikePython } from '../workspace/paths.js';
-import { SidecarError } from '../sidecar/client.js';
+import { runtimeFailureDetails, 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 { 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 { 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, 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 { withSessionWireFlags } from './list.js';
-import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
+import { UNSETTLED_TODO_KEY, parseTodoToolResult } from './todo.js';
+import { SessionNotices } from './notices.js';
+import { SessionGoals } from './goals.js';
+import { turnTerminalState } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
-import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, 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, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
-import { mayBecomeSilentReply, turnOrigin, withBackgroundUpdates } from './background-updates.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, 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. */
+const CONTENT_EVENTS = new Set(['token', 'reasoning', 'interim_assistant', 'tool', 'tool_complete']);
 /** 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.' };
@@ -65,6 +70,9 @@ export function classifyProviderError(errStr, opts = {}) {
     const lower = errStr.toLowerCase();
     if (opts.compressionExhausted)
         return COMPRESSION_EXHAUSTED;
+    // TAL-798: the Agent's local llama.cpp provider has no key to add; its server is off or still starting.
+    if (opts.condition === 'local_runtime_unavailable')
+        return { label: 'Local model server unavailable', type: 'local_runtime_unavailable', hint: 'The local model server is off or still starting. Turn it on in Hermes Agent, or pick another model.' };
     if (opts.condition === 'credential_missing')
         return { label: 'Authentication failed', type: 'auth_mismatch', hint: 'The selected model may not be supported by your configured provider or your API key is invalid. Run `hermes model` in your terminal to update credentials, then restart the WebUI.' };
     const cancelled = ['cancelled by user', 'canceled by user', 'user cancelled', 'user canceled', 'task cancelled', 'task canceled', 'cancellederror'].some((k) => lower.includes(k));
@@ -209,6 +217,10 @@ export class TurnRunner {
     liveUsage = new Map();
     /** TAL-397: each running turn's latest todo list, which an error or cancel keeps on the session. */
     liveTodos = new Map();
+    /** The current presentation, scoped to its owning stream and released on every terminal path. */
+    runStatuses = new Map();
+    /** TAL-1006: each live stream's open compression span, by its start (epoch seconds). */
+    compressionSpans = 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). */
@@ -216,20 +228,147 @@ 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();
     stopContexts = new Map();
     /** Each turn's worker, so a stopped background turn can be awaited before the user's turn takes the session. */
     workers = new Map();
+    /** TAL-899: sessions whose user pressed Stop; no automatic turn starts in them until the user's next turn is admitted. */
+    stopHeld = new Set();
+    notices = new SessionNotices(() => this.deps.now());
+    goals = new SessionGoals(() => this.deps.now());
     constructor(deps) {
         this.deps = deps;
     }
     get registry() { return this.deps.registry; }
     // ── admission ────────────────────────────────────────────────────────────
+    /** TAL-899: whether a Stop holds the session's automatic turns (session `automatic_turns_held`). */
+    async automaticTurnsHeld(sessionId) {
+        if (this.stopHeld.has(sessionId))
+            return true;
+        try {
+            return (await this.deps.store.get(sessionId, { metadataOnly: true })).automatic_turns_stop_held;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** TAL-803: the Agent's active notices for the session (session `notices`). */
+    sessionNotices(sessionId) {
+        const redact = this.deps.redactEnabled();
+        return this.notices.list(sessionId).map((n) => ({ ...n, text: redactString(n.text, redact) }));
+    }
+    /** TAL-808: the session's standing goal (session `goal`). */
+    sessionGoal(sessionId) {
+        const goal = this.goals.view(sessionId);
+        if (!goal)
+            return null;
+        const redact = this.deps.redactEnabled();
+        return { ...goal, text: redactString(goal.text, redact), reason: goal.reason === null ? null : redactString(goal.reason, redact) };
+    }
+    /**
+     * TAL-808: reads the session's goal from the Agent and, when its view changed, sends `session_goal` on `put` (else the
+     * session's live stream) and `sessions_changed`, which reloads the session for a client between turns.
+     */
+    async refreshGoal(s, put = async (event, data) => { (await this.emitToSession(s.session_id, event, data)); }) {
+        if (!(await this.readGoal(s)))
+            return;
+        await put('session_goal', { session_id: s.session_id, goal: this.sessionGoal(s.session_id) });
+        this.deps.events.publish('goal', { profile: s.profile, sessionId: s.session_id });
+    }
+    /** TAL-808: a session's first detail after a restart reads its goal before answering, so it tells no one else. */
+    async loadGoal(sessionId) {
+        if (this.goals.has(sessionId))
+            return;
+        let s;
+        try {
+            s = (await this.deps.store.get(sessionId, { metadataOnly: true }));
+        }
+        catch {
+            return;
+        }
+        await this.readGoal(s);
+    }
+    /** The Agent's `goals.get` into the cache, and a re-read when a timed park ends; whether the view changed. A failed read keeps the last one. */
+    async readGoal(s) {
+        const sidecar = this.deps.sidecar();
+        if (!sidecar)
+            return false;
+        let status;
+        try {
+            // Short: a session's first load waits on it.
+            status = await sidecar.call('goals.get', { session_id: s.session_id, profile_home: this.deps.profileHome(s.profile) }, { timeoutMs: 3_000 });
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: goal read failed for ${s.session_id}: ${error.message}`);
+            return false;
+        }
+        const changed = this.goals.set(s.session_id, status);
+        this.goals.rereadAfterPark(s.session_id, () => { void this.refreshGoal({ session_id: s.session_id, profile: s.profile }); });
+        return changed;
+    }
+    /** Hygiene sweep: a deleted session's hold, notices and goal go with it (TAL-899, TAL-803, TAL-808). */
+    async sweep() {
+        const exists = async (sid) => (await this.deps.store.exists(sid));
+        for (const sid of this.stopHeld)
+            if (!(await exists(sid)))
+                this.stopHeld.delete(sid);
+        await this.notices.sweep(exists);
+        await this.goals.sweep(exists);
+    }
+    /**
+     * Admit automatic turns through the same workspace recovery and model resolution as user turns. After the user's Stop
+     * none starts (TAL-899): the answer is a `held` 409, and the caller keeps its work for the user's next turn.
+     */
+    async startServerTurn(session, opts) {
+        if ((await this.automaticTurnsHeld(session.session_id)))
+            return { _status: 409, error: 'automatic turns are held after Stop', held: true };
+        try {
+            const service = this.deps.service();
+            const workspace = (await service.turnWorkspace(session));
+            const [model, modelProvider, normalizedModel] = service.turnModel(session);
+            return (await this.admit(session, { ...opts, workspace, model, modelProvider, normalizedModel }));
+        }
+        catch (error) {
+            if (error instanceof HttpFailure)
+                return { _status: error.status, error: error.message };
+            throw error;
+        }
+    }
+    /** A user's turn; admitting it releases the hold a Stop put on automatic turns (TAL-899). */
+    async start(session, opts) {
+        const response = (await this.admit(session, opts, true));
+        if (response._status === undefined)
+            this.stopHeld.delete(session.session_id);
+        return response;
+    }
     /** Python `_start_chat_stream_for_session`: persist pending state, register the channel, launch the worker. */
-    start(session, opts) {
+    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)
+            return { error: readOnly, _status: 403 };
         if (this.deps.updateInProgress?.())
             return { error: 'Web is updating. Retry after it restarts.', _status: 503 };
         if (this.deps.profileDeleting?.(s.profile ?? null))
@@ -242,7 +381,7 @@ export class TurnRunner {
         if (locked) {
             if (this.registry.liveIds.has(locked) || this.registry.activeRuns.has(locked))
                 return { error: 'session already has an active stream', active_stream_id: locked, _status: 409 };
-            this.deps.service().clearStaleStreamState(s);
+            await this.deps.service().clearStaleStreamState(s);
             if (s.active_stream_id)
                 return { error: 'session already has an active stream', active_stream_id: s.active_stream_id, _status: 409 };
         }
@@ -251,11 +390,28 @@ export class TurnRunner {
             if (blocking)
                 return { error: 'session already has an active stream', active_stream_id: blocking, _status: 409 };
         }
+        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).
         const source = opts.source !== 'process_wakeup' && str(s.source_tag).toLowerCase() === 'fork' ? 'fork' : (opts.source ?? 'webui');
+        // TAL-1005: the context figures the last turn reported hold for a turn on the same model only, and are judged before
+        // admission clears the post-compression estimate. A `/btw` clone is thrown away after one answer, so it is never due.
+        const sameRuntime = str(s.model) === str(opts.model) && str(s.model_provider) === str(opts.modelProvider);
+        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;
@@ -265,6 +421,12 @@ export class TurnRunner {
         s.pending_attachments = attachments;
         s.pending_started_at = this.deps.now();
         s.pending_user_source = source;
+        // TAL-927: reasoning one provider issued can fail on another (hermes-agent#122831), so a provider switch moves the
+        // boundary its carriers replay from.
+        if (s.reasoning_replay_provider !== str(opts.modelProvider)) {
+            s.reasoning_replay_provider = str(opts.modelProvider);
+            s.reasoning_replay_from = s.pending_started_at;
+        }
         if (['', 'Untitled', 'New Chat'].includes(str(s.title).trim())) {
             const provisional = titleFrom([{ role: 'user', content: opts.msg }], s.title || 'Untitled');
             if (provisional && !['', 'Untitled', 'New Chat'].includes(provisional.trim()))
@@ -272,21 +434,47 @@ export class TurnRunner {
         }
         if (this.deps.saveMode() === 'eager')
             this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source, streamId);
-        this.deps.store.save(s);
+        const previousStopHold = s.automatic_turns_stop_held;
+        if (releaseStopHold)
+            s.automatic_turns_stop_held = false;
+        const previousAcceptances = s.extra.completion_acceptances;
+        if (opts.completionKeys?.length)
+            s.extra.completion_acceptances = { ...accepted, ...Object.fromEntries(opts.completionKeys.map((key) => [key, streamId])) };
+        const previousUpdates = s.extra.background_updates;
+        if (opts.backgroundUpdate)
+            recordBackgroundUpdate(s, streamId, opts.backgroundUpdate);
+        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 timing.measure('admission_persistence', () => this.deps.store.save(s));
+        }
+        catch (error) {
+            this.registry.activeRuns.delete(streamId);
+            s.extra.background_updates = previousUpdates;
+            s.extra.completion_acceptances = previousAcceptances;
+            s.automatic_turns_stop_held = previousStopHold;
+            throw error;
+        }
         this.registry.writebackOwners.set(s.session_id, streamId);
         // 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 {
-            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);
-        this.registry.registerActiveRun({ stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral), origin: turnOrigin(source) });
-        const worker = this.run(s.session_id, streamId, channel, opts).catch((error) => {
+        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)
@@ -307,28 +495,78 @@ export class TurnRunner {
         s.messages.push(pendingUserRow(msg, attachments, startedAt, source, turnId));
     }
     // ── worker ───────────────────────────────────────────────────────────────
-    async run(sessionId, streamId, channel, opts) {
+    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 = deps.journal.writer(sessionId, streamId);
+            writer = (await deps.journal.writer(sessionId, streamId));
             this.writers.set(streamId, writer);
         }
         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 = {}) => {
+        let waitDetail = null;
+        let providerPhase = null;
+        let statusEnded = false;
+        // TAL-1006: the open compression span closes on the Agent's end of it, else on the next content frame.
+        const closeCompression = async (createdAt) => {
+            if (!this.compressionSpans.has(streamId))
+                return;
+            await put('compressed', { session_id: sessionId, message: 'Compression finished' }, createdAt === undefined ? {} : { createdAt });
+        };
+        const put = async (event, data, meta = {}) => {
+            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) {
+                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')
+                waitDetail = data.wait;
+            // Both pre-turn compaction and Agent callbacks publish through this boundary.
+            if (event === 'compressing' && !statusEnded) {
+                const startedAt = this.compressionSpans.get(streamId) ?? meta.createdAt ?? deps.now();
+                this.compressionSpans.set(streamId, startedAt);
+                data = { ...data, started_at: startedAt };
+            }
+            else if (event === 'compressed')
+                this.compressionSpans.delete(streamId);
+            if (CONTENT_EVENTS.has(event)) {
+                if (waitDetail) {
+                    await put('rate_limit_wait', { session_id: sessionId, wait: null }, meta.createdAt === undefined ? {} : { createdAt: meta.createdAt });
+                }
+                await closeCompression(meta.createdAt);
+            }
+            const status = event === 'run_status' ? data.status : statusEnded ? null : this.compressionSpans.has(streamId) ? { phase: 'compressing' }
+                : waitDetail ? { phase: 'rate_limit_wait', wait: waitDetail } : providerPhase ?? { phase: 'working' };
+            if (JSON.stringify(this.runStatuses.get(streamId) ?? null) !== JSON.stringify(status)) {
+                if (status)
+                    this.runStatuses.set(streamId, status);
+                else
+                    this.runStatuses.delete(streamId);
+                await put('run_status', { session_id: sessionId, status }, meta);
+            }
+            // The sidecar phase is private; only the selected status crosses the client boundary.
+            if (event === 'provider_phase')
+                return;
             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))
+                (await put(steerEvent[0], steerEvent[1]));
+            if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn', 'run_status'].includes(event))
                 return;
             // `cancel()` already wrote the terminal row and closed the stream: the worker's unwind adds no second one.
             if (event === 'cancel' && !this.registry.streams.has(streamId)) {
+                timing?.frame(event, data);
                 try {
                     deps.onTerminal?.(streamId, 'cancelled');
                 }
@@ -336,9 +574,9 @@ export class TurnRunner {
                 return;
             }
             let eventId = null;
-            if (writer) {
+            if (writer && event !== 'tool_progress') {
                 try {
-                    eventId = writer.appendSseEvent(event, data, meta).event_id;
+                    eventId = (await writer.appendSseEvent(event, data, meta)).event_id;
                 }
                 catch (error) {
                     this.registry.degradedJournals.add(streamId);
@@ -346,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);
@@ -360,25 +599,46 @@ export class TurnRunner {
         const activeRun = this.registry.activeRuns.get(streamId);
         let s;
         try {
-            s = deps.store.get(sessionId);
+            s = (await deps.store.get(sessionId));
         }
         catch {
-            put('apperror', { type: 'error', terminal_state: 'error', message: 'Session not found', session_id: sessionId });
-            this.teardown(sessionId, streamId);
+            await put('apperror', { type: 'error', terminal_state: 'error', message: 'Session not found', session_id: sessionId });
+            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 previousMessages = structuredClone(s.messages);
-        // 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 });
+        const history = async () => {
+            // TAL-493: one state.db read builds the history and marks where this turn's own rows begin.
+            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);
+            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.
-        this.stopContexts.set(streamId, { previousContext, historyLength: apiHistory.length, prompt: msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null });
+        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' })); } });
+        if (compacted) {
+            try {
+                s = (await deps.store.get(sessionId));
+            }
+            catch { /* the cancel or error path below reports a deleted session */ }
+            ;
+            ({ previousMessages, previousContext, apiHistory } = await history());
+            await put('compressed', this.compressedFrame(s));
+        }
         const activeTurnToken = buildActiveTurnToken(streamId, s.pending_started_at);
         const sidecar = deps.sidecar();
         const partialText = this.registry.partialText.get(streamId) ?? [];
@@ -395,21 +655,19 @@ export class TurnRunner {
         // 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();
+        const putMetering = async (force, 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 });
+            await put('metering', { session_id: sessionId, usage: meteringUsage(liveUsage), tps, tps_available: tps !== null, estimated: false });
         };
-        const meterDelta = () => {
-            const now = deps.now();
+        const meterDelta = async (now = deps.now()) => {
             if (!meter.deltas)
                 meter.first = now;
             meter.last = now;
             meter.deltas += 1;
-            putMetering(false);
+            await putMetering(false, now);
         };
         // 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;
@@ -418,13 +676,11 @@ export class TurnRunner {
         let heldText = '';
         const titles = new ReasoningTitleTracker();
         let capturedTerminalError = null;
-        const controller = new AbortController();
-        this.abortControllers.set(streamId, controller);
         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 userMessage = this.buildUserMessage(opts.prompt ?? 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);
@@ -434,6 +690,10 @@ export class TurnRunner {
             activeRun.phase = 'running';
         const settledAt = { value: false };
         let succeeded = false;
+        let ownershipRefused = false;
+        let agentDispatched = false;
+        let streamWrites = Promise.resolve();
+        let streamWriteError;
         // TAL-424: steers an errored turn ended without taking, sent as one follow-up turn once this one is torn down.
         let followUp = [];
         try {
@@ -443,6 +703,11 @@ export class TurnRunner {
             // 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)) ?? {};
+            const personality = str(s.personality);
+            // A selected personality never silently drops: an unknown catalog fails the turn (an absent name is the Agent's no-overlay).
+            const personalities = personality && deps.personalities
+                ? await deps.personalities(s.profile ?? null).catch((error) => { throw new SidecarError(`The session's personality "${personality}" could not be resolved: ${error instanceof Error ? error.message : String(error)}`, { condition: 'sidecar_error' }); })
+                : [];
             // 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.
             await this.withYoloLock(sessionId, async () => { try {
@@ -452,173 +717,288 @@ export class TurnRunner {
             // Last yield before `chat.start`: a cancel that landed during the attachment, config or YOLO awaits must not
             // start an Agent turn (the client also refuses an already-aborted signal outright).
             if (this.registry.cancelled.has(streamId)) {
-                this.finalizeCancelled(s, streamId, opts.ephemeral);
-                put('cancel', this.cancelFrame(sessionId));
+                await this.finalizeCancelled(s, streamId, opts.ephemeral);
+                await put('cancel', (await this.cancelFrame(sessionId)));
                 return;
             }
             const turnContext = {
                 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),
+                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personalityPrompt: findPersonality(personalities, personality)?.prompt ?? null, sessionId, profile: s.profile ?? null, workspace: opts.workspace, hermesHome: deps.profileHome(s.profile), homeDisplay: deps.homeDisplay?.() ?? '~/.hermes', background: turnOrigin(opts.source) === 'background' }),
+                ...agentBuildParams(cfg, opts.source ?? 'webui', opts.modelProvider ?? s.model_provider ?? null, deps.env ?? {}),
             };
             // 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));
-            put('context_status', { session_id: sessionId, prefill: { status: 'not_configured', source: 'none', label: '', message_count: 0 } });
+            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, 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, workspace: opts.workspace, model: opts.model ?? '', model_provider: opts.modelProvider,
+                profile_home: deps.profileHome(s.profile), session_id: sessionId, stream_id: streamId, ...this.agentWorkspace(s, opts.workspace), model: opts.model ?? '', model_provider: opts.modelProvider,
                 user_message: userMessage, ...turnContext, conversation_history: conversationHistory, enabled_toolsets: deps.toolsetsFor(s), ...(msgText ? { persist_user_message: msgText } : {}), ...(opts.ephemeral ? { ephemeral: true } : {}),
+                ...(opts.voiceTurn ? { voice_turn: true } : {}),
+                ...(opts.connectCard ? { connect_card: true } : {}),
+                ...(opts.skillSecret ? { skill_secret: true } : {}),
             }, {
+                timing,
                 signal: controller.signal,
                 timeoutMs: 0,
                 onStream: (frame) => {
-                    const data = isDict(frame.data) ? frame.data : {};
-                    switch (frame.event) {
-                        case 'token': {
-                            tokenSent = true;
-                            firstTokenAt ??= deps.now();
-                            // Visible text closes the reasoning segment: a stable title snapshot (or a clear) goes out first.
-                            const stable = titles.stableSnapshot(reasoningText.join(''));
-                            if (stable !== null)
-                                put('reasoning', { text: '', titles: stable });
-                            partialText.push(str(data.text));
-                            if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
-                                heldText += str(data.text);
-                                meterDelta();
-                                return;
+                    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);
                             }
-                            put('token', { text: heldText + str(data.text) });
-                            heldText = '';
-                            meterDelta();
-                            return;
-                        }
-                        case 'reasoning': {
-                            if (partialText.length && !reasoningText.length)
-                                titles.resetSegment();
-                            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);
+                            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)}`);
                             }
-                            putMetering(true);
                             return;
                         }
-                        case 'steer_pending':
-                            // TAL-424: while a withdraw or Send now rewrites the Agent's queue its pending text is ambiguous; it settles after.
-                            if (this.steerRewrites.has(streamId)) {
-                                this.deferredPendingSteer.set(streamId, str(data.text));
+                        switch (frame.event) {
+                            case 'token': {
+                                tokenSent = true;
+                                firstTokenAt ??= receivedAt;
+                                // Visible text closes the reasoning segment: a stable title snapshot (or a clear) goes out first.
+                                const stable = titles.stableSnapshot(reasoningText.join(''));
+                                if (stable !== null)
+                                    (await emitFrame('reasoning', { text: '', titles: stable }));
+                                partialText.push(str(data.text));
+                                if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
+                                    heldText += str(data.text);
+                                    (await meterDelta(receivedAt));
+                                    return;
+                                }
+                                await emitFrame('token', { text: heldText + str(data.text) });
+                                heldText = '';
+                                await meterDelta(receivedAt);
                                 return;
                             }
-                            this.settleConsumedSteers(sessionId, streamId, str(data.text));
-                            return;
-                        case 'tool': {
-                            const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
-                            liveToolCalls.push(call);
-                            toolIds.set(call, call.tid || mintToolId());
-                            toolStartedAt.set(call, deps.now());
-                            const redacted = deps.redactEnabled();
-                            put('tool', publicToolFrame(withToolId(data, toolIds.get(call)), redacted), { 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, ...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 } : {}), ...(editDiff ? { edit_diff: editDiff } : {}) });
+                            case 'reasoning': {
+                                if (partialText.length && !reasoningText.length)
+                                    titles.resetSegment();
+                                reasoningText.push(str(data.text));
+                                // Python `reasoning_event_payload`: bold or first-line titles ride on the delta they complete.
+                                await emitFrame('reasoning', titles.prepare(reasoningEventPayload(str(data.text), reasoningText.join(''))));
+                                await meterDelta(receivedAt);
+                                return;
                             }
-                            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));
+                            case 'usage': {
+                                const usage = ChatUsageSchema.safeParse(data);
+                                if (usage.success) {
+                                    applyAgentUsage(liveUsage, usage.data);
+                                    this.liveUsage.set(streamId, liveUsage);
+                                }
+                                await putMetering(true, receivedAt);
+                                return;
                             }
-                            return;
-                        }
-                        // Python: the live chat frame carries the queue head plus depth, not the entry that just arrived.
-                        case 'approval': {
-                            deps.pending.submitApproval(sessionId, { ...data, session_id: sessionId });
-                            const { pending, pending_count } = deps.pending.approvalPending(sessionId);
-                            put('approval', { ...(pending ?? data), pending_count });
-                            return;
-                        }
-                        // TAL-514: the Agent stopped waiting on an approval (answer, timeout, or interrupt); withdraw its copy.
-                        case 'approval_resolved': {
-                            if (!str(data.approval_id))
+                            case 'steer_pending': {
+                                // TAL-424: while a withdraw or Send now rewrites the Agent's queue its pending text is ambiguous; it settles after.
+                                if (this.steerRewrites.has(streamId)) {
+                                    this.deferredPendingSteer.set(streamId, str(data.text));
+                                    return;
+                                }
+                                // Capture the causal position before the next frame; only persistence is asynchronous.
+                                const saving = this.settleConsumedSteers(sessionId, streamId, str(data.text));
+                                await saving;
                                 return;
-                            deps.pending.resolveApproval(sessionId, str(data.approval_id));
-                            put(...this.approvalHeadFrame(sessionId));
-                            return;
-                        }
-                        case 'clarify': {
-                            deps.pending.submitClarify(sessionId, { ...data, session_id: sessionId, kind: 'clarify' });
-                            const head = deps.pending.clarifyHeadFrame(sessionId);
-                            if (head)
-                                put('clarify', head);
-                            return;
-                        }
-                        case 'clarify_resolved': {
-                            const { head } = deps.pending.resolveClarify(sessionId, str(data.clarify_id));
-                            if (head)
-                                put('clarify', head);
-                            return;
+                            }
+                            case 'tool': {
+                                const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
+                                liveToolCalls.push(call);
+                                toolIds.set(call, call.tid || mintToolId());
+                                toolStartedAt.set(call, receivedAt);
+                                const redacted = deps.redactEnabled();
+                                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, data.name);
+                                complete.progress = null;
+                                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. TAL-909:
+                                // else the diff in the metadata the Agent persisted on the result row, which a reload reads the same way.
+                                const editDiff = toolEditDiff(data.name, { diff: resultDiff }, displayMetadata);
+                                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, 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, 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();
+                                await emitFrame('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.
+                                // TAL-889: the sidecar attaches `todo_result` only to the Agent's todo tool, so no name check here.
+                                const todos = parseTodoToolResult(todoResult);
+                                if (todos) {
+                                    todos.ts = receivedAt;
+                                    this.liveTodos.set(streamId, todos);
+                                    await emitFrame('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.
+                            case 'approval': {
+                                deps.pending.submitApproval(sessionId, { ...data, session_id: sessionId });
+                                const { pending, pending_count } = deps.pending.approvalPending(sessionId);
+                                await emitFrame('approval', { ...(pending ?? data), pending_count });
+                                return;
+                            }
+                            // TAL-514: the Agent stopped waiting on an approval (answer, timeout, or interrupt); withdraw its copy.
+                            case 'approval_resolved': {
+                                if (!str(data.approval_id))
+                                    return;
+                                deps.pending.resolveApproval(sessionId, str(data.approval_id));
+                                await emitFrame(...this.approvalHeadFrame(sessionId));
+                                return;
+                            }
+                            case 'clarify': {
+                                deps.pending.submitClarify(sessionId, { ...data, session_id: sessionId });
+                                const head = deps.pending.clarifyHeadFrame(sessionId);
+                                if (head)
+                                    (await emitFrame('clarify', head));
+                                return;
+                            }
+                            case 'clarify_resolved': {
+                                const { head } = deps.pending.resolveClarify(sessionId, str(data.clarify_id));
+                                if (head)
+                                    (await emitFrame('clarify', head));
+                                return;
+                            }
+                            case 'provider_phase': {
+                                const phase = data.phase;
+                                if (phase !== null && phase?.phase !== 'prompt_reading')
+                                    return;
+                                const percent = phase?.progress_percent;
+                                providerPhase = phase === null ? null : { phase: 'prompt_reading', progress_percent: typeof percent === 'number' && Number.isFinite(percent) ? Math.max(0, Math.min(100, percent)) : null };
+                                await put('provider_phase', {}, { createdAt: receivedAt });
+                                return;
+                            }
+                            // TAL-821: the Agent sits out a provider's rate limit (`until`, epoch seconds: its reset, else the Agent's retry).
+                            case 'rate_limit_wait': {
+                                const until = typeof data.until === 'number' ? data.until : null;
+                                if (until === null && !waitDetail)
+                                    return;
+                                const provider = str(data.provider) || null;
+                                await emitFrame('rate_limit_wait', { session_id: sessionId, wait: until === null ? null : { provider, provider_label: provider && (deps.providerLabel?.(s.profile ?? null, provider) ?? displayName(provider)), until, until_kind: data.until_kind === 'reset' ? 'reset' : 'retry' } });
+                                return;
+                            }
+                            // TAL-818: a `manage_connections` card opened; clients poll and answer the operation by its `op_id`.
+                            case 'connection': {
+                                const snapshot = ConnectorOperationSnapshotSchema.safeParse(data);
+                                if (snapshot.success)
+                                    (await emitFrame('connect_card', connectorOperation(snapshot.data, catalogNames(deps.profileHome(s.profile)))));
+                                return;
+                            }
+                            case 'compressing':
+                                await emitFrame('compressing', data);
+                                return;
+                            case 'compression_finished':
+                                await closeCompression(receivedAt);
+                                return;
+                            case 'status':
+                                if (data.kind === 'terminal_error' && !capturedTerminalError)
+                                    capturedTerminalError = str(data.message);
+                                return;
+                            // TAL-803: the session's notice list changed; every client replaces its copy.
+                            case 'notice': {
+                                const notice = this.notices.add(sessionId, data);
+                                if (!notice)
+                                    return;
+                                await emitFrame('notices', { session_id: sessionId, notices: this.sessionNotices(sessionId) });
+                                // ponytail: the expiry reaches a client only while a turn streams; an idle tab drops it on its next session load.
+                                if (notice.expires_at !== null) {
+                                    const expiresAt = notice.expires_at;
+                                    const emitAfterExpiry = async () => {
+                                        // Timers can run before the wall clock expires the notice. Let SessionNotices decide, then retry.
+                                        if (this.notices.list(sessionId).includes(notice))
+                                            setTimeout(() => { void emitAfterExpiry().catch((error) => { deps.log(`[webui] notice expiry failed: ${String(error)}`); }); }, Math.max(1, Math.ceil((expiresAt - deps.now()) * 1000))).unref();
+                                        else
+                                            (await this.emitToSession(sessionId, 'notices', { session_id: sessionId, notices: this.sessionNotices(sessionId) }));
+                                    };
+                                    await emitAfterExpiry();
+                                }
+                                return;
+                            }
+                            case 'notice_clear':
+                            case 'notices_reset':
+                                if (frame.event === 'notice_clear' ? this.notices.clear(sessionId, str(data.key)) : this.notices.reset(sessionId))
+                                    (await emitFrame('notices', { session_id: sessionId, notices: this.sessionNotices(sessionId) }));
+                                return;
+                            default:
+                                await emitFrame(frame.event, data);
                         }
-                        case 'status':
-                            if (data.kind === 'terminal_error' && !capturedTerminalError)
-                                capturedTerminalError = str(data.message);
-                            return;
-                        default:
-                            put(frame.event, data);
-                    }
+                    }).catch((error) => { streamWriteError = error instanceof Error ? error : new Error(String(error)); });
                 },
             });
+            await streamWrites;
+            if (streamWriteError !== undefined)
+                throw streamWriteError;
             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);
+            // 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.
                 const interrupted = await this.interrupts.get(streamId);
                 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));
+                await this.finalizeCancelled(s, streamId, opts.ephemeral, interrupted?.checkpoint ? withImages(interrupted.checkpoint) : result.messages);
+                await put('cancel', (await this.cancelFrame(sessionId)));
                 return;
             }
             // Writeback only while this stream still owns the session (Python `_stream_writeback_is_current`).
             let current;
             try {
-                current = deps.store.get(sessionId);
+                current = (await deps.store.get(sessionId));
             }
             catch {
                 current = s;
@@ -654,15 +1034,15 @@ 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, 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 = this.publicTerminalSession(s);
+                    payload.session = (await 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);
+                    (await put(event, data));
+                await put('apperror', payload);
                 return;
             }
             // TAL-512: a btw turn passes the failure check above first, so its last assistant row is this turn's reply.
@@ -676,11 +1056,11 @@ export class TurnRunner {
                     }
                 }
                 succeeded = true;
-                opts.onDone?.(answer);
+                await opts.onDone?.(answer);
                 // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
-                put('done', { session: { session_id: sessionId, messages: resultMessages.map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer, terminal_state: answer.trim() ? 'completed' : 'no_response' });
+                await 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 });
+                    await deps.store.delete(sessionId, { tombstone: false });
                 }
                 catch { /* ignore */ }
                 deps.store.sessions.delete(sessionId);
@@ -707,8 +1087,9 @@ export class TurnRunner {
             const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, result.pending_steer, 'followup');
             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);
+            // The settled turn's own figures: a compaction it waited on (TAL-1005) installed an estimate its prompt now supersedes.
+            s.post_compression_context_tokens_estimate = result.compressed ? estimate : null;
             if (result.compressed) {
-                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));
@@ -733,20 +1114,11 @@ export class TurnRunner {
                 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.next_turn_threshold_tokens = result.context.next_turn_threshold_tokens ?? null;
+            if (result.compressed)
+                (await put('compressed', this.compressedFrame(s)));
             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;
+            this.clearPendingTurn(s);
             // TAL-576: a turn that ran means the provider has usable credentials again.
             s.process_wakeup_pause = null;
             const attachments = opts.attachments ?? [];
@@ -801,18 +1173,18 @@ 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);
+            this.settleStateDb(s, streamId, agentRows, { previousContext, read: settlement });
+            recordBackgroundReview(s, streamId);
+            await deps.store.save(s);
             deps.pending.clearApprovals(sessionId);
             deps.pending.clearClarifies(sessionId);
             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)
-                    put('state_saved', { session_id: sessionId, kind: 'memory', action: 'saved' });
-                for (const change of changes.skills)
-                    put('state_saved', { session_id: sessionId, kind: 'skill', action: change.action, name: change.name });
+                if (persistentChanges?.memory_saved)
+                    (await put('state_saved', { session_id: sessionId, kind: 'memory', action: 'saved' }));
+                for (const change of persistentChanges?.skills ?? [])
+                    (await put('state_saved', { session_id: sessionId, kind: 'skill', action: change.action, name: change.name }));
             }
             catch (error) {
                 deps.log(`[webui] persistent state change detection failed for ${sessionId}: ${error.message}`);
@@ -828,7 +1200,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 = this.publicTerminalSession(s);
+            const doneSession = (await 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];
@@ -847,58 +1219,80 @@ 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);
+            await put('metering', { session_id: sessionId, usage: meteringUsage(s), tps: doneUsage.tps ?? null, tps_available: doneUsage.tps !== undefined, estimated: false });
+            await put('done', donePayload);
             for (const [event, payload] of steerEvents)
-                put(event, payload);
+                (await put(event, payload));
             // The turn is over: release admission before the title work so a follow-up message is accepted while the
             // (up to two) title prompts run; the channel and journal stay open for the `title` events (Python retired the
             // worker before its daemon-thread title generation).
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
-            this.startSteerFollowUp(sessionId, leftovers);
+            // TAL-1005: a turn that settled at or above the next turn's threshold starts the compaction now, so the next message
+            // usually finds the session compacted; a follow-up turn admitted meanwhile joins it.
+            void deps.service().ensureCompacted(sessionId);
+            await 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 });
+            await put('stream_end', { session_id: sessionId });
             for (const r of work)
                 if (r.status === 'rejected')
                     throw r.reason;
             succeeded = true;
-            opts.onDone?.(lastAnswer(s.messages));
+            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.
+                    s.messages = s.messages.filter((m) => !(m.role === 'user' && m._turn_id === streamId));
+                    this.clearPendingTurn(s);
+                    if (isDict(s.extra.completion_acceptances))
+                        s.extra.completion_acceptances = Object.fromEntries(Object.entries(s.extra.completion_acceptances).filter(([, value]) => value !== streamId));
+                    await deps.store.save(s, { touchUpdatedAt: false });
+                }
+                await put('apperror', { type: 'error', terminal_state: 'error', message: readOnly, session_id: sessionId, session: (await this.publicTerminalSession(s)) });
+                return;
+            }
             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)) {
-                this.finalizeCancelled(s, streamId, opts.ephemeral);
-                put('cancel', this.cancelFrame(sessionId));
+                await this.finalizeCancelled(s, streamId, opts.ephemeral);
+                await put('cancel', (await this.cancelFrame(sessionId)));
                 return;
             }
             const message = error instanceof Error ? error.message : String(error);
             const condition = error instanceof SidecarError ? error.condition : undefined;
-            const classification = classifyProviderError(message, { condition });
-            const payload = providerErrorPayload(message, classification.type, classification.hint, deps.redactEnabled());
-            if (condition === 'sidecar_unavailable' || condition === 'agent_runtime_stale') {
-                payload.type = condition === 'agent_runtime_stale' ? 'agent_runtime_stale' : 'sidecar_unavailable';
-                payload.condition = condition;
-            }
+            const runtime = error instanceof SidecarError && ['sidecar_unavailable', 'agent_runtime_stale', 'agent_incompatible'].includes(error.condition)
+                ? runtimeFailureDetails(error.condition, error.data) : null;
+            const classification = runtime ? { label: 'Error', type: runtime.type, hint: '' } : classifyProviderError(message, { condition });
+            const payload = providerErrorPayload(runtime?.message ?? message, classification.type, classification.hint, deps.redactEnabled());
+            if (runtime)
+                Object.assign(payload, runtime);
             try {
                 let current = s;
                 try {
-                    current = deps.store.get(sessionId);
+                    current = (await deps.store.get(sessionId));
                 }
                 catch {
                     current = s;
                 }
                 if (current.active_stream_id === streamId) {
                     for (const [event, data] of this.takeSteerEventsBefore(streamId, 'apperror'))
-                        put(event, data);
-                    this.persistError(current, streamId, classification.label, payload, activeTurnToken);
+                        (await put(event, data));
+                    await this.persistError(current, settlement, streamId, classification.label, payload, activeTurnToken);
                     if (!opts.ephemeral)
-                        payload.session = this.publicTerminalSession(current);
+                        payload.session = (await this.publicTerminalSession(current));
                 }
             }
             catch (persistError) {
@@ -906,15 +1300,20 @@ export class TurnRunner {
             }
             payload.session_id = sessionId;
             payload.old_session_id = sessionId;
-            put('apperror', payload);
+            await put('apperror', payload);
         }
         finally {
-            this.teardown(sessionId, streamId);
+            await 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 (!succeeded)
-                opts.onFailed?.(failure);
-            this.startSteerFollowUp(sessionId, followUp);
+                await opts.onFailed?.(failure);
+            // TAL-1005: a Stop or an error after the turn ran on a compaction's result left that job's estimate under a context
+            // its prompt and work may have grown; the idle trigger judges the context measured again.
+            if (!succeeded && !ownershipRefused && !opts.ephemeral)
+                void deps.service().remeasureContext(sessionId).then((measured) => { if (measured)
+                    void deps.service().ensureCompacted(sessionId); });
+            await this.startSteerFollowUp(sessionId, followUp);
         }
     }
     /**
@@ -995,33 +1394,30 @@ 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());
+    async publicTerminalSession(s) {
+        return this.deps.service().windowedDetail(s, TRANSCRIPT_WINDOW);
     }
-    /**
-     * Python `_session_payload_with_terminal_window`: the same visible-message window contract as `GET /api/session?
-     * msg_limit=` (renderable rows, limited payload shape, windowed tool calls, todo state) with the full count.
-     */
-    terminalSessionPayload(s) {
-        const payload = withSessionWireFlags(s.compact({ contextLengthFor: this.deps.service().deps.contextLengthFor, modelOptionFor: this.deps.service().deps.modelOptionFor }), this.registry.liveIds);
-        payload.assistant_name = this.deps.service().assistantName(s);
-        payload.workspace_name = this.deps.service().workspaceNames()(s);
-        const service = this.deps.service();
-        const scened = service.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withMarkerKinds(withTurnIds(withAttachmentObjects(s.messages))), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true }));
-        const [window, offset] = messageWindowForDisplay(scened, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
-        const limited = messagesForLimitedPayload(withBodyExcerpts(withDisplayMedia(window, service.mediaProjector(s)), s.active_stream_id));
-        payload.messages = limited;
-        payload.message_count = s.messages.length;
-        payload._messages_offset = offset;
-        payload._messages_truncated = offset > 0;
-        attachTodoState(payload, s.messages, s.extra[UNSETTLED_TODO_KEY]);
-        payload.tool_calls = toolCallsForMessageWindow(s.tool_calls, offset, limited.length);
-        payload.compression_reference = compressionReference(s, scened);
-        return payload;
+    /** 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) {
+        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, () => this.deps.service().deps.contextLengthFor(s.model, s.model_provider)),
+        };
+        const sid = s.session_id;
+        return { session_id: sid, old_session_id: sid, new_session_id: sid, continuation_session_id: sid, message: 'Compression finished', usage };
+    }
+    /** Release only the pending admission metadata; transcript settlement belongs to the caller. */
+    clearPendingTurn(s) {
+        s.active_stream_id = null;
+        s.pending_user_message = null;
+        s.pending_attachments = [];
+        s.pending_started_at = null;
+        s.pending_user_source = null;
     }
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
     /** `runtimeProvider`: the provider the Agent resolved for the turn, when it reported one. */
-    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') {
@@ -1038,11 +1434,7 @@ export class TurnRunner {
         }
         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;
-        s.pending_user_message = null;
-        s.pending_attachments = [];
-        s.pending_started_at = null;
-        s.pending_user_source = null;
+        this.clearPendingTurn(s);
         this.appendPartialSnapshot(s, streamId);
         const hint = str(payload.hint);
         const errorMessage = { role: 'assistant', content: `**${label}:** ${str(payload.message) || label}${hint ? `\n\n*${hint}*` : ''}`, timestamp: Math.trunc(this.deps.now()), _error: true, _turn_id: streamId };
@@ -1068,14 +1460,12 @@ 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;
-        const stop = this.stopContexts.get(streamId);
-        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null, read });
+        this.settleStateDb(s, streamId, agentRows, { read });
         try {
-            this.deps.store.save(s);
+            (await this.deps.store.save(s));
         }
         catch (error) {
             this.deps.log(`[webui] WARNING: failed to save error turn for ${s.session_id}: ${error.message}`);
@@ -1086,6 +1476,20 @@ 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) {
+        const stop = this.stopContexts.get(streamId);
+        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
      * rows it committed past its starting read in `read`, the read its settlement uses.
@@ -1094,7 +1498,7 @@ export class TurnRunner {
         const stop = this.stopContexts.get(streamId);
         if (!stop)
             return null;
-        const after = stop.stateDbStartId;
+        const after = stop.stateDbStartGeneration !== null && read.generation !== null && stop.stateDbStartGeneration !== read.generation ? -1 : 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 });
     }
@@ -1143,11 +1547,11 @@ export class TurnRunner {
      * Python `_emit_cancel_event`: the terminal frame carries the settled session so tabs can render the partial without a
      * reload. TAL-364: no copy — clients show their one localized status for the `cancelled` outcome.
      */
-    cancelFrame(sessionId) {
+    async cancelFrame(sessionId) {
         let snapshot = null;
         if (sessionId)
             try {
-                snapshot = this.publicTerminalSession(this.deps.store.get(sessionId));
+                snapshot = (await this.publicTerminalSession((await this.deps.store.get(sessionId))));
             }
             catch {
                 snapshot = null;
@@ -1159,21 +1563,33 @@ export class TurnRunner {
      * turn's model context keeps what the Agent had captured (`checkpoint`, its canonical transcript) and the prose that
      * streamed, so the next request continues from it; the terminal row carries the outcome and no copy.
      */
-    finalizeCancelled(s, streamId, ephemeral, checkpoint = null) {
+    async finalizeCancelled(s, streamId, ephemeral, checkpoint = null) {
         if (this.registry.writebackOwners.get(s.session_id) !== streamId)
             return false;
         let current = s;
         try {
-            current = this.deps.store.get(s.session_id);
+            current = (await this.deps.store.get(s.session_id));
         }
         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 {
-                rmSync(this.deps.store.pathFor(current.session_id), { force: true });
+                await this.deps.store.delete(current.session_id, { tombstone: false });
             }
             catch { /* ignore */ }
             this.deps.store.sessions.delete(current.session_id);
@@ -1185,9 +1601,9 @@ 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.deps.service().settleStateDb(current, { turnId: streamId, previousContext: this.stopContexts.get(streamId)?.previousContext ?? [], agentRows: checkpoint, startId: this.stopContexts.get(streamId)?.stateDbStartId ?? null });
+                this.settleStateDb(current, streamId, checkpoint, { read });
                 try {
-                    this.deps.store.save(current);
+                    (await this.deps.store.save(current));
                 }
                 catch {
                     return false;
@@ -1195,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)
@@ -1212,13 +1626,12 @@ 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.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null, read });
+                this.settleStateDb(current, streamId, checkpoint, { read });
                 try {
-                    this.deps.store.save(current);
+                    (await this.deps.store.save(current));
                 }
                 catch {
                     return false;
@@ -1228,24 +1641,19 @@ 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);
-        current.active_stream_id = null;
-        current.pending_user_message = null;
-        current.pending_attachments = [];
-        current.pending_started_at = null;
-        current.pending_user_source = null;
+        this.clearPendingTurn(current);
         if (!quiet) {
             this.appendPartialSnapshot(current, streamId);
             current.messages.push({ role: 'assistant', content: '', _error: true, _terminal_state: 'cancelled', timestamp: Math.trunc(this.deps.now()), _turn_id: streamId });
         }
         this.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 });
+        this.settleStateDb(current, streamId, checkpoint, { read });
         try {
-            this.deps.store.save(current);
+            (await this.deps.store.save(current));
         }
         catch {
             return false;
@@ -1257,8 +1665,8 @@ export class TurnRunner {
         return true;
     }
     /** Push a frame onto the session's live chat stream from outside the turn (Python gateway notify callbacks). */
-    emitToSession(sessionId, event, data) {
-        this.sessionPuts.get(sessionId)?.(event, data);
+    async emitToSession(sessionId, event, data) {
+        await 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) {
@@ -1269,13 +1677,15 @@ export class TurnRunner {
         if (todos)
             s.extra[UNSETTLED_TODO_KEY] = todos;
     }
-    teardown(sessionId, streamId) {
+    async teardown(sessionId, streamId) {
+        this.runStatuses.delete(streamId);
         this.liveUsage.delete(streamId);
+        this.compressionSpans.delete(streamId);
         this.liveTodos.delete(streamId);
         const writer = this.writers.get(streamId);
         if (writer) {
             try {
-                writer.close();
+                (await writer.close());
             }
             catch { /* ignore */ }
             this.writers.delete(streamId);
@@ -1304,21 +1714,28 @@ export class TurnRunner {
         catch { /* best effort */ }
     }
     /** Journal files with a live writer (retention must leave them alone). */
-    activeJournalPaths() {
-        return new Set([...this.writers.values()].map((w) => this.deps.journal.pathFor(w.sessionId, w.runId)));
-    }
     // ── title ────────────────────────────────────────────────────────────────
     /** Python `_generate_llm_session_title_via_aux`: aux-route statuses (`llm_aux`, `llm_aux_retry`, `llm_*_aux`). */
     async llmTitle(s, userText, assistantText) {
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return { title: '', status: 'llm_error_aux', rawPreview: '' };
+        const service = this.deps.service();
+        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)))
+                return { title: '', status: 'read_only', rawPreview: '' };
             let raw = '';
             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 }, { timeoutMs: 15_000 });
+                const result = await sidecar.call('aux.complete', {
+                    profile_home: this.deps.profileHome(s.profile), task: 'title_generation',
+                    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);
             }
             catch (error) {
@@ -1339,6 +1756,43 @@ export class TurnRunner {
         }
         return { title: '', status, rawPreview: '' };
     }
+    /**
+     * TAL-902: `/refine [focus]` starts the Agent's memory/skill review of the chat's model context on its agent
+     * (`chat.refine`, the agent a turn would build); no turn starts. Without a chat, while a turn runs, or before anything
+     * was said it answers with the Agent's wording instead.
+     */
+    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(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.
+        if (this.deps.profileDeleting?.(s.profile ?? null))
+            throw new HttpFailure(409, `Profile '${str(s.profile)}' is being deleted.`);
+        const sidecar = this.deps.sidecar();
+        if (!sidecar)
+            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)) ?? {};
+        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 ?? {}),
+            ...this.agentWorkspace(s, (await this.deps.service().turnWorkspace(s))),
+        }, { timeoutMs: 120_000 })).output;
+    }
+    /**
+     * TAL-903: the workspace a session's agent is built at, and whether it is a host path (the profile's terminal runs
+     * locally). Only then does the Agent anchor AGENTS.md discovery and its memory provider there; `chat.start` and
+     * `chat.refine` send the same pair, so the agent `/refine` builds is the one the next turn reuses.
+     */
+    agentWorkspace(s, workspace) {
+        return { workspace, workspace_local: this.deps.workspaces.profileSupportsLocalIo(s.profile) };
+    }
     /**
      * 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).
@@ -1352,6 +1806,7 @@ export class TurnRunner {
         let rawPreview = '';
         if (assistantText)
             ({ title: next, status: llmStatus, rawPreview } = await this.llmTitle(s, userText, assistantText));
+        await this.deps.service().assertWritable(s);
         if (next)
             return { title: next, status: llmStatus, rawPreview };
         const fallback = fallbackTitleFromExchange(userText, assistantText);
@@ -1366,7 +1821,7 @@ export class TurnRunner {
     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}`); });
+        await this.backgroundTitle(s, () => Promise.resolve()).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) {
@@ -1378,8 +1833,8 @@ export class TurnRunner {
         const eligible = ['Untitled', 'New Chat', ''].includes(placeholder) || placeholder === titleFrom(s.messages, '') || invalidExisting || defaultTitle(s);
         const [userText, assistantText] = firstExchangeSnippets(s.messages);
         // Python `_put_title_status`: empty reason/title/raw_preview keys are omitted.
-        const status = (status, reason = '', title = '', rawPreview = '') => {
-            put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
+        const status = async (status, reason = '', title = '', rawPreview = '') => {
+            await put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
         };
         // Python ran the adaptive refresh only when the first-title job was not eligible.
         if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText) {
@@ -1387,21 +1842,25 @@ export class TurnRunner {
             return;
         }
         if (s.manual_title) {
-            status('skipped', 'manual_title', placeholder);
+            (await status('skipped', 'manual_title', placeholder));
             return;
         }
         // A missing config.yaml reads as `{}` (enabled); an unreadable one cannot confirm the user has not opted out.
         const cfg = await this.deps.profileConfig?.(s.profile ?? null);
         if (!cfg) {
-            status('skipped', 'config_unavailable', placeholder);
+            (await status('skipped', 'config_unavailable', placeholder));
             return;
         }
         if (!titleGenerationEnabled(cfg)) {
-            status('skipped', 'title_generation_disabled', placeholder);
+            (await status('skipped', 'title_generation_disabled', placeholder));
             return;
         }
         const generated = await this.llmTitle(s, userText, assistantText);
         const { status: llmStatus, rawPreview } = generated;
+        if (llmStatus === 'read_only') {
+            (await status('skipped', 'read_only', placeholder));
+            return;
+        }
         let next = generated.title;
         let source = llmStatus;
         if (!next) {
@@ -1414,26 +1873,30 @@ export class TurnRunner {
         const fallbackReason = source === 'fallback' && llmStatus ? `local_summary:${llmStatus}` : 'local_summary';
         let current = s;
         try {
-            current = this.deps.store.get(sessionId);
+            current = (await this.deps.store.get(sessionId));
         }
         catch {
             // A session deleted while the title prompt ran stays deleted.
-            if (this.deps.store.wasDeleted(sessionId))
+            if ((await this.deps.store.wasDeleted(sessionId)))
                 return;
             current = s;
         }
+        if ((await this.deps.service().isReadOnly(current))) {
+            (await status('skipped', 'read_only', str(current.title).trim()));
+            return;
+        }
         let effective = str(current.title).trim();
         let wrote = false;
         if (next) {
             const stillAuto = effective === placeholder || ['Untitled', 'New Chat', ''].includes(effective) || effective === titleFrom(current.messages, '') || looksInvalidGeneratedTitle(current.title) || defaultTitle(current);
             if (current.manual_title || !stillAuto) {
-                status('skipped', 'manual_title', effective);
+                (await status('skipped', 'manual_title', effective));
                 return;
             }
             if (next !== effective) {
                 current.title = next;
                 markSessionTitleGenerated(current);
-                this.deps.store.save(current, { touchUpdatedAt: false });
+                await this.deps.store.save(current, { touchUpdatedAt: false });
                 // Python `sync_session_title` after generation: the state.db row follows when `sync_to_insights` is on.
                 await this.deps.syncTitle?.(current);
                 this.deps.events.publish('title', { profile: current.profile, sessionId });
@@ -1442,11 +1905,11 @@ export class TurnRunner {
             }
         }
         if (wrote) {
-            status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
-            put('title', { session_id: sessionId, title: effective });
+            await status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
+            await put('title', { session_id: sessionId, title: effective });
         }
         else
-            status('skipped', source || 'unchanged', effective, rawPreview);
+            (await status('skipped', source || 'unchanged', effective, rawPreview));
     }
     /**
      * Python `_maybe_schedule_title_refresh` + `_run_background_title_refresh`: every N exchanges a generated title is
@@ -1463,7 +1926,7 @@ export class TurnRunner {
         // 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));
+        const run = (this.titleRefreshes.get(sessionId) ?? Promise.resolve()).catch(() => undefined).then(async () => { await this.applyTitleRefresh(sessionId, s, userText, assistantText, put, status); });
         this.titleRefreshes.set(sessionId, run);
         try {
             await run;
@@ -1474,44 +1937,48 @@ export class TurnRunner {
         }
     }
     async applyTitleRefresh(sessionId, s, userText, assistantText, put, status) {
-        const read = () => { try {
-            return this.deps.store.get(sessionId);
+        const read = async () => { try {
+            return (await this.deps.store.get(sessionId));
         }
         catch {
             return s;
         } };
-        const latest = read();
+        const latest = (await 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);
+            (await 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);
+            (await 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);
+            (await status('refresh_skipped', 'same_title', placeholder, rawPreview));
             return;
         }
-        const current = read();
+        const current = (await 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());
+            (await status('skipped', 'manual_title', str(current.title).trim()));
+            return;
+        }
+        if ((await this.deps.service().isReadOnly(current))) {
+            (await status('refresh_skipped', 'read_only', str(current.title).trim()));
             return;
         }
         current.title = next;
         markSessionTitleGenerated(current);
-        this.deps.store.save(current, { touchUpdatedAt: false });
+        await 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 });
+        await status('refreshed', llmStatus, next, rawPreview);
+        await put('title', { session_id: sessionId, title: next });
     }
     // ── cancel / steer ───────────────────────────────────────────────────────
     /**
@@ -1519,6 +1986,26 @@ export class TurnRunner {
      * `steer_withdrawn` (stopped) this Stop emitted, for the cancel response (TAL-426).
      */
     async cancel(streamId) {
+        const ownerCancelled = await this.deps.service().owner?.cancel(streamId);
+        if (ownerCancelled !== null && ownerCancelled !== undefined)
+            return { cancelled: ownerCancelled, withdrawn: [] };
+        // TAL-899: the user's Stop holds automatic turns, even one that lands after `done`, unless a newer turn already
+        // took the session: a late or retried Stop for a turn the user followed holds nothing.
+        const owner = this.registry.ownerSessionId(streamId) ?? this.registry.activeRuns.get(streamId)?.session_id;
+        if (owner && this.registry.writebackOwners.get(owner) === streamId) {
+            this.stopHeld.add(owner);
+            try {
+                const session = (await this.deps.store.get(owner));
+                session.automatic_turns_stop_held = true;
+                await this.deps.store.save(session, { touchUpdatedAt: false });
+            }
+            catch (error) {
+                this.deps.log(`[webui] WARNING: failed to persist Stop hold for session ${owner}; interrupting with the in-memory hold: ${error.message}`);
+            }
+        }
+        return (await this.stop(streamId));
+    }
+    async stop(streamId) {
         const channel = this.registry.peek(streamId);
         const run = this.registry.activeRuns.get(streamId);
         if (!channel && !run)
@@ -1553,24 +2040,24 @@ export class TurnRunner {
         if (sessionId) {
             let current = null;
             try {
-                current = this.deps.store.get(sessionId);
+                current = (await this.deps.store.get(sessionId));
             }
             catch {
                 current = null;
             }
             if (current?.active_stream_id === streamId) {
-                this.finalizeCancelled(current, streamId, run?.ephemeral, checkpoint);
+                await this.finalizeCancelled(current, streamId, run?.ephemeral, checkpoint);
             }
         }
         // The worker may already have written its terminal row while the interrupt was in flight; the stream is then
         // gone from the registry and this path must not add a second one.
         if (channel && this.registry.streams.has(streamId)) {
             const writer = this.writers.get(streamId) ?? null;
-            const emit = (event, data) => {
+            const emit = async (event, data) => {
                 let eventId = null;
                 if (writer) {
                     try {
-                        eventId = writer.appendSseEvent(event, data).event_id;
+                        eventId = (await writer.appendSseEvent(event, data)).event_id;
                     }
                     catch {
                         eventId = null;
@@ -1579,8 +2066,10 @@ export class TurnRunner {
                 channel.put([event, data, eventId]);
             };
             for (const [event, data] of steerEvents)
-                emit(event, data);
-            emit('cancel', this.cancelFrame(sessionId));
+                (await emit(event, data));
+            this.runStatuses.delete(streamId);
+            await emit('run_status', { session_id: sessionId, status: null });
+            await emit('cancel', (await this.cancelFrame(sessionId)));
             this.registry.streams.delete(streamId);
             this.registry.liveIds.delete(streamId);
         }
@@ -1596,7 +2085,7 @@ export class TurnRunner {
         const streamId = this.registry.activeRunStreamForSession(sessionId);
         if (!streamId || this.registry.activeRuns.get(streamId)?.origin !== 'background')
             return false;
-        await this.cancel(streamId);
+        await this.stop(streamId);
         let timer;
         await Promise.race([this.workers.get(streamId), new Promise((resolve) => { timer = setTimeout(resolve, BACKGROUND_UNWIND_WAIT_MS); })]);
         clearTimeout(timer);
@@ -1605,7 +2094,7 @@ export class TurnRunner {
     async steer(sessionId, text, displayText, steerId) {
         let s = null;
         try {
-            s = this.deps.store.get(sessionId, { metadataOnly: true });
+            s = (await this.deps.store.get(sessionId, { metadataOnly: true }));
         }
         catch {
             s = null;
@@ -1624,7 +2113,7 @@ export class TurnRunner {
             return { accepted: false, fallback: 'no_cached_agent', stream_id: null };
         // Register provisionally before the RPC: the Agent may apply the steer and finish the turn before the steer
         // reply arrives, and the turn's finalisation must then already see the record. A rejection removes it again.
-        return this.withSteerChain(activeStreamId, () => this.steerInto(sidecar, sessionId, activeStreamId, text, displayText, steerId));
+        return this.withSteerChain(activeStreamId, sessionId, () => this.steerInto(sidecar, sessionId, activeStreamId, text, displayText, steerId));
     }
     async steerInto(sidecar, sessionId, activeStreamId, text, displayText, steerId) {
         const record = { steer_id: steerId, session_id: sessionId, stream_id: activeStreamId, text, display_text: displayText || text, created_at: this.deps.now(), state: 'pending', can_redirect: false };
@@ -1656,7 +2145,7 @@ export class TurnRunner {
             record.can_redirect = result.can_redirect === true;
             // TAL-424: every client shows it until the Agent takes it (unless it already did while the reply was in flight).
             if (this.steers.get(activeStreamId)?.includes(record))
-                this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+                (await this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record)));
         }
         return { accepted: result.accepted, fallback: result.accepted ? null : (result.fallback ?? 'not_running'), stream_id: activeStreamId, steer_id: steerId };
     }
@@ -1725,10 +2214,10 @@ export class TurnRunner {
         return boundary;
     }
     /** A steer is saved as it enters the stream, so a reload mid-turn already has it; the terminal save re-places it. */
-    saveConsumedSteers(sessionId, streamId) {
+    async saveConsumedSteers(sessionId, streamId) {
         let s;
         try {
-            s = this.deps.store.get(sessionId);
+            s = (await this.deps.store.get(sessionId));
         }
         catch {
             return;
@@ -1736,7 +2225,7 @@ export class TurnRunner {
         if (s.active_stream_id !== streamId || this.placeConsumedSteers(s, streamId, s.pending_started_at) === null)
             return;
         try {
-            this.deps.store.save(s, { touchUpdatedAt: false });
+            (await this.deps.store.save(s, { touchUpdatedAt: false }));
         }
         catch (error) {
             this.deps.log(`[webui] WARNING: failed to save consumed steer for ${sessionId}: ${error.message}`);
@@ -1796,18 +2285,18 @@ export class TurnRunner {
      * TAL-424: the steers a finished turn never took go on as one follow-up turn, sent once by the server for every client.
      * Should another turn already hold the session, they steer into that one instead, so no text is lost.
      */
-    startSteerFollowUp(sessionId, texts) {
+    async startSteerFollowUp(sessionId, texts) {
         if (!texts.length)
             return;
         let s;
         try {
-            s = this.deps.store.get(sessionId);
+            s = (await this.deps.store.get(sessionId));
         }
         catch {
             return;
         }
         const msg = texts.join('\n');
-        const started = this.start(s, { msg, attachments: [], workspace: s.workspace, model: s.model, modelProvider: s.model_provider });
+        const started = (await this.startServerTurn(s, { msg }));
         if (!started._status || started._status < 400)
             return;
         if (started._status === 409 && started.active_stream_id) {
@@ -1835,61 +2324,88 @@ export class TurnRunner {
         // Only a known goal turn shows progress up front; any other turn shows nothing unless a goal turns out to be active.
         const goalTurn = this.registry.goalRelated.has(streamId);
         if (goalTurn)
-            put('goal', { session_id: sessionId, state: 'evaluating', message: 'Evaluating goal progress…', message_key: 'goal_evaluating_progress' });
+            (await put('goal', { session_id: sessionId, state: 'evaluating', message: 'Evaluating goal progress…', message_key: 'goal_evaluating_progress' }));
         let decision;
         try {
-            decision = await sidecar.call('goals.evaluate', { session_id: sessionId, profile_home: this.deps.profileHome(s.profile), last_response: lastResponse, user_initiated: true });
+            // The workspace the turn ran in, unrecovered: the Agent pauses the goal rather than run its gates anywhere else.
+            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) {
             this.deps.log(`[webui] WARNING: goal evaluation failed for ${sessionId}: ${error.message}`);
             if (goalTurn)
-                put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' });
+                (await put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' }));
             return;
         }
+        // The judgement moved the goal on (turns, park, pause, done); an inactive one only matters if a goal still shows.
+        if (decision.verdict !== 'inactive' || this.goals.view(sessionId))
+            await this.refreshGoal(s, put);
         if (!goalTurn && decision.verdict === 'inactive')
             return;
         const prompt = str(decision.continuation_prompt).trim();
         const proceed = decision.should_continue && Boolean(prompt);
         const status = { message: decision.message, message_key: decision.message_key, message_args: decision.message_args ?? [], decision: decision.verdict };
-        put('goal', { session_id: sessionId, state: proceed ? 'continuing' : 'idle', ...status });
-        if (!proceed)
+        if (!proceed) {
+            (await put('goal', { session_id: sessionId, state: 'idle', ...status }));
             return;
+        }
         let current;
         try {
-            current = this.deps.store.get(sessionId);
+            current = (await this.deps.store.get(sessionId));
         }
         catch {
             return;
         }
-        const started = this.start(current, { msg: prompt, attachments: [], workspace: current.workspace, model: current.model, modelProvider: current.model_provider, goalRelated: true });
+        const started = (await this.startServerTurn(current, { msg: prompt, goalRelated: true }));
+        // TAL-899: a Stop, even one after the answer, holds the continuation; the user's next turn is judged instead.
+        if (started.held) {
+            (await put('goal', { session_id: sessionId, state: 'idle', decision: 'held', message: '' }));
+            return;
+        }
+        await put('goal', { session_id: sessionId, state: 'continuing', ...status });
         if (started._status === 409 && started.active_stream_id) {
             this.registry.goalRelated.add(started.active_stream_id);
             return;
         }
         if (started._status !== undefined && started._status >= 400) {
             this.deps.log(`[webui] WARNING: goal continuation for ${sessionId} not started (${String(started._status)}): ${str(started.error)}`);
-            put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' });
+            await put('goal', { session_id: sessionId, state: 'idle', decision: 'error', message: '' });
             return;
         }
-        put('goal_continue', { session_id: sessionId, state: 'continuing', continuation_prompt: prompt, text: prompt, stream_id: str(started.stream_id), ...status });
+        await put('goal_continue', { session_id: sessionId, state: 'continuing', continuation_prompt: prompt, text: prompt, stream_id: str(started.stream_id), ...status });
     }
     /** The Agent's pending steer text settles which steers it has taken: those become `steer_consumed` and their rows. */
-    settleConsumedSteers(sessionId, streamId, pendingText) {
+    async settleConsumedSteers(sessionId, streamId, pendingText) {
         for (const record of this.takeConsumedSteers(streamId, pendingText, { keepLeftovers: true }))
-            this.emitToSession(sessionId, 'steer_consumed', record);
-        this.saveConsumedSteers(sessionId, streamId);
+            (await this.emitToSession(sessionId, 'steer_consumed', record));
+        await this.saveConsumedSteers(sessionId, streamId);
     }
     /** What every client shows for a pending steer; the server decides which actions it offers. */
     pendingSteerView(r) {
         const open = r.state === 'pending';
         return { steer_id: r.steer_id, text: r.display_text, submitted_at: r.created_at, state: r.state, actions: { edit: open, cancel: open, send_now: open && r.can_redirect } };
     }
+    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;
+    }
+    /** TAL-1006: the start (epoch seconds) of the stream's open compression span, else null. */
+    compressionStartedAt(streamId) {
+        return this.compressionSpans.get(streamId) ?? null;
+    }
     /** TAL-424: the active stream's pending steers, oldest first (session detail `pending_steers`). */
     pendingSteers(streamId) {
         return (this.steers.get(streamId) ?? []).map((r) => this.pendingSteerView(r));
     }
-    withSteerChain(streamId, fn) {
-        const run = (this.steerChains.get(streamId) ?? Promise.resolve()).then(fn);
+    withSteerChain(streamId, sessionId, fn) {
+        const run = (this.steerChains.get(streamId) ?? Promise.resolve()).then(async () => {
+            await this.deps.service().getForMutation(sessionId);
+            return fn();
+        });
         const settled = run.catch(() => undefined).then(() => { if (this.steerChains.get(streamId) === settled)
             this.steerChains.delete(streamId); });
         this.steerChains.set(streamId, settled);
@@ -1903,7 +2419,7 @@ export class TurnRunner {
     async rewriteSteer(sessionId, steerId, fallback, rewrite) {
         let s = null;
         try {
-            s = this.deps.store.get(sessionId, { metadataOnly: true });
+            s = (await this.deps.store.get(sessionId, { metadataOnly: true }));
         }
         catch {
             s = null;
@@ -1911,21 +2427,21 @@ export class TurnRunner {
         const streamId = s?.active_stream_id;
         const sidecar = this.deps.sidecar();
         if (!streamId || !sidecar)
-            return fallback;
-        return this.withSteerChain(streamId, async () => {
+            return fallback('not_running');
+        return this.withSteerChain(streamId, sessionId, async () => {
             const records = this.steers.get(streamId) ?? [];
             const index = records.findIndex((r) => r.steer_id === steerId);
             if (index < 0 || records[index].state !== 'pending')
-                return fallback;
+                return fallback('taken');
             // In flight before the sidecar call, so a pending-text report racing its reply is deferred too.
             let finished = () => undefined;
             this.steerRewrites.set(streamId, new Promise((resolve) => { finished = resolve; }));
-            let outcome = { result: fallback, changed: false };
+            let outcome = { result: fallback('failed'), changed: false };
             try {
                 outcome = await rewrite(sidecar, streamId, records, index);
             }
             catch {
-                outcome = { result: fallback, changed: false };
+                outcome = { result: fallback('failed'), changed: false };
             }
             finally {
                 this.steerRewrites.delete(streamId);
@@ -1933,7 +2449,7 @@ export class TurnRunner {
                 const deferred = this.deferredPendingSteer.get(streamId);
                 this.deferredPendingSteer.delete(streamId);
                 if (deferred !== undefined && !outcome.changed)
-                    this.settleConsumedSteers(sessionId, streamId, deferred);
+                    (await this.settleConsumedSteers(sessionId, streamId, deferred));
             }
             return outcome.result;
         });
@@ -1948,54 +2464,61 @@ export class TurnRunner {
      * TAL-424 Edit and Cancel: take a pending steer back before the Agent takes it. `withdrawn: false` (and nothing
      * emitted) when it is unknown, already taken or being sent; a taken one then settles as consumed.
      */
-    withdrawSteer(sessionId, steerId, reason) {
-        return this.rewriteSteer(sessionId, steerId, { withdrawn: false }, async (sidecar, streamId, records, index) => {
+    async withdrawSteer(sessionId, steerId, reason) {
+        return (await this.rewriteSteer(sessionId, steerId, () => ({ withdrawn: false }), async (sidecar, streamId, records, index) => {
             const record = records[index];
             const reply = await sidecar.call('chat.steer_withdraw', { stream_id: streamId, pending: records.map((r) => r.text), index });
             if (!reply.withdrawn)
                 return { result: { withdrawn: false }, changed: false };
             this.dropSteer(streamId, record);
-            this.emitToSession(sessionId, 'steer_withdrawn', { steer_id: record.steer_id, reason, text: record.display_text });
+            await this.emitToSession(sessionId, 'steer_withdrawn', { steer_id: record.steer_id, reason, text: record.display_text });
             return { result: { withdrawn: true, text: record.display_text }, changed: true };
-        });
+        }));
     }
     /**
      * TAL-424 Send now: deliver a pending steer with the Agent's redirect. A model request restarts with it (consumed at
      * once); during tools it goes last on the Agent's queue and stays `sending_now` until taken; with nothing live it
      * stays pending.
      */
-    sendSteerNow(sessionId, steerId) {
-        return this.rewriteSteer(sessionId, steerId, { redirected: false }, async (sidecar, streamId, records, index) => {
+    async sendSteerNow(sessionId, steerId) {
+        return (await this.rewriteSteer(sessionId, steerId, (outcome) => ({ redirected: false, outcome }), async (sidecar, streamId, records, index) => {
             const record = records[index];
             if (!record.can_redirect)
-                return { result: { redirected: false }, changed: false };
+                return { result: { redirected: false, outcome: 'failed' }, changed: false };
             const reply = await sidecar.call('chat.steer_now', { stream_id: streamId, pending: records.map((r) => r.text), index });
             if (!reply.withdrawn)
-                return { result: { redirected: false }, changed: false };
+                return { result: { redirected: false, outcome: reply.reason === 'not_running' ? 'not_running' : 'taken' }, changed: false };
             if (!reply.redirected) {
                 // The Agent's queue changed meanwhile, so it went back last: clients follow the new order.
                 if (reply.requeued === 'last') {
                     this.dropSteer(streamId, record);
                     records.push(record);
-                    this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+                    (await this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record)));
                 }
-                return { result: { redirected: false }, changed: true };
+                return { result: { redirected: false, outcome: 'next_step' }, changed: true };
             }
             this.dropSteer(streamId, record);
             if (reply.delivery === 'steer') {
                 record.state = 'sending_now';
                 records.push(record);
-                this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
+                await this.emitToSession(sessionId, 'steer_pending', this.pendingSteerView(record));
             }
             else {
-                this.emitToSession(sessionId, 'steer_consumed', this.consumedSteerPayload(record, { redirected: true }));
-                this.saveConsumedSteers(sessionId, streamId);
+                await this.emitToSession(sessionId, 'steer_consumed', this.consumedSteerPayload(record, { redirected: true }));
+                await this.saveConsumedSteers(sessionId, streamId);
             }
-            return { result: { redirected: true }, changed: true };
-        });
+            return { result: { redirected: true, outcome: 'delivered' }, changed: true };
+        }));
     }
     // ── approvals / clarify ──────────────────────────────────────────────────
     async respondApproval(sessionId, choice, approvalId, enableYolo) {
+        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);
+            return { ok: true, choice };
+        }
+        sessionId = (await this.deps.service().idForMutation(sessionId));
         // Python `_enable_session_yolo_and_release_pending`: a stale card id while another approval is parked
         // must not commit YOLO for the whole session — fail closed with the relay envelope instead.
         if (enableYolo && approvalId && !this.deps.pending.hasApprovalId(sessionId, approvalId) && this.deps.pending.hasPendingApproval(sessionId)) {
@@ -2008,7 +2531,7 @@ export class TurnRunner {
         const relayFailure = (message) => ({ ok: false, choice, error: `The Agent sidecar did not accept the approval (${message}); retry in a moment.`, _status: 503 });
         let s = null;
         try {
-            s = this.deps.store.get(sessionId, { metadataOnly: true });
+            s = (await this.deps.store.get(sessionId, { metadataOnly: true }));
         }
         catch {
             s = null;
@@ -2050,7 +2573,7 @@ export class TurnRunner {
                         return relayFailure(str(error.message));
                     }
                 }
-                this.deps.service().setYolo(sessionId, true);
+                await this.deps.service().setYolo(sessionId, true);
                 return null;
             });
             if (failure)
@@ -2084,17 +2607,21 @@ export class TurnRunner {
             return;
         }
         if (this.deps.pending.dropApprovals(sessionId, new Set(before.filter((id) => !live.has(id)))).length)
-            this.emitToSession(sessionId, ...this.approvalHeadFrame(sessionId));
+            (await this.emitToSession(sessionId, ...this.approvalHeadFrame(sessionId)));
     }
     withYoloLock(sessionId, fn) {
-        const run = (this.yoloChains.get(sessionId) ?? Promise.resolve()).then(fn);
+        const run = (this.yoloChains.get(sessionId) ?? Promise.resolve()).then(async () => {
+            sessionId = (await this.deps.service().idForMutation(sessionId));
+            return fn();
+        });
         const settled = run.catch(() => undefined).then(() => { if (this.yoloChains.get(sessionId) === settled)
             this.yoloChains.delete(sessionId); });
         this.yoloChains.set(sessionId, settled);
         return run;
     }
     /** Python `set_session_yolo_enabled(False)`: the sidecar must drop its per-session YOLO state before the local flag clears. */
-    disableYolo(sessionId) {
+    async disableYolo(sessionId) {
+        sessionId = (await this.deps.service().idForMutation(sessionId));
         return this.withYoloLock(sessionId, async () => {
             const sidecar = this.deps.sidecar();
             if (sidecar) {
@@ -2105,7 +2632,7 @@ export class TurnRunner {
                     return { ok: false, error: `The Agent sidecar did not disable YOLO (${str(error.message)}); retry in a moment.`, yolo_enabled: this.deps.service().yolo(sessionId).yolo_enabled === true, _status: 503 };
                 }
             }
-            return this.deps.service().setYolo(sessionId, false);
+            return (await this.deps.service().setYolo(sessionId, false));
         });
     }
     /**
@@ -2114,16 +2641,25 @@ export class TurnRunner {
      * did not acknowledge (prompt retained).
      */
     async respondClarify(sessionId, clarifyId, reply) {
+        if (await this.deps.service().owner?.isOwned(sessionId)) {
+            await this.deps.service().owner.respond(sessionId, 'clarify', clarifyId, reply);
+            return { ok: true };
+        }
+        sessionId = (await this.deps.service().idForMutation(sessionId));
         const entry = this.deps.pending.peekClarify(sessionId, clarifyId);
         if (!entry)
             return { ok: false, stale: true };
-        const response = typeof reply === 'string' ? reply : clarifyReply(entry, reply);
+        // TAL-887: a password-manager answer goes to the Agent and nowhere else; `null` (a decline) is its empty reply.
+        const vault = isVaultPrompt(entry);
+        if (vault && typeof reply === 'string')
+            return { ok: false, invalid: true };
+        const response = vault ? vaultReply(entry, reply) : reply === null ? null : 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 };
+            return vault ? { ok: true } : { ok: true, response };
         }
         const sidecar = this.deps.sidecar();
         if (!sidecar)
@@ -2133,14 +2669,16 @@ export class TurnRunner {
             ok = (await sidecar.call('clarify.respond', { session_id: sessionId, clarify_id: str(entry.clarify_id), response })).ok;
         }
         catch (error) {
+            if (vault)
+                return { ok: false, error: 'The Agent sidecar did not accept the secure answer; retry in a moment.' };
             return { ok: false, error: `The Agent sidecar did not accept the answer (${str(error.message)}); retry in a moment.` };
         }
         if (!ok)
             return { ok: false, stale: true };
         const { head } = this.deps.pending.resolveClarify(sessionId, str(entry.clarify_id));
         if (head)
-            this.emitToSession(sessionId, 'clarify', head);
-        return { ok: true, response };
+            (await this.emitToSession(sessionId, 'clarify', head));
+        return vault ? { ok: true } : { ok: true, response };
     }
 }
 /** The turn's answer: the last non-error assistant reply with content. */