@maudecode/talaria-web 1.13.0 → 1.15.0

package/dist/sessions/turn.js

@@ -14,7 +14,7 @@ import { HttpFailure, markSessionTitleGenerated } from './service.js';
 import { StreamRegistry, SessionChannels } from './streams.js';
 import { PendingPrompts, clarifyReply } from './pending.js';
 import { RunJournal } from './journal.js';
-import { Session, titleFrom } from './session.js';
+import { CONTEXT_USAGE_FIELDS, Session, titleFrom } from './session.js';
 import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactSessionData, redactString, withToolId } from '../redact.js';
 import { dict } from '../config/agent-config.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
@@ -24,12 +24,15 @@ import { withSessionWireFlags } from './list.js';
 import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
-import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, escapeWorkspacePrefixPath, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withAttachmentObjects, withBodyExcerpts, withToolCallOutcomes, workspaceContextPrefix } 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 { str } from '../util.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
 const IMAGE_MODE_TIMEOUT_MS = 15_000;
 const TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT = 80;
+/** 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;
 export function classifyProviderError(errStr, opts = {}) {
     const lower = errStr.toLowerCase();
     if (opts.condition === 'credential_missing')
@@ -148,6 +151,11 @@ export class TurnRunner {
     abortControllers = new Map();
     steers = new Map();
     consumedSteers = new Map();
+    /** Per stream: steer, withdraw and Send now run one at a time, so each sees the queue the Agent holds. */
+    steerChains = new Map();
+    /** Streams whose Agent steer queue a withdraw or Send now is rewriting right now, and the pending text seen meanwhile. */
+    steerRewrites = new Map();
+    deferredPendingSteer = new Map();
     lastCompletedTool = 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();
