@maudecode/talaria-web 1.17.2 → 1.18.0

package/dist/sessions/turn.js

@@ -15,7 +15,7 @@ import { StreamRegistry, SessionChannels } from './streams.js';
 import { ChatUsageSchema } from '@maudecode/talaria-web-contracts';
 import { PendingPrompts, clarifyReply } from './pending.js';
 import { RunJournal } from './journal.js';
-import { CONTEXT_USAGE_FIELDS, Session, contextUsage, titleFrom } from './session.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';
@@ -26,12 +26,14 @@ import { withSessionWireFlags } from './list.js';
 import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, stoppedTurnContext, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, workspaceContextPrefix, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
 import { mayBecomeSilentReply, turnOrigin, withBackgroundUpdates } from './background-updates.js';
-import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
+import { countExchanges, fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
 import { WORKSPACE_BUSY_MESSAGE } from '../workspace/git.js';
+import { CHECKPOINT_STORE_BUSY_MESSAGE } from '../workspace/rollback.js';
 import { str } from '../util.js';
 import { toolEditDiff } from './tool-display.js';
+import { recordWakeupPause } from './wakeup-pause.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
 const IMAGE_MODE_TIMEOUT_MS = 15_000;
 const TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT = 80;
@@ -71,7 +73,7 @@ export function classifyProviderError(errStr, opts = {}) {
     if (['interrupted by user', 'response interrupted', 'operation interrupted', 'operation was interrupted', 'operation aborted', 'request was aborted', 'aborterror'].some((k) => lower.includes(k))) {
         return { label: 'Response interrupted', type: 'interrupted', hint: 'The run stopped before a provider response completed. If you did not cancel it, try again.' };
     }
-    const quota = ['insufficient_quota', 'insufficient credits', 'out of credits', 'credits exhausted', 'quota exceeded', 'usage limit', 'plan limit', 'billing'].some((k) => lower.includes(k));
+    const quota = ['insufficient_quota', 'insufficient credits', 'out of credits', 'credits exhausted', 'quota exceeded', 'usage limit', 'plan limit', 'billing', 'more credits', 'can only afford', 'fewer max_tokens', 'credit balance', 'exceeded your current quota', 'usage_limit_exceeded', 'reached the limit of messages', 'used up your usage'].some((k) => lower.includes(k));
     const poolEmpty = lower.includes('credential(s) exhausted') || lower.includes('credentials exhausted') || (lower.includes('credential') && lower.includes('exhausted'));
     const auth = !quota && !poolEmpty && (errStr.includes('401') || lower.includes('authentication') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('invalid_api_key') || lower.includes('no cookie auth credentials'));
     const notFound = errStr.includes('404') || lower.includes('not found') || lower.includes('does not exist') || lower.includes('model_not_found') || lower.includes('invalid model') || lower.includes('does not match any known model') || lower.includes('unknown model');
@@ -125,8 +127,6 @@ export function sniffImageMime(bytes, declared = '') {
         return 'image/bmp';
     return null;
 }
-const COMPRESSION_RECOVERY_TERMINAL_STATE = 'compression_exhausted';
-const COMPRESSION_RECOVERY_ACTION_START_FOCUSED = 'start_focused_continuation';
 /** Python `build_compression_recovery_payload` + `stamp_compression_exhausted_recovery`. */
 export function stampCompressionExhaustedRecovery(s, message, details) {
     const positive = (v) => { const n = Math.trunc(Number(v) || 0); return n > 0 ? n : 0; };
@@ -211,6 +211,8 @@ export class TurnRunner {
     liveTodos = new Map();
     /** Streams whose run completed (`done` emitted) and only await title work; a late cancel is a no-op for these. */
     settledStreams = new Set();
+    /** The last adaptive title refresh per session; a successor turn's refresh runs after it (TAL-589). */
+    titleRefreshes = new Map();
     /**
      * TAL-364: what a Stop needs to write the turn's model context: its starting context, the prompt the Agent got, and
      * whether a settlement already used a canonical checkpoint (which marks the stop boundary; later work never replaces it).
@@ -234,6 +236,8 @@ export class TurnRunner {
             return { error: `Profile '${str(s.profile)}' is being deleted.`, _status: 409 };
         if (this.deps.workspaceBusy?.(opts.workspace))
             return { error: WORKSPACE_BUSY_MESSAGE, _status: 409 };
+        if (this.deps.checkpointStoreBusy?.(s.profile ?? null))
+            return { error: CHECKPOINT_STORE_BUSY_MESSAGE, _status: 409 };
         const locked = s.active_stream_id;
         if (locked) {
             if (this.registry.liveIds.has(locked) || this.registry.activeRuns.has(locked))
@@ -291,6 +295,10 @@ export class TurnRunner {
             response.effective_model_provider = opts.modelProvider;
         return response;
     }
+    /** Resolves once the stream's worker has ended (settled, failed, or torn down); it never rejects. */
+    finished(streamId) {
+        return this.workers.get(streamId) ?? Promise.resolve();
+    }
     /** Python `_checkpoint_user_message_for_eager_session_save`. */
     checkpointUserMessage(s, msg, attachments, startedAt, source, turnId) {
         const latest = s.messages[s.messages.length - 1];
@@ -309,7 +317,12 @@ export class TurnRunner {
         catch (error) {
             deps.log(`[webui] WARNING: run journal degraded for stream ${streamId}: ${error.message}`);
         }
+        const failure = { apperror: null, cancelled: false };
         const put = (event, data, meta = {}) => {
+            if (event === 'apperror')
+                failure.apperror = data;
+            else if (event === 'cancel')
+                failure.cancelled = true;
             for (const steerEvent of this.takeSteerEventsBefore(streamId, event))
                 put(steerEvent[0], steerEvent[1]);
             if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn'].includes(event))
@@ -358,14 +371,14 @@ export class TurnRunner {
         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);
-        const previousContext = structuredClone(deps.service().modelContext(s, startRead.rows));
+        // 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 workspaceCtx = workspaceContextPrefix(opts.workspace);
         // Before the first await: a Stop can land at any point after admission.
-        // An eager save already put this turn's prompt in the transcript; the Stop fallback appends it once itself.
-        this.stopContexts.set(streamId, { previousContext: previousContext.filter((m) => m._turn_id !== streamId), historyLength: apiHistory.length, prompt: workspaceCtx + msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null });
+        this.stopContexts.set(streamId, { previousContext, historyLength: apiHistory.length, prompt: msgText, msgText, checkpointed: false, stateDbStartId: startRead.ok ? stateDbSeenId(startRead.rows) ?? 0 : null });
         const activeTurnToken = buildActiveTurnToken(streamId, s.pending_started_at);
         const sidecar = deps.sidecar();
         const partialText = this.registry.partialText.get(streamId) ?? [];
@@ -411,7 +424,7 @@ export class TurnRunner {
         // TAL-545: one image mode decides both this turn's upload and the replayed history, which a text-mode turn sends
         // without native images; only a turn with an image on either side asks for it.
         const imageMode = attachments.some(isImageAttachment) || hasNativeImages(apiHistory) ? await this.imageInputMode(sessionId, s, opts, controller.signal) : null;
-        const userMessage = this.buildUserMessage(workspaceCtx, msgText, attachments, opts.workspace, sessionId, imageMode);
+        const userMessage = this.buildUserMessage(msgText, attachments, opts.workspace, sessionId, imageMode);
         const conversationHistory = imageMode === 'text' ? withoutNativeImages(apiHistory) : apiHistory;
         // The prompt the Agent actually gets, native image parts included.
         const stop = this.stopContexts.get(streamId);
@@ -420,14 +433,15 @@ export class TurnRunner {
         if (activeRun)
             activeRun.phase = 'running';
         const settledAt = { value: false };
-        let failed = false;
+        let succeeded = false;
         // TAL-424: steers an errored turn ended without taking, sent as one follow-up turn once this one is torn down.
         let followUp = [];
         try {
             if (!sidecar)
                 throw new SidecarError('The Agent sidecar is not running; chat is unavailable until it starts.', { condition: 'sidecar_unavailable' });
             // Python: budgets, reasoning config, personality and delivery context come from the profile's config.yaml; the
-            // system message carries the frozen session workspace, the WebUI guidance rides as the ephemeral prompt.
+            // system message carries the frozen session workspace, the WebUI guidance rides as the ephemeral prompt with this
+            // turn's workspace (TAL-710: never a tag on the user's message, which the Agent can persist from memory).
             const cfg = (await deps.profileConfig?.(s.profile ?? null)) ?? {};
             // The sidecar's per-session YOLO state does not survive its restarts: push the local flag (either way) before
             // the turn so a stale sidecar-side enable cannot auto-approve a session the UI reports as guarded.
@@ -442,10 +456,9 @@ export class TurnRunner {
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
-            const frozenWorkspace = str(s.created_workspace) || str(s.workspace);
             const turnContext = {
-                system_message: workspaceSystemMessage(frozenWorkspace),
-                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personality: str(s.personality) || null, sessionId, profile: s.profile ?? null, workspace: frozenWorkspace, hermesHome: deps.profileHome(s.profile), homeDisplay: deps.homeDisplay?.() ?? '~/.hermes', background: turnOrigin(opts.source) === 'background' }),
+                system_message: workspaceSystemMessage(str(s.created_workspace) || str(s.workspace)),
+                ephemeral_system_prompt: webuiEphemeralSystemPrompt({ config: cfg, personality: str(s.personality) || null, sessionId, profile: s.profile ?? null, workspace: opts.workspace, hermesHome: deps.profileHome(s.profile), homeDisplay: deps.homeDisplay?.() ?? '~/.hermes', background: turnOrigin(opts.source) === 'background' }),
                 max_iterations: processWakeupMaxIterations(maxIterationsFromConfig(cfg), opts.source ?? 'webui', deps.env ?? {}),
                 max_tokens: maxTokensFromConfig(cfg),
                 reasoning_config: reasoningConfigFromConfig(cfg, opts.modelProvider ?? s.model_provider ?? null),
@@ -641,16 +654,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);
+                this.persistError(s, streamId, classification.label, payload, activeTurnToken, resultMessages, result.provider);
                 // TAL-512: a btw error carries no session: its journaled frame must not keep a copy of the parent conversation.
                 if (!opts.ephemeral)
-                    payload.session = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
+                    payload.session = this.publicTerminalSession(s);
                 payload.session_id = s.session_id;
                 payload.old_session_id = sessionId;
                 for (const [event, data] of steerEvents)
                     put(event, data);
                 put('apperror', payload);
-                failed = true;
                 return;
             }
             // TAL-512: a btw turn passes the failure check above first, so its last assistant row is this turn's reply.
@@ -663,6 +675,7 @@ export class TurnRunner {
                         break;
                     }
                 }
+                succeeded = true;
                 opts.onDone?.(answer);
                 // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
                 put('done', { session: { session_id: sessionId, messages: 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' });
@@ -734,6 +747,8 @@ export class TurnRunner {
             s.pending_attachments = [];
             s.pending_started_at = null;
             s.pending_user_source = null;
+            // TAL-576: a turn that ran means the provider has usable credentials again.
+            s.process_wakeup_pause = null;
             const attachments = opts.attachments ?? [];
             if (attachments.length) {
                 for (let i = s.messages.length - 1; i >= 0; i -= 1) {
@@ -813,7 +828,7 @@ export class TurnRunner {
                 cache_hit_percent: cacheHit(cacheReadTokens, inputTokens), turn_cache_hit_percent: cacheHit(turnCacheRead, turnInput), duration_seconds: Math.round(duration * 1000) / 1000,
                 context_length: s.context_length ?? 0, threshold_tokens: s.threshold_tokens ?? 0, last_prompt_tokens: s.last_prompt_tokens ?? 0,
             };
-            const doneSession = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
+            const doneSession = this.publicTerminalSession(s);
             // TAL-299: the ring's figures match the terminal session's (and a detail reload's).
             for (const key of CONTEXT_USAGE_FIELDS)
                 doneUsage[key] = doneSession[key];
@@ -850,14 +865,13 @@ export class TurnRunner {
             for (const r of work)
                 if (r.status === 'rejected')
                     throw r.reason;
-            // Python: the last non-error assistant reply with content, else "(no answer produced)".
-            opts.onDone?.(lastAnswer(s.messages) || '(no answer produced)');
+            succeeded = true;
+            opts.onDone?.(lastAnswer(s.messages));
         }
         catch (error) {
             if (settledAt.value && !(error instanceof SidecarError)) {
                 deps.log(`[webui] ERROR settling turn ${streamId}\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
             }
-            failed = true;
             if (this.registry.cancelled.has(streamId)) {
                 this.finalizeCancelled(s, streamId, opts.ephemeral);
                 put('cancel', this.cancelFrame(sessionId));
@@ -884,7 +898,7 @@ export class TurnRunner {
                         put(event, data);
                     this.persistError(current, streamId, classification.label, payload, activeTurnToken);
                     if (!opts.ephemeral)
-                        payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
+                        payload.session = this.publicTerminalSession(current);
                 }
             }
             catch (persistError) {
@@ -898,8 +912,8 @@ export class TurnRunner {
             this.teardown(sessionId, streamId);
             // After persistence and teardown: a background route's failure cleanup deletes the hidden session, which must
             // not race the error writeback above (a re-saved session would resurface in the sidebar).
-            if (failed)
-                opts.onFailed?.();
+            if (!succeeded)
+                opts.onFailed?.(failure);
             this.startSteerFollowUp(sessionId, followUp);
         }
     }
@@ -941,9 +955,8 @@ export class TurnRunner {
      * after the text (TAL-276), so an attachment-only turn still gives the model a request and its transcript row a
      * distinct identity.
      */
-    buildUserMessage(workspaceCtx, msgText, attachments, workspace, sessionId, imageMode) {
-        const text = workspaceCtx + msgText;
-        const withFiles = () => attachedFilesPrompt(text, attachments);
+    buildUserMessage(msgText, attachments, workspace, sessionId, imageMode) {
+        const withFiles = () => attachedFilesPrompt(msgText, attachments);
         const candidates = attachments.filter(isImageAttachment);
         if (!candidates.length || imageMode !== 'native')
             return withFiles();
@@ -981,6 +994,10 @@ export class TurnRunner {
         }
         return images ? [{ type: 'text', text: withFiles() }, ...parts] : withFiles();
     }
+    /** The settled session as a terminal frame carries it: the display window, redacted. */
+    publicTerminalSession(s) {
+        return redactSessionData(this.terminalSessionPayload(s), this.deps.redactEnabled());
+    }
     /**
      * Python `_session_payload_with_terminal_window`: the same visible-message window contract as `GET /api/session?
      * msg_limit=` (renderable rows, limited payload shape, windowed tool calls, todo state) with the full count.
@@ -1003,8 +1020,22 @@ export class TurnRunner {
         return payload;
     }
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
-    persistError(s, streamId, label, payload, activeTurnToken, agentRows = []) {
+    /** `runtimeProvider`: the provider the Agent resolved for the turn, when it reported one. */
+    persistError(s, streamId, label, payload, activeTurnToken, agentRows = [], runtimeProvider = '') {
         const startedAt = s.pending_started_at;
+        // TAL-576: an automatic wakeup with no usable credentials pauses the next ones instead of failing each.
+        if (s.pending_user_source === 'process_wakeup' && payload.type === 'credential_pool_empty') {
+            // A profile whose home now escapes the profiles root (`profileHome` throws) records no pause; the error still persists.
+            let home = null;
+            try {
+                home = this.deps.profileHome(s.profile);
+            }
+            catch {
+                home = null;
+            }
+            if (home !== null)
+                recordWakeupPause(s, home, this.deps.now(), runtimeProvider, this.deps.configPath?.(home));
+        }
         this.materializePendingUserTurn(s, activeTurnToken, streamId);
         const duration = typeof startedAt === 'number' && startedAt > 0 ? Math.max(0, this.deps.now() - startedAt) : null;
         s.active_stream_id = null;
@@ -1035,8 +1066,14 @@ export class TurnRunner {
         s.messages.push(errorMessage);
         this.keepLiveState(s, streamId);
         this.persistConsumedSteers(s, streamId, startedAt, this.deps.now());
+        // TAL-921: the next prompt remembers the turn's work; an exhausted compression's work would only overflow again. One
+        // read builds the context and settles, so a row committed in between is never covered without reaching either.
+        const read = this.deps.service().stateDbRead(s);
+        const context = payload.type === 'compression_exhausted' ? null : this.unsettledContext(streamId, agentRows, read);
+        if (context)
+            s.context_messages = context;
         const stop = this.stopContexts.get(streamId);
-        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null });
+        this.deps.service().settleStateDb(s, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows, startId: stop?.stateDbStartId ?? null, read });
         try {
             this.deps.store.save(s);
         }
@@ -1049,6 +1086,18 @@ export class TurnRunner {
         this.deps.pending.clearClarifies(s.session_id);
         this.deps.events.publish('session_error', { profile: s.profile, sessionId: s.session_id });
     }
+    /**
+     * TAL-921: the model context a turn that ends without its settled result leaves: the work its Agent reported, else the
+     * rows it committed past its starting read in `read`, the read its settlement uses.
+     */
+    unsettledContext(streamId, agentRows, read) {
+        const stop = this.stopContexts.get(streamId);
+        if (!stop)
+            return null;
+        const after = stop.stateDbStartId;
+        const stateRows = after === null ? [] : read.rows.filter((m) => typeof m._state_db_row_id === 'number' && m._state_db_row_id > after);
+        return this.deps.service().unsettledTurnContext({ ...stop, streamedText: (this.registry.partialText.get(streamId) ?? []).join(''), agentRows, stateRows });
+    }
     materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
         if (!s.hasPendingPrompt)
@@ -1098,7 +1147,7 @@ export class TurnRunner {
         let snapshot = null;
         if (sessionId)
             try {
-                snapshot = redactSessionData(this.terminalSessionPayload(this.deps.store.get(sessionId)), this.deps.redactEnabled());
+                snapshot = this.publicTerminalSession(this.deps.store.get(sessionId));
             }
             catch {
                 snapshot = null;
@@ -1148,24 +1197,26 @@ export class TurnRunner {
         }
         const stop = this.stopContexts.get(streamId);
         const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
-        const settle = () => {
+        // TAL-921: one state.db read builds the context and settles the turn.
+        const settle = (read) => {
             if (!stop)
                 return null;
             if (canonical)
                 stop.checkpointed = true;
-            return stoppedTurnContext(stop.previousContext, checkpoint, stop.prompt, stop.msgText, (this.registry.partialText.get(streamId) ?? []).join(''), stop.historyLength);
+            return this.unsettledContext(streamId, checkpoint, read);
         };
         if (current.messages.some((m) => isCancelMarker(m)) && current.active_stream_id === null && !current.pending_user_message) {
             // The worker's canonical result can arrive after cancel() settled without a checkpoint (the interrupt reply failed
             // or timed out): it replaces this stream's context and never adds a second Stop row. A settlement that already had
             // one keeps it, so work the Agent finished after the Stop stays out.
             const ownStop = current.messages.some((m) => isCancelMarker(m) && m._turn_id === streamId);
-            const late = canonical && !stop.checkpointed && ownStop ? settle() : null;
-            if (late)
-                current.context_messages = dedupeContext(late);
             // TAL-493: the worker's rows committed after the first settlement are covered by what it reports; others are kept.
-            if (late || (ownStop && checkpoint)) {
-                this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null });
+            if (ownStop && checkpoint) {
+                const read = this.deps.service().stateDbRead(current);
+                const late = canonical && !stop.checkpointed ? settle(read) : null;
+                if (late)
+                    current.context_messages = dedupeContext(late);
+                this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null, read });
                 try {
                     this.deps.store.save(current);
                 }
@@ -1177,7 +1228,8 @@ export class TurnRunner {
         }
         const startedAt = current.pending_started_at;
         this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at), streamId);
-        const context = settle();
+        const read = this.deps.service().stateDbRead(current);
+        const context = settle(read);
         if (context)
             current.context_messages = dedupeContext(context);
         current.active_stream_id = null;
@@ -1191,7 +1243,7 @@ export class TurnRunner {
         }
         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 });
+        this.deps.service().settleStateDb(current, { turnId: streamId, previousContext: stop?.previousContext ?? [], agentRows: checkpoint, startId: stop?.stateDbStartId ?? null, read });
         try {
             this.deps.store.save(current);
         }
@@ -1307,6 +1359,15 @@ export class TurnRunner {
             return { title: fallback, status: `local_summary:${llmStatus}`, rawPreview };
         return { title: null, status: llmStatus || 'empty_title', rawPreview };
     }
+    /**
+     * TAL-591 (Python `_queue_generated_title_for_imported_session`): a CLI session a mutation claims while it still
+     * carries its default title gets the background title job at once instead of after its first WebUI turn.
+     */
+    async titleClaimed(s) {
+        if (!looksLikeDefaultCliTitle({ title: s.title, source_tag: s.source_tag, raw_source: s.raw_source, session_source: s.session_source, source_label: s.source_label }))
+            return;
+        await this.backgroundTitle(s, () => undefined).catch((error) => { this.deps.log(`[webui] imported session title failed for ${s.session_id}: ${error.message}`); });
+    }
     /** Python `_run_background_title_update` (spawned only when `_background_title_generation_inputs` is eligible). */
     async backgroundTitle(s, put) {
         const sessionId = s.session_id;
@@ -1320,8 +1381,11 @@ export class TurnRunner {
         const status = (status, reason = '', title = '', rawPreview = '') => {
             put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
         };
-        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
+        // Python ran the adaptive refresh only when the first-title job was not eligible.
+        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText) {
+            await this.refreshTitle(s, put, status);
             return;
+        }
         if (s.manual_title) {
             status('skipped', 'manual_title', placeholder);
             return;
@@ -1353,6 +1417,9 @@ export class TurnRunner {
             current = this.deps.store.get(sessionId);
         }
         catch {
+            // A session deleted while the title prompt ran stays deleted.
+            if (this.deps.store.wasDeleted(sessionId))
+                return;
             current = s;
         }
         let effective = str(current.title).trim();
@@ -1381,6 +1448,71 @@ export class TurnRunner {
         else
             status('skipped', source || 'unchanged', effective, rawPreview);
     }
+    /**
+     * Python `_maybe_schedule_title_refresh` + `_run_background_title_refresh`: every N exchanges a generated title is
+     * regenerated from the latest exchange; a manual title is never touched.
+     */
+    async refreshTitle(s, put, status) {
+        const every = this.deps.titleRefreshEvery?.() ?? 0;
+        const exchanges = countExchanges(s.messages);
+        if (every <= 0 || exchanges <= 0 || exchanges % every !== 0)
+            return;
+        const [userText, assistantText] = latestExchangeSnippets(s.messages);
+        if (!userText || !assistantText)
+            return;
+        // Admission is released before title work, so an earlier turn's refresh may still be running: refreshes apply in
+        // turn order and each reads the title its predecessor wrote.
+        const sessionId = s.session_id;
+        const run = (this.titleRefreshes.get(sessionId) ?? Promise.resolve()).catch(() => undefined).then(() => this.applyTitleRefresh(sessionId, s, userText, assistantText, put, status));
+        this.titleRefreshes.set(sessionId, run);
+        try {
+            await run;
+        }
+        finally {
+            if (this.titleRefreshes.get(sessionId) === run)
+                this.titleRefreshes.delete(sessionId);
+        }
+    }
+    async applyTitleRefresh(sessionId, s, userText, assistantText, put, status) {
+        const read = () => { try {
+            return this.deps.store.get(sessionId);
+        }
+        catch {
+            return s;
+        } };
+        const latest = read();
+        const placeholder = str(latest.title).trim();
+        if (['Untitled', 'New Chat', ''].includes(placeholder) || latest.manual_title || !latest.llm_title_generated)
+            return;
+        const cfg = await this.deps.profileConfig?.(latest.profile ?? null);
+        if (!cfg || !titleGenerationEnabled(cfg)) {
+            status('refresh_skipped', cfg ? 'title_generation_disabled' : 'config_unavailable', placeholder);
+            return;
+        }
+        const { title: next, status: llmStatus, rawPreview } = await this.llmTitle(latest, userText, assistantText);
+        if (!next) {
+            status('refresh_skipped', llmStatus || 'empty', placeholder, rawPreview);
+            return;
+        }
+        const normalize = (value) => value.replace(/\s+/g, ' ').trim().toLowerCase();
+        if (normalize(next) === normalize(placeholder)) {
+            status('refresh_skipped', 'same_title', placeholder, rawPreview);
+            return;
+        }
+        const current = read();
+        // The user may have renamed the session while the title prompt ran.
+        if (current.manual_title || str(current.title).trim() !== placeholder) {
+            status('skipped', 'manual_title', str(current.title).trim());
+            return;
+        }
+        current.title = next;
+        markSessionTitleGenerated(current);
+        this.deps.store.save(current, { touchUpdatedAt: false });
+        await this.deps.syncTitle?.(current);
+        this.deps.events.publish('title', { profile: current.profile, sessionId });
+        status('refreshed', llmStatus, next, rawPreview);
+        put('title', { session_id: sessionId, title: next });
+    }
     // ── cancel / steer ───────────────────────────────────────────────────────
     /**
      * Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. `withdrawn` is the
@@ -1658,12 +1790,6 @@ export class TurnRunner {
             return { events, leftovers: [...(unmatched ? [unmatched] : []), ...left.map((r) => r.text)] };
         if (unmatched)
             events.push(['steer_withdrawn', { steer_id: null, reason: 'stopped', text: unmatched }]);
-        // ponytail: legacy `pending_steer_leftover` keeps today's Web and App from losing a stopped steer (they requeue it);
-        // drop it once TAL-425 / TAL-426 put `steer_withdrawn` text back in the composer.
-        for (const r of left)
-            events.push(['pending_steer_leftover', { steer_id: r.steer_id, stream_id: streamId, text: r.text, display_text: r.display_text, leftover_at: this.deps.now() }]);
-        if (unmatched)
-            events.push(['pending_steer_leftover', { stream_id: streamId, text: unmatched }]);
         return { events, leftovers: [] };
     }
     /**
@@ -1890,7 +2016,9 @@ export class TurnRunner {
         const profileHome = this.deps.profileHome(s?.profile ?? null);
         let resolved = false;
         let withdrawn = false;
-        if (entry) {
+        if (entry?._injected === true)
+            resolved = Boolean(this.deps.pending.resolveApproval(sessionId, str(entry.approval_id)).entry);
+        else if (entry) {
             if (!sidecar)
                 return relayFailure('not running');
             try {
@@ -1992,6 +2120,11 @@ export class TurnRunner {
         const response = typeof reply === 'string' ? reply : clarifyReply(entry, reply);
         if (response === null)
             return { ok: false, invalid: true };
+        // A test-hook prompt has no parked Agent waiter: it is answered here.
+        if (entry._injected === true) {
+            this.deps.pending.resolveClarify(sessionId, str(entry.clarify_id));
+            return { ok: true, response };
+        }
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return { ok: false, error: 'The Agent sidecar is not running; retry in a moment.' };