@maudecode/talaria-web 1.15.0 → 1.16.1

package/dist/sessions/turn.js

@@ -24,17 +24,22 @@ import { withSessionWireFlags } from './list.js';
 import { hydrateAnchorActivityScenes, turnTerminalState, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, escapeWorkspacePrefixPath, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stoppedTurnContext, stripXmlToolCalls, toolOutcome, withAttachmentObjects, withBodyExcerpts, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, escapeWorkspacePrefixPath, checkpointTurnStart, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitDisplayText, joinReasoning, reasoningFieldsText, stoppedTurnContext, toolOutcome, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withToolCallOutcomes, workspaceContextPrefix } from './merge.js';
 import { mayBecomeSilentReply, turnOrigin, withBackgroundUpdates } from './background-updates.js';
 import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
+import { WORKSPACE_BUSY_MESSAGE } from '../workspace/git.js';
 import { str } from '../util.js';
 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;
+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.' };
+/** `compressionExhausted`: the Agent flagged the turn itself, so its wording does not matter. */
 export function classifyProviderError(errStr, opts = {}) {
     const lower = errStr.toLowerCase();
+    if (opts.compressionExhausted)
+        return COMPRESSION_EXHAUSTED;
     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));
@@ -60,7 +65,7 @@ export function classifyProviderError(errStr, opts = {}) {
     if (notFound)
         return { label: 'Model not found', type: 'model_not_found', hint: 'The selected model was not found by the provider. Check the model ID in Settings or run `hermes model` to verify it exists for your provider.' };
     if (compressionExhausted)
-        return { 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.' };
+        return COMPRESSION_EXHAUSTED;
     if (opts.silentFailure)
         return { label: 'No response from provider', type: 'no_response', hint: 'The provider returned no content and no error. This often means a usage/rate limit was hit silently. Check provider status, switch providers via `hermes model`, or try again in a moment.' };
     return { label: 'Error', type: 'error', hint: '' };
@@ -180,6 +185,8 @@ export class TurnRunner {
             return { error: 'Web is updating. Retry after it restarts.', _status: 503 };
         if (this.deps.profileDeleting?.(s.profile ?? null))
             return { error: `Profile '${str(s.profile)}' is being deleted.`, _status: 409 };
+        if (this.deps.workspaceBusy?.(opts.workspace))
+            return { error: WORKSPACE_BUSY_MESSAGE, _status: 409 };
         const locked = s.active_stream_id;
         if (locked) {
             if (this.registry.liveIds.has(locked) || this.registry.activeRuns.has(locked))
@@ -424,15 +431,20 @@ export class TurnRunner {
                             return;
                         }
                         case 'tool_complete': {
-                            // TAL-313: the server decides failure from the sidecar's raw result, which never leaves the server.
+                            // TAL-313: the server decides failure from the sidecar's raw result, which never leaves the server; TAL-315: so
+                            // are its display sections, which keep the stderr and exit code the flat preview drops.
                             const { raw_result: rawResult, ...complete } = data;
-                            complete.is_error = toolOutcome(rawResult).is_error;
+                            const outcome = toolOutcome(rawResult);
+                            complete.is_error = outcome.is_error;
+                            if (rawResult !== undefined)
+                                complete.result_view = outcome.result_view;
                             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;
-                                Object.assign(tc, { done: true, snippet: data.preview, is_error: complete.is_error, duration: complete.duration ?? null });
+                                // 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 } : {}) });
                             }
                             const id = (tc && toolIds.get(tc)) || str(data.tid) || mintToolId();
                             this.lastCompletedTool.set(streamId, id);
@@ -447,6 +459,14 @@ export class TurnRunner {
                             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))
+                                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);
@@ -478,25 +498,6 @@ export class TurnRunner {
                 put('cancel', this.cancelFrame(sessionId));
                 return;
             }
-            if (opts.ephemeral) {
-                let answer = '';
-                for (let i = result.messages.length - 1; i >= 0; i -= 1) {
-                    const m = result.messages[i];
-                    if (m.role === 'assistant') {
-                        answer = str(m.content);
-                        break;
-                    }
-                }
-                opts.onDone?.(answer);
-                // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
-                put('done', { session: { session_id: sessionId, messages: (result.messages).map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer, terminal_state: answer.trim() ? 'completed' : 'no_response' });
-                try {
-                    rmSync(deps.store.pathFor(sessionId), { force: true });
-                }
-                catch { /* ignore */ }
-                deps.store.sessions.delete(sessionId);
-                return;
-            }
             // Writeback only while this stream still owns the session (Python `_stream_writeback_is_current`).
             let current;
             try {
@@ -518,12 +519,14 @@ export class TurnRunner {
             // 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, attachments: opts.attachments ?? [] });
-            const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
+            // TAL-512: a btw answer must be a reply this turn added: everything before it is the parent's replayed history.
+            const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || (!opts.ephemeral && !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.
-            const stalePartial = result.result_status === 'partial' && !assistantAdded;
-            if (result.status === 'error' || (!assistantAdded && !tokenSent) || stalePartial) {
-                const classification = classifyProviderError(lastErr, { silentFailure: !lastErr });
+            // Python `_agent_result_terminal_failure`: the Agent's failed, partial, or compression-exhausted result ends the turn
+            // even after text streamed; only a partial with no error text and a final answer still completes.
+            const agentFailed = result.failed || result.compression_exhausted || (result.partial && (Boolean(lastErr) || !assistantAdded));
+            if (result.status === 'error' || agentFailed || (!assistantAdded && (!tokenSent || opts.ephemeral))) {
+                const classification = classifyProviderError(lastErr, { silentFailure: !lastErr, compressionExhausted: result.compression_exhausted });
                 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 is sent next.
@@ -532,7 +535,9 @@ export class TurnRunner {
                 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());
+                // 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_id = s.session_id;
                 payload.old_session_id = sessionId;
                 for (const [event, data] of steerEvents)
@@ -541,18 +546,32 @@ export class TurnRunner {
                 failed = true;
                 return;
             }
+            // TAL-512: a btw turn passes the failure check above first, so its last assistant row is this turn's reply.
+            if (opts.ephemeral) {
+                let answer = '';
+                for (let i = result.messages.length - 1; i >= 0; i -= 1) {
+                    const m = result.messages[i];
+                    if (m.role === 'assistant') {
+                        answer = str(m.content);
+                        break;
+                    }
+                }
+                opts.onDone?.(answer);
+                // Python `_ephemeral_session_payload`: only role and content leave the server for a btw turn.
+                put('done', { session: { session_id: sessionId, messages: (result.messages).map((m) => ({ role: m.role, content: m.content })) }, usage: { input_tokens: 0, output_tokens: 0 }, ephemeral: true, answer, terminal_state: answer.trim() ? 'completed' : 'no_response' });
+                try {
+                    rmSync(deps.store.pathFor(sessionId), { force: true });
+                }
+                catch { /* ignore */ }
+                deps.store.sessions.delete(sessionId);
+                return;
+            }
             // ── settle the transcript ──
             // The Agent's last pending-steer text settles the remaining steers before the turn is written back.
             await this.steerRewrites.get(streamId);
             const { events: steerEvents, leftovers } = this.finalizeSteers(streamId, result.pending_steer, 'followup');
             s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId, attachments: opts.attachments ?? [] });
             s.context_messages = dedupeContext(resultMessages);
-            for (const m of s.messages) {
-                if (m.role !== 'assistant')
-                    continue;
-                if (typeof m.content === 'string')
-                    m.content = stripXmlToolCalls(m.content);
-            }
             if (result.compressed) {
                 s.compression_anchor_visible_idx = Math.max(0, previousMessages.length - 1);
                 put('compressed', { session_id: sessionId, old_session_id: sessionId, new_session_id: sessionId, continuation_session_id: sessionId, message: 'Compression finished' });
@@ -611,12 +630,12 @@ export class TurnRunner {
                 asstIdx += 1;
                 if (turnIdx < prevAssistants)
                     continue;
-                const existing = str(m.reasoning);
+                // The settled row keeps its own fields: only its prose and its inline thinking (into `reasoning`) are rewritten.
                 if (typeof m.content === 'string' && m.content) {
-                    const [content, merged] = splitThinkingFromContent(m.content, existing);
+                    const [content, inline] = splitDisplayText(m.content);
                     m.content = content;
-                    if (merged)
-                        m.reasoning = merged;
+                    if (inline)
+                        m.reasoning = joinReasoning([reasoningFieldsText({ reasoning: m.reasoning }), inline]);
                 }
                 if (turnIdx === prevAssistants && reasoning.trim() && !m.reasoning)
                     m.reasoning = reasoning.trim();
@@ -690,22 +709,14 @@ export class TurnRunner {
             this.registry.activeRuns.delete(streamId);
             this.settledStreams.add(streamId);
             this.startSteerFollowUp(sessionId, leftovers);
-            await this.backgroundTitle(s, put);
+            // 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 });
+            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)".
-            if (opts.onDone) {
-                let answer = '';
-                for (let i = s.messages.length - 1; i >= 0; i -= 1) {
-                    const m = s.messages[i];
-                    if (m.role !== 'assistant' || m._error)
-                        continue;
-                    const text = messageText(m.content).trim();
-                    if (text) {
-                        answer = text;
-                        break;
-                    }
-                }
-                opts.onDone(answer || '(no answer produced)');
-            }
+            opts.onDone?.(lastAnswer(s.messages) || '(no answer produced)');
         }
         catch (error) {
             if (settledAt.value && !(error instanceof SidecarError)) {
@@ -737,7 +748,8 @@ export class TurnRunner {
                     for (const [event, data] of this.takeSteerEventsBefore(streamId, 'apperror'))
                         put(event, data);
                     this.persistError(current, streamId, classification.label, payload, activeTurnToken);
-                    payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
+                    if (!opts.ephemeral)
+                        payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
                 }
             }
             catch (persistError) {
@@ -835,11 +847,13 @@ export class TurnRunner {
      * 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 }), this.registry.liveIds);
+        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);
-        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);
+        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(window);
+        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;
@@ -1131,65 +1145,60 @@ export class TurnRunner {
         const status = (status, reason = '', title = '', rawPreview = '') => {
             put('title_status', { session_id: sessionId, status, ...(reason ? { reason } : {}), ...(title ? { title } : {}), ...(rawPreview ? { raw_preview: rawPreview } : {}) });
         };
-        try {
-            if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
-                return;
-            if (s.manual_title) {
-                status('skipped', 'manual_title', placeholder);
-                return;
+        if (!eligible || (s.llm_title_generated && !invalidExisting) || !userText || !assistantText)
+            return;
+        if (s.manual_title) {
+            status('skipped', 'manual_title', placeholder);
+            return;
+        }
+        if (!this.deps.titleGenerationEnabled()) {
+            status('skipped', 'title_generation_disabled', placeholder);
+            return;
+        }
+        const generated = await this.llmTitle(s, userText, assistantText);
+        const { status: llmStatus, rawPreview } = generated;
+        let next = generated.title;
+        let source = llmStatus;
+        if (!next) {
+            const fallback = fallbackTitleFromExchange(userText, assistantText);
+            if (fallback && !isGenericFallbackTitle(fallback)) {
+                next = fallback;
+                source = 'fallback';
             }
-            if (!this.deps.titleGenerationEnabled()) {
-                status('skipped', 'title_generation_disabled', placeholder);
+        }
+        const fallbackReason = source === 'fallback' && llmStatus ? `local_summary:${llmStatus}` : 'local_summary';
+        let current = s;
+        try {
+            current = this.deps.store.get(sessionId);
+        }
+        catch {
+            current = s;
+        }
+        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);
                 return;
             }
-            const generated = await this.llmTitle(s, userText, assistantText);
-            const { status: llmStatus, rawPreview } = generated;
-            let next = generated.title;
-            let source = llmStatus;
-            if (!next) {
-                const fallback = fallbackTitleFromExchange(userText, assistantText);
-                if (fallback && !isGenericFallbackTitle(fallback)) {
-                    next = fallback;
-                    source = 'fallback';
-                }
-            }
-            const fallbackReason = source === 'fallback' && llmStatus ? `local_summary:${llmStatus}` : 'local_summary';
-            let current = s;
-            try {
-                current = this.deps.store.get(sessionId);
-            }
-            catch {
-                current = s;
-            }
-            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);
-                    return;
-                }
-                if (next !== effective) {
-                    current.title = next;
-                    markSessionTitleGenerated(current);
-                    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 });
-                    effective = next;
-                    wrote = true;
-                }
-            }
-            if (wrote) {
-                status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
-                put('title', { session_id: sessionId, title: effective });
+            if (next !== effective) {
+                current.title = next;
+                markSessionTitleGenerated(current);
+                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 });
+                effective = next;
+                wrote = true;
             }
-            else
-                status('skipped', source || 'unchanged', effective, rawPreview);
         }