@@ -158,6 +166,8 @@ export class TurnRunner {
     /** 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();
     constructor(deps) {
         this.deps = deps;
     }
@@ -184,9 +194,10 @@ export class TurnRunner {
                 return { error: 'session already has an active stream', active_stream_id: blocking, _status: 409 };
         }
         const streamId = randomUUID().replace(/-/g, '');
-        const wasHiddenEmpty = !s.messages.length && !s.context_messages.length && !s.pending_user_message;
+        const wasHiddenEmpty = !s.messages.length && !s.context_messages.length && !s.hasPendingPrompt;
         const attachments = opts.attachments ?? [];
-        const source = str(s.source_tag).toLowerCase() === 'fork' ? 'fork' : (opts.source ?? 'webui');
+        // 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');
         s.workspace = opts.workspace;
         s.model = opts.model;
         s.model_provider = opts.modelProvider;
@@ -205,8 +216,8 @@ export class TurnRunner {
             this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source, streamId);
         this.deps.store.save(s);
         this.registry.writebackOwners.set(s.session_id, streamId);
-        if (wasHiddenEmpty)
-            this.deps.events.publish('session_new', { profile: s.profile, sessionId: s.session_id });
+        // 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);
         }
@@ -214,10 +225,11 @@ export class TurnRunner {
         const channel = this.registry.create(streamId, s.session_id);
         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) });
-        void this.run(s.session_id, streamId, channel, opts).catch((error) => {
+        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) => {
             this.deps.log(`[webui] ERROR turn ${streamId} crashed\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        });
+        }).finally(() => { 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)
             response.effective_model = opts.model;
@@ -246,7 +258,7 @@ export class TurnRunner {
         const put = (event, data, meta = {}) => {
             for (const steerEvent of this.takeSteerEventsBefore(streamId, event))
                 put(steerEvent[0], steerEvent[1]);
-            if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'pending_steer_leftover'].includes(event))
+            if (this.registry.cancelled.has(streamId) && !['cancel', 'apperror', 'steer_consumed', 'steer_withdrawn'].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)) {
@@ -290,11 +302,7 @@ export class TurnRunner {
         }
         const msgText = opts.msg;
         const previousMessages = structuredClone(s.messages);
-        // Python `reconciled_state_db_messages_for_session(prefer_context=True)`: the model history is the owner context
-        // extended append-only with the Agent's state.db rows (a CLI continuation of this session reaches the model), except
-        // for a compressed context whose anchor cannot be verified — that stays context-only.
-        const localContext = s.context_messages.length ? s.context_messages : s.messages.filter((m) => !m._error && !m._partial);
-        const previousContext = structuredClone(localContext.some((m) => isContextCompressionMarker(m)) ? localContext : deps.service().mergedTranscript(s, localContext));
+        const previousContext = structuredClone(deps.service().modelContext(s));
         // Python `_sanitize_messages_for_api`: the model never sees display-only rows or a replayed cancelled prompt.
         const apiHistory = sanitizeMessagesForApi(previousContext);
         const workspaceCtx = workspaceContextPrefix(opts.workspace);
@@ -314,6 +322,11 @@ export class TurnRunner {
         const toolStartedAt = new WeakMap();
         let tokenSent = false;
         let firstTokenAt = null;
+        // TAL-460: a background turn's text is held back while it could still be a silence marker, so one never flashes by.
+        // ponytail: checks the turn's whole text, so a marker after earlier prose streams until the settled row hides it;
+        // check the last text segment instead if that shows up.
+        const holdSilence = turnOrigin(opts.source) === 'background';
+        let heldText = '';
         const titles = new ReasoningTitleTracker();
         let capturedTerminalError = null;
         const controller = new AbortController();
@@ -327,6 +340,8 @@ export class TurnRunner {
             activeRun.phase = 'running';
         const settledAt = { value: false };
         let failed = 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' });
@@ -349,7 +364,7 @@ export class TurnRunner {
             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' }),
+                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' }),
                 max_iterations: processWakeupMaxIterations(maxIterationsFromConfig(cfg), opts.source ?? 'webui', deps.env ?? {}),
                 max_tokens: maxTokensFromConfig(cfg),
                 reasoning_config: reasoningConfigFromConfig(cfg, opts.modelProvider ?? s.model_provider ?? null),
@@ -375,7 +390,12 @@ export class TurnRunner {
                             if (stable !== null)
                                 put('reasoning', { text: '', titles: stable });
                             partialText.push(str(data.text));
-                            put('token', { text: str(data.text) });
+                            if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
+                                heldText += str(data.text);
+                                return;
+                            }
+                            put('token', { text: heldText + str(data.text) });
+                            heldText = '';
                             return;
                         }
                         case 'reasoning': {
@@ -387,9 +407,12 @@ export class TurnRunner {
                             return;
                         }
                         case 'steer_pending':
-                            for (const record of this.takeConsumedSteers(streamId, str(data.text), { keepLeftovers: true }))
-                                put('steer_consumed', record);
-                            this.saveConsumedSteers(sessionId, streamId);
+                            // 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;
+                            }
+                            this.settleConsumedSteers(sessionId, streamId, str(data.text));
                             return;
                         case 'tool': {
                             const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
@@ -494,7 +517,7 @@ export class TurnRunner {
             // sidecar reports `completed` whenever a failed run still carries messages).
             // Python's second chance: a turn that emitted no new row still counts when the merged transcript it produced
             // ends on a final answer (the current user row or trailing tool activity makes it "lacking").
-            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
+            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] });
             const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
             const lastErr = result.error ?? capturedTerminalError ?? '';
             // Python `_turn_transcript_lacks_final_assistant_answer`: a partial result with no final answer is a silent failure even if tokens streamed.
@@ -503,8 +526,11 @@ export class TurnRunner {
                 const classification = classifyProviderError(lastErr, { silentFailure: !lastErr });
                 const errStr = lastErr || `${classification.label}.`;
                 const payload = providerErrorPayload(errStr, classification.type, classification.hint, deps.redactEnabled());
-                // Settle the steers first so the persisted turn carries every consumed one; the Agent's pending text stays a leftover.
-                const steerEvents = this.finalizeSteerEvents(streamId, str(result.pending_steer));
+                // Settle the steers first so the persisted turn carries every consumed one; the Agent's pending text is sent next.
+                // A withdraw or Send now still in flight finishes first, so the settlement sees the queue it left.
+                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);
                 payload.session = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
                 payload.session_id = s.session_id;
@@ -517,8 +543,9 @@ export class TurnRunner {
             }
             // ── settle the transcript ──
             // The Agent's last pending-steer text settles the remaining steers before the turn is written back.
-            const steerEvents = this.finalizeSteerEvents(streamId, result.pending_steer);
-            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
+            await this.steerRewrites.get(streamId);
+            const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, result.pending_steer, 'followup');
+            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] });
             s.context_messages = dedupeContext(resultMessages);
             for (const m of s.messages) {
                 if (m.role !== 'assistant')
@@ -567,7 +594,8 @@ export class TurnRunner {
                     if (m.role === 'user') {
                         const content = messageText(m.content);
                         const base = msgText.includes('\n\n[Attached files:') ? (msgText.split('\n\n[Attached files:')[0] ?? '').trim() : msgText;
-                        if (content.includes(base.slice(0, 60)) || msgText.includes(content.slice(0, 60)))
+                        // An attachment-only prompt has no text to match: only this turn's own row takes its files.
+                        if (msgText ? content.includes(base.slice(0, 60)) || msgText.includes(content.slice(0, 60)) : m._turn_id === streamId)
                             m.attachments = [...attachments];
                         break;
                     }
@@ -635,6 +663,10 @@ 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());
+            // 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];
             if (usage.completion_tokens && duration > 0)
                 doneUsage.tps = Math.round((usage.completion_tokens / duration) * 10) / 10;
             if (firstTokenAt !== null)
@@ -643,7 +675,7 @@ export class TurnRunner {
             if (usedModel)
                 doneUsage.used_model = usedModel;
             const donePayload = {
-                session: redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled()),
+                session: doneSession,
                 usage: doneUsage,
                 terminal_state: turnTerminalState(s.messages, streamId),
             };
@@ -657,6 +689,7 @@ export class TurnRunner {
             // worker before its daemon-thread title generation).
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
+            this.startSteerFollowUp(sessionId, leftovers);
             await this.backgroundTitle(s, put);
             // Python: the last non-error assistant reply with content, else "(no answer produced)".
             if (opts.onDone) {
@@ -720,21 +753,26 @@ export class TurnRunner {
             // not race the error writeback above (a re-saved session would resurface in the sidebar).
             if (failed)
                 opts.onFailed?.();
+            this.startSteerFollowUp(sessionId, followUp);
         }
     }
     /**
      * Python `_build_user_message`: image attachments are embedded as native `image_url` parts only when the Agent's
      * resolved image mode for this model is `native` (text mode routes them through the Agent's vision tool path), and
-     * only after the bytes are read through an anchored descriptor and sniffed as a real image format.
+     * only after the bytes are read through an anchored descriptor and sniffed as a real image format. Every attached
+     * file is also named by path after the text (TAL-276), so an attachment-only turn still gives the model a request
+     * and its transcript row a distinct identity.
      */
     async buildUserMessage(workspaceCtx, msgText, attachments, workspace, sessionId, s, opts, signal) {
         const text = workspaceCtx + msgText;
+        const named = attachments.map((att) => str(att.path).trim()).filter(Boolean).map(escapeWorkspacePrefixPath);
+        const withFiles = () => (named.length ? `${text}\n\n[Attached files: ${named.join(', ')}]` : text);
         const candidates = attachments.filter((att) => str(att.path).trim() && str(att.mime).trim().startsWith('image/'));
         if (!candidates.length)
-            return text;
+            return withFiles();
         const sidecar = this.deps.sidecar();
         if (!sidecar)
-            return text;
+            return withFiles();
         // A cancel that landed before this point is final: never start the lookup or wait on it.
         if (signal.aborted)
             return text;
@@ -750,15 +788,15 @@ export class TurnRunner {
             if (mode.mode !== 'native') {
                 const cfg = (await this.deps.profileConfig?.(s.profile ?? null)) ?? {};
                 if (explicitTextSignal(cfg) || mode.supports_vision === false)
-                    return text;
+                    return withFiles();
             }
         }
         catch (error) {
             if (!signal.aborted)
                 this.deps.log(`[webui] image mode lookup failed for ${sessionId}: ${error.message}`);
-            return text;
+            return withFiles();
         }
-        const parts = [{ type: 'text', text }];
+        const parts = [];
         let images = 0;
         const roots = [workspace, this.deps.attachmentDir(sessionId)].map((r) => resolvePathLikePython(r));
         for (const att of candidates) {
@@ -790,15 +828,16 @@ export class TurnRunner {
                 closeSync(fd);
             }
         }
-        return images ? parts : text;
+        return images ? [{ type: 'text', text: withFiles() }, ...parts] : withFiles();
     }
     /**
      * 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(), this.registry.liveIds);
-        const scened = hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(s.messages), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true });
+        const payload = withSessionWireFlags(s.compact({ contextLengthFor: this.deps.service().deps.contextLengthFor }), this.registry.liveIds);
+        payload.assistant_name = this.deps.service().assistantName(s);
+        const scened = withBodyExcerpts(this.deps.service().backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withTurnIds(withAttachmentObjects(s.messages)), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true })), s.active_stream_id);
         const [window, offset] = messageWindowForDisplay(scened, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
         const limited = messagesForLimitedPayload(window);
         payload.messages = limited;
@@ -853,7 +892,7 @@ export class TurnRunner {
     }
     materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
-        if (!pendingText)
+        if (!s.hasPendingPrompt)
             return false;
         const recoveredTs = typeof s.pending_started_at === 'number' && s.pending_started_at > 0 ? s.pending_started_at : this.deps.now();
         const source = s.pending_user_source ?? 'webui';
@@ -932,6 +971,11 @@ export class TurnRunner {
             this.deps.store.sessions.delete(current.session_id);
             return true;
         }
+        // TAL-460: a background turn stops quietly: its prompt and model context are kept, but no partial and no Stop row,
+        // and its first settlement is final.
+        const quiet = this.registry.activeRuns.get(streamId)?.origin === 'background';
+        if (quiet && current.active_stream_id === null)
+            return true;
         const stop = this.stopContexts.get(streamId);
         const canonical = stop !== undefined && checkpoint !== null && checkpointTurnStart(checkpoint, stop.msgText, stop.historyLength) !== null;
         const settle = () => {
@@ -967,8 +1011,10 @@ export class TurnRunner {
         current.pending_attachments = [];
         current.pending_started_at = null;
         current.pending_user_source = null;
-        this.appendPartialSnapshot(current, streamId);
-        current.messages.push({ role: 'assistant', content: '', _error: true, _terminal_state: 'cancelled', timestamp: Math.trunc(this.deps.now()), _turn_id: streamId });
+        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.persistConsumedSteers(current, streamId, startedAt, this.deps.now());
         try {
             this.deps.store.save(current);
@@ -1077,7 +1123,9 @@ export class TurnRunner {
         const sessionId = s.session_id;
         const placeholder = str(s.title).trim();
         const invalidExisting = looksInvalidGeneratedTitle(s.title);
-        const eligible = ['Untitled', 'New Chat', ''].includes(placeholder) || placeholder === titleFrom(s.messages, '') || invalidExisting;
+        // A claimed CLI session still carrying its default `<Source> Session` title is retitled like a new chat (TAL-256).
+        const defaultTitle = (session) => looksLikeDefaultCliTitle({ title: session.title, source_tag: session.source_tag, raw_source: session.raw_source, session_source: session.session_source, source_label: session.source_label });
+        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 = '') => {
@@ -1116,7 +1164,7 @@ export class TurnRunner {
             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);
+                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);
                     return;
@@ -1144,16 +1192,19 @@ export class TurnRunner {
         }
     }
     // ── cancel / steer ───────────────────────────────────────────────────────
-    /** Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. */
+    /**
+     * Python `cancel_stream`: persist the partial, mark cancelled, interrupt the Agent, release admission. `withdrawn` is the
+     * `steer_withdrawn` (stopped) this Stop emitted, for the cancel response (TAL-426).
+     */
     async cancel(streamId) {
         const channel = this.registry.peek(streamId);
         const run = this.registry.activeRuns.get(streamId);
         if (!channel && !run)
-            return false;
+            return { cancelled: false, withdrawn: [] };
         // Python popped the run before its title work: a cancel that lands after `done` (while the title prompts still run)
         // is not a cancellation, so it neither journals a `cancel` frame nor marks the completed run interrupted.
         if (!run && this.settledStreams.has(streamId))
-            return false;
+            return { cancelled: false, withdrawn: [] };
         const sessionId = this.registry.ownerSessionId(streamId) ?? run?.session_id ?? null;
         this.registry.cancelled.add(streamId);
         if (run) {
@@ -1174,7 +1225,9 @@ export class TurnRunner {
         const leftover = str(reply?.pending_steer);
         const checkpoint = reply?.checkpoint ?? null;
         // Settle the steers first so the persisted cancel carries every consumed one.
-        const steerEvents = (this.steers.get(streamId) ?? []).length ? this.finalizeSteerEvents(streamId, leftover) : [];
+        // TAL-424: a Stop withdraws the steers the Agent never took, with their text, and starts nothing after.
+        await this.steerRewrites.get(streamId);
+        const steerEvents = (this.steers.get(streamId) ?? []).length ? this.finalizeSteers(streamId, leftover, 'stopped').events : [];
         if (sessionId) {
             let current = null;
             try {
@@ -1210,6 +1263,21 @@ export class TurnRunner {
             this.registry.liveIds.delete(streamId);
         }
         this.abortControllers.get(streamId)?.abort();
+        const withdrawn = steerEvents.filter(([event]) => event === 'steer_withdrawn').map(([, data]) => data);
+        return { cancelled: true, withdrawn };
+    }
+    /**
+     * TAL-460: a user's message never joins a background turn. That turn stops quietly (`finalizeCancelled`) and its worker
+     * unwinds before the user's turn is admitted, so two Agent runs never share the session. True when one was stopped.
+     */
+    async yieldBackgroundTurn(sessionId) {
+        const streamId = this.registry.activeRunStreamForSession(sessionId);
+        if (!streamId || this.registry.activeRuns.get(streamId)?.origin !== 'background')
+            return false;
+        await this.cancel(streamId);
+        let timer;
+        await Promise.race([this.workers.get(streamId), new Promise((resolve) => { timer = setTimeout(resolve, BACKGROUND_UNWIND_WAIT_MS); })]);
+        clearTimeout(timer);
         return true;
     }
     async steer(sessionId, text, displayText, steerId) {
@@ -1234,7 +1302,10 @@ 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.
-        const record = { steer_id: steerId, session_id: sessionId, stream_id: activeStreamId, text, display_text: displayText || text, created_at: this.deps.now() };
+        return this.withSteerChain(activeStreamId, () => 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 };
         const records = this.steers.get(activeStreamId) ?? [];
         records.push(record);
         this.steers.set(activeStreamId, records);
@@ -1259,6 +1330,12 @@ export class TurnRunner {
         // An accepted steer whose turn finalised while the reply was in flight was already reported by that finalisation.
         if (!result.accepted)
             withdraw();
+        else {
+            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));
+        }
         return { accepted: result.accepted, fallback: result.accepted ? null : (result.fallback ?? 'not_running'), stream_id: activeStreamId, steer_id: steerId };
     }
     /** Python `_webui_steer_events_before` for terminal frames: cancel/apperror flush consumed steers and leftovers first. */
@@ -1267,7 +1344,7 @@ export class TurnRunner {
             return [];
         if (!(this.steers.get(streamId) ?? []).length)
             return [];
-        return this.finalizeSteerEvents(streamId, '');
+        return this.finalizeSteers(streamId, '', 'stopped').events;
     }
     /** Python `_pending_webui_steer_suffix_start`: the pending text is the newline-joined tail of the records; earlier ones are consumed. */
     static pendingSteerSuffixStart(records, pendingText) {
@@ -1280,15 +1357,15 @@ export class TurnRunner {
         }
         return null;
     }
-    consumedSteerPayload(record) {
+    consumedSteerPayload(record, opts = {}) {
         const consumedAt = this.deps.now();
         const afterToolCallId = this.lastCompletedTool.get(record.stream_id) ?? null;
         const consumed = this.consumedSteers.get(record.stream_id) ?? [];
         if (!consumed.some((c) => c.steer_id === record.steer_id)) {
-            consumed.push({ steer_id: record.steer_id, text: record.display_text || record.text, agent_text: record.text, submitted_at: record.created_at, consumed_at: consumedAt, after_tool_call_id: afterToolCallId });
+            consumed.push({ steer_id: record.steer_id, text: record.display_text || record.text, agent_text: record.text, submitted_at: record.created_at, consumed_at: consumedAt, after_tool_call_id: afterToolCallId, ...(opts.redirected ? { redirected: true } : {}) });
             this.consumedSteers.set(record.stream_id, consumed);
         }
-        return { ...record, agent_text: record.text, text: record.display_text || record.text, consumed_at: consumedAt, after_tool_call_id: afterToolCallId };
+        return { steer_id: record.steer_id, session_id: record.session_id, stream_id: record.stream_id, display_text: record.display_text, created_at: record.created_at, agent_text: record.text, text: record.display_text || record.text, consumed_at: consumedAt, after_tool_call_id: afterToolCallId };
     }
     /**
      * Consumed steers become display-only `_steer` user rows at their causal place in the turn: after the tool results of
@@ -1309,7 +1386,14 @@ export class TurnRunner {
             };
             // An Agent that records the steer it delivered does so at its exact place: that row becomes the steer, not a copy.
             const agentRows = s.messages.flatMap((m, i) => (m._turn_id === streamId && agentSteerText(m) !== null ? [i] : []));
-            const agentRow = agentRows.find((i) => agentSteerText(s.messages[i]) === steer.agent_text.trim()) ?? agentRows[0];
+            let agentRow = agentRows.find((i) => agentSteerText(s.messages[i]) === steer.agent_text.trim()) ?? agentRows[0];
+            // A Send now redirect is recorded as a plain user row of the turn: that row becomes the steer too.
+            if (steer.redirected) {
+                const prompt = s.messages.findIndex((m) => m._turn_id === streamId && m.role === 'user' && !m._steer);
+                const own = s.messages.findIndex((m, i) => i > prompt && m._turn_id === streamId && m.role === 'user' && !m._steer && messageText(m.content).trim() === steer.agent_text.trim());
+                // Never another steer's row: without its own correction row (the Agent joins two redirects) it gets a new one.
+                agentRow = own >= 0 ? own : undefined;
+            }
             if (agentRow === undefined)
                 s.messages.splice(steerInsertIndex(s.messages, streamId, steer.after_tool_call_id), 0, row);
             else
@@ -1364,22 +1448,181 @@ export class TurnRunner {
             return [];
         return records.slice(0, start).map((r) => this.consumedSteerPayload(r));
     }
-    /** Terminal steer bookkeeping for cancel/error paths: consumed records first, then `pending_steer_leftover` for the rest. */
-    finalizeSteerEvents(streamId, leftoverText) {
+    /**
+     * Terminal steer bookkeeping: the records the Agent no longer holds are consumed; the rest it never took are either
+     * `stopped` (withdrawn with their text for the composer) or returned as one `followup` turn's texts (TAL-424).
+     */
+    finalizeSteers(streamId, leftoverText, mode) {
         const records = this.steers.get(streamId) ?? [];
         this.steers.delete(streamId);
-        const start = TurnRunner.pendingSteerSuffixStart(records, leftoverText);
-        if (start === null)
-            return leftoverText ? [['pending_steer_leftover', { stream_id: streamId, text: leftoverText }]] : [];
-        const events = records.slice(0, start).map((r) => ['steer_consumed', this.consumedSteerPayload(r)]);
-        const leftovers = records.slice(start);
-        for (const r of leftovers)
-            events.push(['pending_steer_leftover', { ...r, leftover_at: this.deps.now() }]);
-        const matched = leftovers.map((r) => r.text).join('\n');
+        // Text that ends with none of these steers is another surface's: the Agent took every one of them.
+        const start = TurnRunner.pendingSteerSuffixStart(records, leftoverText) ?? records.length;
+        const consumed = records.slice(0, start);
+        const left = records.slice(start);
+        const matched = left.map((r) => r.text).join('\n');
         const unmatched = matched ? leftoverText.slice(0, leftoverText.length - matched.length).replace(/\n+$/, '') : leftoverText;
+        const events = consumed.map((r) => ['steer_consumed', this.consumedSteerPayload(r)]);
+        for (const r of left)
+            events.push(['steer_withdrawn', { steer_id: r.steer_id, reason: mode, text: r.display_text }]);
+        if (mode === 'followup')
+            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;
+        return { events, leftovers: [] };
+    }
+    /**
+     * 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) {
+        if (!texts.length)
+            return;
+        let s;
+        try {
+            s = 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 });
+        if (!started._status || started._status < 400)
+            return;
+        if (started._status === 409 && started.active_stream_id) {
+            void this.steer(sessionId, msg, msg, `steer-${randomUUID()}`).then((r) => {
+                if (r.accepted !== true)
+                    this.deps.log(`[webui] WARNING: steer follow-up for ${sessionId} was not accepted (${str(r.fallback)}); text: ${msg.slice(0, 200)}`);
+            });
+            return;
+        }
+        this.deps.log(`[webui] WARNING: steer follow-up for ${sessionId} not started (${String(started._status)}): ${str(started.error)}`);
+    }
+    /** The Agent's pending steer text settles which steers it has taken: those become `steer_consumed` and their rows. */
+    settleConsumedSteers(sessionId, streamId, pendingText) {
+        for (const record of this.takeConsumedSteers(streamId, pendingText, { keepLeftovers: true }))
+            this.emitToSession(sessionId, 'steer_consumed', record);
+        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 } };
+    }
+    /** 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);
+        const settled = run.catch(() => undefined).then(() => { if (this.steerChains.get(streamId) === settled)
+            this.steerChains.delete(streamId); });
+        this.steerChains.set(streamId, settled);
+        return run;
+    }
+    /**
+     * A withdraw or Send now on one pending steer of the session's active stream. `rewrite` asks the sidecar to change the
+     * Agent's queue and says whether it did; pending text the Agent reported meanwhile is settled after, unless the queue
+     * changed (the next report then reflects it).
+     */
+    async rewriteSteer(sessionId, steerId, fallback, rewrite) {
+        let s = null;
+        try {
+            s = this.deps.store.get(sessionId, { metadataOnly: true });
+        }
+        catch {
+            s = null;
+        }
+        const streamId = s?.active_stream_id;
+        const sidecar = this.deps.sidecar();
+        if (!streamId || !sidecar)
+            return fallback;
+        return this.withSteerChain(streamId, 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;
+            // 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 };
+            try {
+                outcome = await rewrite(sidecar, streamId, records, index);
+            }
+            catch {
+                outcome = { result: fallback, changed: false };
+            }
+            finally {
+                this.steerRewrites.delete(streamId);
+                finished();
+                const deferred = this.deferredPendingSteer.get(streamId);
+                this.deferredPendingSteer.delete(streamId);
+                if (deferred !== undefined && !outcome.changed)
+                    this.settleConsumedSteers(sessionId, streamId, deferred);
+            }
+            return outcome.result;
+        });
+    }
+    dropSteer(streamId, record) {
+        const records = this.steers.get(streamId);
+        const index = records?.indexOf(record) ?? -1;
+        if (records && index >= 0)
+            records.splice(index, 1);
+    }
+    /**
+     * 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) => {
+            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 });
+            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) => {
+            const record = records[index];
+            if (!record.can_redirect)
+                return { result: { redirected: false }, 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 };
+            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));
+                }
+                return { result: { redirected: false }, 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));
+            }
+            else {
+                this.emitToSession(sessionId, 'steer_consumed', this.consumedSteerPayload(record, { redirected: true }));
+                this.saveConsumedSteers(sessionId, streamId);
+            }
+            return { result: { redirected: true }, changed: true };
+        });
     }
     // ── approvals / clarify ──────────────────────────────────────────────────
     async respondApproval(sessionId, choice, approvalId, enableYolo) {