-        finally {
-            put('stream_end', { session_id: sessionId });
+        if (wrote) {
+            status(source, source === 'fallback' ? fallbackReason : llmStatus, effective, rawPreview);
+            put('title', { session_id: sessionId, title: effective });
         }
+        else
+            status('skipped', source || 'unchanged', effective, rawPreview);
     }
     // ── cancel / steer ───────────────────────────────────────────────────────
     /**
@@ -1503,6 +1512,60 @@ export class TurnRunner {
         }
         this.deps.log(`[webui] WARNING: steer follow-up for ${sessionId} not started (${String(started._status)}): ${str(started.error)}`);
     }
+    /**
+     * TAL-396 (Agent gateway `_post_turn_goal_continuation`): after every turn settles, the Agent's GoalManager judges it
+     * while a goal is active and the server starts the continuation turn it asks for. Any turn counts, so a resumed or
+     * persisted goal picks up from the next user message. A user turn that took the session meanwhile runs first and is
+     * judged next. A stopped or failed turn never gets here, so the run ends there.
+     */
+    async continueGoal(s, streamId, put) {
+        const sidecar = this.deps.sidecar();
+        const lastResponse = lastAnswer(s.messages);
+        // The Agent never drives a goal from an empty reply.
+        if (!sidecar || !lastResponse)
+            return;
+        const sessionId = s.session_id;
+        // 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' });
+        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 });
+        }
+        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: '' });
+            return;
+        }
+        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)
+            return;
+        let current;
+        try {
+            current = 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 });
+        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: '' });
+            return;
+        }
+        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) {
         for (const record of this.takeConsumedSteers(streamId, pendingText, { keepLeftovers: true }))
@@ -1645,6 +1708,7 @@ export class TurnRunner {
         }
         const profileHome = this.deps.profileHome(s?.profile ?? null);
         let resolved = false;
+        let withdrawn = false;
         if (entry) {
             if (!sidecar)
                 return relayFailure('not running');
@@ -1656,8 +1720,13 @@ export class TurnRunner {
                 this.deps.log(`[webui] approval relay failed for ${sessionId}: ${error.message}`);
                 return relayFailure(str(error.message));
             }
-            if (resolved && entry)
+            if (resolved)
                 this.deps.pending.resolveApproval(sessionId, str(entry.approval_id));
+            else {
+                // TAL-514: a rejected answer can mean the Agent already stopped waiting on this card; drop what it no longer holds.
+                await this.reconcileApprovals(sessionId, sidecar);
+                withdrawn = !this.deps.pending.hasApprovalId(sessionId, str(entry.approval_id));
+            }
         }
         let yoloEnabled;
         if (enableYolo) {
@@ -1680,10 +1749,34 @@ export class TurnRunner {
             yoloEnabled = true;
             this.deps.pending.clearApprovals(sessionId);
         }
+        if (withdrawn)
+            return { ok: true, choice, stale_cleared: true, pending_count: this.deps.pending.approvalPending(sessionId).pending_count, ...(enableYolo ? { yolo_enabled: yoloEnabled } : {}) };
         if (!found && !this.deps.pending.hasPendingApproval(sessionId))
             return { ok: true, choice, stale_cleared: true, ...(enableYolo ? { yolo_enabled: yoloEnabled } : {}) };
         return { ok: resolved || !approvalId, choice, ...(enableYolo && (resolved || !approvalId) ? { yolo_enabled: yoloEnabled } : {}) };
     }
+    /** The live chat frame after approvals were withdrawn: the new queue head, or `approval_cleared` once none is left. */
+    approvalHeadFrame(sessionId) {
+        const { pending, pending_count } = this.deps.pending.approvalPending(sessionId);
+        return pending ? ['approval', { ...pending, pending_count }] : ['approval_cleared', { session_id: sessionId, pending_count: 0 }];
+    }
+    /**
+     * Drop mirrored approvals the Agent no longer holds; a failed read keeps them (the card stays answerable). Only
+     * entries queued before the read are candidates: one the Agent parks meanwhile can be missing from its snapshot.
+     */
+    async reconcileApprovals(sessionId, sidecar) {
+        const before = this.deps.pending.approvalRequestIds(sessionId);
+        let live;
+        try {
+            live = new Set((await sidecar.call('approval.pending', { session_id: sessionId })).pending.map((p) => str(p.request_id)));
+        }
+        catch (error) {
+            this.deps.log(`[webui] approval reconcile failed for ${sessionId}: ${error.message}`);
+            return;
+        }
+        if (this.deps.pending.dropApprovals(sessionId, new Set(before.filter((id) => !live.has(id)))).length)
+            this.emitToSession(sessionId, ...this.approvalHeadFrame(sessionId));
+    }
     withYoloLock(sessionId, fn) {
         const run = (this.yoloChains.get(sessionId) ?? Promise.resolve()).then(fn);
         const settled = run.catch(() => undefined).then(() => { if (this.yoloChains.get(sessionId) === settled)
@@ -1736,6 +1829,18 @@ export class TurnRunner {
         return { ok: true, response };
     }
 }
+/** The turn's answer: the last non-error assistant reply with content. */
+function lastAnswer(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (m.role !== 'assistant' || m._error)
+            continue;
+        const text = messageText(m.content).trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
 function previousStartedAt(s, run) {
     return typeof s.pending_started_at === 'number' && s.pending_started_at > 0 ? s.pending_started_at : (run?.started_at ?? Date.now() / 1000);
 }