@maudecode/talaria-web 1.15.0 → 1.16.1

package/dist/sessions/merge.js

@@ -96,13 +96,43 @@ export function messagesHavePrefix(messages, prefix) {
             return false;
     return true;
 }
-export function isContextCompressionMarker(msg) {
+const PRESERVED_TASK_LIST_PREFIX = '[your active task list was preserved across context compression]';
+const hasPrefix = (text, prefix) => text.slice(0, prefix.length).toLowerCase() === prefix;
+/**
+ * TAL-305: the one rule for the marker rows the Agent writes around context compaction. A flagged row, or a user or
+ * assistant row starting `[context compaction`, is a compaction summary; a user row starting with the preserved-task-list
+ * line is that list. Both ignore case and leading whitespace; prose that merely mentions compaction is no marker.
+ */
+export function markerKind(msg) {
     if (!isDict(msg))
-        return false;
+        return null;
     if (msg._context_compression_marker || msg._compression_marker || msg._compaction_marker)
-        return true;
-    const text = messageText(msg.content);
-    return str(msg.role) === 'user' && text.startsWith('[CONTEXT COMPACTION]');
+        return 'context_compaction';
+    const role = str(msg.role);
+    const text = messageText(msg.content).trimStart();
+    if (role === 'user' && hasPrefix(text, PRESERVED_TASK_LIST_PREFIX))
+        return 'preserved_task_list';
+    if ((role === 'user' || role === 'assistant') && hasPrefix(text, '[context compaction'))
+        return 'context_compaction';
+    return null;
+}
+export function isContextCompressionMarker(msg) {
+    return markerKind(msg) === 'context_compaction';
+}
+/**
+ * TAL-305: stamps `_marker_kind` on marker rows, and `_marker_body` (the list without its marker line) on a preserved
+ * task list, so clients render a marker card instead of a message. Returns copies; stored rows are untouched.
+ */
+export function withMarkerKinds(messages) {
+    return messages.map((m) => {
+        const kind = markerKind(m);
+        if (!kind || !isDict(m))
+            return m;
+        if (kind === 'context_compaction')
+            return { ...m, _marker_kind: kind };
+        const body = messageText(m.content).trim().slice(PRESERVED_TASK_LIST_PREFIX.length).trim();
+        return { ...m, _marker_kind: kind, _marker_body: body };
+    });
 }
 /** A user prompt as the user typed it: without the workspace prefix and the attached-files line the server adds. */
 const userPromptText = (text) => stripWorkspacePrefix(stripAttachedFilesMarker(text), true);
@@ -314,10 +344,134 @@ function presentError(v) {
         return v.length > 0;
     return isDict(v) ? Object.keys(v).length > 0 : v === true;
 }
+const RESULT_TEXT_KEYS = ['result', 'results', 'preview', 'content', 'text', 'message', 'summary', 'data', 'items'];
+const RESULT_VIEW_MAX_DEPTH = 8;
+const tryJson = (text) => { try {
+    return JSON.parse(text);
+}
+catch {
+    return undefined;
+} };
+const prettyJson = (value) => { try {
+    return JSON.stringify(value, null, 2);
+}
+catch {
+    return str(value);
+} };
+/** Line breaks and tabs a JSON-encoded result left escaped (`\n`, `\\n`), as the characters they stand for. */
+const unescapeResultText = (text) => text.replace(/\r\n/g, '\n').replace(/\\{1,2}r\\{1,2}n|\\{1,2}n/g, '\n').replace(/\\{1,2}t/g, '\t');
+/** The JSON a result string holds: as written, else with its escaped quotes undone; nested JSON strings unwrap three levels. */
+function resultJson(text) {
+    const trimmed = text.trim();
+    let value = tryJson(trimmed);
+    if (value === undefined && trimmed.includes('\\"'))
+        value = tryJson(trimmed.replaceAll('\\"', '"'));
+    for (let i = 0; i < 3 && typeof value === 'string'; i += 1) {
+        const inner = tryJson(value.trim());
+        if (inner === undefined)
+            break;
+        value = inner;
+    }
+    return value;
+}
+/** A section's text: a string unescaped, a scalar as written, a structure as pretty JSON; `undefined` when blank. */
+function sectionText(value) {
+    const text = typeof value === 'string' ? unescapeResultText(value) : typeof value === 'number' || typeof value === 'boolean' ? String(value) : value === null || value === undefined ? '' : prettyJson(value);
+    return text.trim() || undefined;
+}
+/** An exit code: an integer, or a string of one; anything else is dropped. */
+function exitCodeOf(value) {
+    const n = typeof value === 'number' ? Math.trunc(value) : typeof value === 'string' && /^\s*[+-]?\d+\s*$/.test(value) ? Number(value) : NaN;
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+/** A terminal result's sections; the exit code only when it is non-zero or nothing else would show. */
+function terminalView(data) {
+    const view = {};
+    const stdout = sectionText(data.output) ?? sectionText(data.stdout);
+    const stderr = sectionText(data.stderr);
+    const error = sectionText(data.error);
+    if (stdout)
+        view.stdout = stdout;
+    if (stderr)
+        view.stderr = stderr;
+    if (error)
+        view.error = error;
+    const exit = exitCodeOf(data.exit_code ?? data.exitCode);
+    if (exit !== undefined && (exit !== 0 || !Object.keys(view).length))
+        view.exit_code = exit;
+    return view;
+}
+/** Every item of a list is a text part (`text`, `content` or `message`): their texts, one per line. */
+function textParts(items) {
+    const texts = items.map((item) => (isDict(item) ? sectionText(item.text) ?? sectionText(item.content) ?? sectionText(item.message) : undefined));
+    return texts.length && texts.every(Boolean) ? texts.join('\n') : undefined;
+}
+const isEmptyView = (view) => Object.keys(view).length === 0;
+function resultView(value, depth) {
+    if (typeof value === 'string') {
+        const parsed = depth < RESULT_VIEW_MAX_DEPTH ? resultJson(value) : undefined;
+        if (parsed !== undefined && typeof parsed !== 'string') {
+            const view = resultView(parsed, depth + 1);
+            if (!isEmptyView(view))
+                return view;
+        }
+        // Top-level text that is not JSON shows exactly as written; strings inside JSON are unescaped.
+        const text = depth === 0 && parsed === undefined ? value.trim() : sectionText(typeof parsed === 'string' ? parsed : value);
+        return text ? { text } : {};
+    }
+    if (Array.isArray(value)) {
+        const text = textParts(value) ?? sectionText(value);
+        return text ? { text } : {};
+    }
+    if (!isDict(value)) {
+        const text = sectionText(value);
+        return text ? { text } : {};
+    }
+    if (depth >= RESULT_VIEW_MAX_DEPTH)
+        return { text: prettyJson(value) };
+    // A process result: its output streams, error and exit code.
+    if (sectionText(value.output) ?? sectionText(value.stdout) ?? sectionText(value.stderr))
+        return terminalView(value);
+    for (const key of RESULT_TEXT_KEYS) {
+        const view = resultView(value[key], depth + 1);
+        if (!isEmptyView(view))
+            return view;
+    }
+    const terminal = terminalView(value);
+    if (!isEmptyView(terminal))
+        return terminal;
+    return Object.keys(value).length ? { text: prettyJson(value) } : {};
+}
+/**
+ * The server's one result view rule (TAL-315), ported from the iOS formatter so every client renders the same sections:
+ * a JSON result (nested JSON strings unwrapped, escaped line breaks undone) with `output`/`stdout`/`stderr` maps to its
+ * terminal sections; any other object shows the first readable `result`, `results`, `preview`, `content`, `text`,
+ * `message`, `summary`, `data` or `items`, else its `error` and exit code, else pretty JSON. A list of text parts joins
+ * by line; a scalar shows as text, and a result that is not JSON exactly as written. Each field is capped like the snippet
+ * (`limit`; TAL-331's whole-result read passes `Infinity`).
+ */
+export function toolResultView(raw, limit = TOOL_RESULT_SNIPPET_MAX) {
+    // Content parts read as their text; a list with no text (`[{ title }]`) is the result itself.
+    const flat = Array.isArray(raw) ? messageText(raw) : raw;
+    const view = resultView(Array.isArray(raw) && !str(flat).trim() ? raw : flat, 0);
+    return Object.fromEntries(Object.entries(view).map(([key, field]) => [key, typeof field === 'string' ? toolResultSnippet(field, limit) : field]));
+}
+/** A view the server already decided (a built scene row, or one stored with its scene): its known fields, capped. */
+export function decidedResultView(value) {
+    const view = {};
+    for (const key of ['text', 'stdout', 'stderr', 'error']) {
+        const field = value[key];
+        if (typeof field === 'string' && field)
+            view[key] = toolResultSnippet(field);
+    }
+    if (typeof value.exit_code === 'number' && Number.isSafeInteger(value.exit_code))
+        view.exit_code = value.exit_code;
+    return view;
+}
 /**
  * The server's one tool outcome rule (TAL-313), for a live `raw_result` and a persisted tool-role content alike: a result
  * is an error when it parses to an object with a non-empty `error`, a non-zero numeric `exit_code` / `exitCode`, or
- * `success: false`. `result_text` is the result's display snippet.
+ * `success: false`. `result_text` is the result's display snippet; `result_view` its display sections (TAL-315).
  */
 export function toolOutcome(raw) {
     const value = Array.isArray(raw) ? messageText(raw) : raw;
@@ -332,7 +486,7 @@ export function toolOutcome(raw) {
     }
     const exit = isDict(data) ? data.exit_code ?? data.exitCode : undefined;
     const isError = isDict(data) && (presentError(data.error) || (typeof exit === 'number' && exit !== 0) || data.success === false);
-    return { is_error: isError, result_text: toolResultSnippet(value) };
+    return { is_error: isError, result_text: toolResultSnippet(value), result_view: toolResultView(raw) };
 }
 const finiteOrNull = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
 function nearestAssistantIdx(messages, msgIdx) {
@@ -444,7 +598,8 @@ export function extractToolCallsFromMessages(messages, liveToolCalls = [], recor
  * a call only the session-level list recorded joins the row at its `assistant_msg_idx`, a failed or cancelled turn's
  * partial snapshot shows the live calls it kept, and every call carries `done`
  * (answered, or outside the running turn), `is_error` (`toolOutcome` of its result, else the recorded value), `duration`
- * (recorded live, else `null`) and `result` (the result snippet, else `null`). Returns copies; stored rows are untouched.
+ * (recorded live, else `null`), `result` (the result snippet, else `null`) and `result_view` (its display sections, TAL-315,
+ * else `null`). Returns copies; stored rows are untouched.
  */
 export function withToolCallOutcomes(messages, sessionToolCalls, activeTurnId) {
     // Every identifier a stored call may carry (`ToolCallSchema`).
@@ -521,6 +676,7 @@ export function withToolCallOutcomes(messages, sessionToolCalls, activeTurnId) {
             return {
                 done: Boolean(reply) || answered || !running, is_error: outcome ? outcome.flagged || outcome.is_error : rec?.is_error === true,
                 duration: finiteOrNull(rec?.duration), result: outcome ? outcome.result_text : typeof rec?.snippet === 'string' ? rec.snippet : null,
+                result_view: outcome ? outcome.result_view : isDict(rec?.result_view) ? decidedResultView(rec.result_view) : typeof rec?.snippet === 'string' ? toolResultView(rec.snippet) : null,
             };
         };
         const projected = [
@@ -553,21 +709,130 @@ export function buildPartialMessage(contentText, reasoningText, toolCalls, now =
         msg._partial_tool_calls = [...toolCalls];
     return msg;
 }
-export function stripXmlToolCalls(text) {
-    return text.replace(/<function_calls>[\s\S]*?<\/function_calls>/gi, '').replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '').trimEnd();
+const DSML = '(?:\\s*｜\\s*DSML\\s*[｜|]\\s*)?';
+/** Markdown code (fenced blocks, an unclosed one running to the end, and inline spans): markup written there is literal. */
+function codeRanges(text) {
+    const code = /^ {0,3}(`{3,}|~{3,})[^\n]*(?:\n[\s\S]*?(?:\n {0,3}\1[^\n]*(?=\n|$)|(?![\s\S]))|(?![\s\S]))|(`+)(?!`)(?:[^\n]|\n(?!\n))*?(?<!`)\2(?!`)/gm;
+    return [...text.matchAll(code)].map((m) => [m.index, m.index + m[0].length]);
+}
+const inCode = (code, at) => code.some(([from, to]) => at >= from && at < to);
+/** `re` matches removed, except the ones that start inside Markdown code. */
+function removeOutsideCode(text, re) {
+    const code = codeRanges(text);
+    return text.replace(re, (match, ...rest) => (inCode(code, rest.find((x) => typeof x === 'number') ?? 0) ? match : ''));
+}
+/** Remove provider tool-call XML (`<function_calls>…`, DSML variants, `<tool_call>`), closed or cut off, that leaks into text. */
+export function stripToolCallXml(text) {
+    const lo = text.toLowerCase();
+    if (!lo.includes('function_calls') && !lo.includes('dsml') && !lo.includes('<tool_call'))
+        return text;
+    return [
+        new RegExp(`<${DSML}function_calls>[\\s\\S]*?<\\/${DSML}function_calls>`, 'gi'),
+        new RegExp(`<${DSML}function_calls(?:>|$)[\\s\\S]*$`, 'i'),
+        /<tool_call>[\s\S]*?<\/tool_call>/gi,
+        /<tool_call>[\s\S]*$/i,
+        /<\s*｜\s*DSML\s*[｜|]\s*/gi,
+    ].reduce(removeOutsideCode, text).replace(/^\s+/, '').trimEnd();
+}
+/** Inline thinking openers: `<think>`/`<thinking>` in any case and with attributes (as the Agent's own split), and the channel forms. */
+const THINK_OPEN = /<think(?:ing)?(?:\s[^>]*)?>|<\|channel\|>thought|<\|turn\|>thinking/gi;
+function thinkClose(open) {
+    if (open.toLowerCase().startsWith('<|channel|>'))
+        return /<channel\|>/gi;
+    if (open.toLowerCase().startsWith('<|turn|>'))
+        return /<turn\|>/gi;
+    return /<\/think(?:ing)?\s*>/gi;
+}
+/**
+ * Split assistant text into its visible prose and its inline thinking: every `<think>`, `<thinking>`,
+ * `<|channel|>thought` and `<|turn|>thinking` block anywhere in the text, an unterminated one running to the end.
+ * A tag written inside Markdown code is prose. Tool-call XML leaves both halves; both come back trimmed.
+ */
+export function splitDisplayText(text) {
+    const code = codeRanges(text);
+    let content = '';
+    const reasoning = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        THINK_OPEN.lastIndex = cursor;
+        let open = THINK_OPEN.exec(text);
+        while (open && inCode(code, open.index))
+            open = THINK_OPEN.exec(text);
+        if (!open) {
+            content += text.slice(cursor);
+            break;
+        }
+        content += text.slice(cursor, open.index);
+        const body = open.index + open[0].length;
+        const closer = thinkClose(open[0]);
+        closer.lastIndex = body;
+        const close = closer.exec(text);
+        reasoning.push(text.slice(body, close?.index));
+        if (!close)
+            break;
+        cursor = close.index + close[0].length;
+    }
+    return [stripToolCallXml(content).replace(/^\s+/, '').trimEnd(), joinReasoning(reasoning)];
+}
+/**
+ * Reasoning parts as one display string: tool-call XML removed, blank-line joined, each part once. A part that is
+ * whole paragraphs of another (a settled row's `reasoning` that already took in its `reasoning_content`) is dropped.
+ */
+export function joinReasoning(parts) {
+    const clean = parts.map((part) => stripToolCallXml(part).trim()).filter(Boolean);
+    const within = (outer, inner) => `\n\n${outer}\n\n`.includes(`\n\n${inner}\n\n`);
+    return clean.filter((p, i) => !clean.some((q, j) => j !== i && (q === p ? j < i : within(q, p)))).join('\n\n');
 }
-/** Split inline `<think>` blocks out of assistant content (Python `_split_thinking_from_content`, reduced). */
-export function splitThinkingFromContent(content, existingReasoning = '') {
-    const parts = [];
-    const cleaned = content.replace(/<think(?:ing)?\b[^>]*>([\s\S]*?)<\/think(?:ing)?>/gi, (_m, inner) => { parts.push(inner.trim()); return ''; });
-    const reasoning = [existingReasoning.trim(), ...parts].filter(Boolean).join('\n\n');
-    return [cleaned.replace(/^\s+/, '').trimEnd(), reasoning];
+/** A message's reasoning fields as one string: `reasoning_content`, `reasoning` (text or a list of text parts), `thinking`. */
+export function reasoningFieldsText(m) {
+    const listed = Array.isArray(m.reasoning) ? m.reasoning.map((part) => (isDict(part) ? reasoningBlockText(part) : str(part))) : [str(m.reasoning)];
+    return joinReasoning([str(m.reasoning_content), ...listed, str(m.thinking)]);
+}
+/**
+ * The one display shape of an assistant row: `content` without inline thinking or tool-call XML (typed `thinking` /
+ * `reasoning` parts leave a list), and every piece of reasoning in one `reasoning` string. `reasoning_content` and
+ * `thinking` are not sent. Idempotent; other rows pass through. A copy: stored rows and model history are untouched.
+ */
+export function normalizeAssistantDisplay(message) {
+    if (!isDict(message) || message.role !== 'assistant')
+        return message;
+    const m = { ...message };
+    delete m.reasoning_content;
+    delete m.thinking;
+    delete m.reasoning;
+    const parts = [reasoningFieldsText(message)];
+    if (typeof m.content === 'string') {
+        const [content, inline] = splitDisplayText(m.content);
+        // Only text something was taken out of is rewritten: plain prose keeps its exact whitespace (an indented code block).
+        if (content !== m.content.trim())
+            m.content = content;
+        parts.push(inline);
+    }
+    else if (Array.isArray(m.content)) {
+        m.content = m.content.flatMap((part) => {
+            if (!isDict(part))
+                return [part];
+            if (isReasoningBlock(part)) {
+                parts.push(reasoningBlockText(part));
+                return [];
+            }
+            if (typeof part.text !== 'string')
+                return [part];
+            const [text, inline] = splitDisplayText(part.text);
+            parts.push(inline);
+            return text === part.text.trim() ? [part] : text ? [{ ...part, text }] : [];
+        });
+    }
+    const reasoning = joinReasoning(parts);
+    return (reasoning ? { ...m, reasoning } : m);
 }
 /**
  * Python `merge_session_messages_append_only`, bounded to its load-bearing rules: state.db rows never delete a local
  * row; rows that replay the sidecar (same role, timestamp, and content) are skipped; rows at or before the sidecar's
  * newest timestamp are already represented locally; a truncation watermark hides rows the user cut (0 blocks every
- * replay). Rows past the sidecar tail (a conversation continued from the CLI) are appended in state.db order.
+ * replay): rows at or before it, and, for a truncation cut, rows after it until the sidecar advances past it (TAL-504).
+ * A compression watermark only covers the compressed rows. Rows past the sidecar tail (a conversation continued from the
+ * CLI) are appended in state.db order.
  * ponytail: the Python identity memo (api_content sidecars, message ids, workspace-prefix normalisation) is not ported;
  * add it if a mixed WebUI/CLI transcript shows duplicated turns.
  */
@@ -586,7 +851,7 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
         }
         if (watermark === 0)
             return [];
-        return state.filter((m) => { const t = ts(m); return t !== null && t > watermark; });
+        return state.filter((m) => { const t = ts(m); return t !== null && (opts.compressedWatermark === true ? t > watermark : t <= watermark); });
     }
     const seen = new Set(sidecar.map(key));
     let maxSidecar = null;
@@ -595,6 +860,8 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
         if (t !== null && (maxSidecar === null || t > maxSidecar))
             maxSidecar = t;
     }
+    // Until a new turn lands in the sidecar, every state.db row past the watermark is the deleted suffix.
+    const advanced = !hasWatermark || opts.compressedWatermark === true || (maxSidecar !== null && maxSidecar > watermark);
     const merged = [...sidecar];
     for (const m of state) {
         const k = key(m);
@@ -603,7 +870,7 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
         const t = ts(m);
         if (maxSidecar !== null && t !== null && t <= maxSidecar)
             continue;
-        if (hasWatermark && t !== null && t <= watermark)
+        if (hasWatermark && t !== null && (t <= watermark || !advanced))
             continue;
         seen.add(k);
         merged.push(m);
@@ -644,6 +911,46 @@ export function attachmentObjects(items) {
 export function withAttachmentObjects(messages) {
     return messages.map((m) => (isDict(m) && Array.isArray(m.attachments) && m.attachments.some((a) => typeof a === 'string') ? { ...m, attachments: attachmentObjects(m.attachments) } : m));
 }
+/** A scene's prose rows with `display_text` and `media` where `project` rewrites their text; the same array when none does. */
+export function withSceneRowMedia(rows, project) {
+    if (!Array.isArray(rows))
+        return rows;
+    let changed = false;
+    const out = rows.map((row) => {
+        if (!isDict(row) || row.role !== 'prose' || typeof row.text !== 'string')
+            return row;
+        const projected = project(row.text);
+        if (!projected)
+            return row;
+        changed = true;
+        return { ...row, display_text: projected.text, media: projected.media };
+    });
+    return changed ? out : rows;
+}
+/**
+ * TAL-186: assistant rows with `_display_content` and `_media`, and their scenes with `final_answer_display` /
+ * `final_answer_media` and prose rows' `display_text` / `media`, wherever `project` rewrites media references in the
+ * text. Runs after scene hydration and before body excerpts, which are cut from the display text. Returns copies.
+ */
+export function withDisplayMedia(messages, project) {
+    return messages.map((m) => {
+        if (!isDict(m) || m.role !== 'assistant')
+            return m;
+        let out = m;
+        const projected = project(messageText(m.content));
+        if (projected)
+            out = { ...out, _display_content: projected.text, _media: projected.media };
+        const scene = m._anchor_activity_scene;
+        if (isDict(scene)) {
+            const final = typeof scene.final_answer === 'string' ? project(scene.final_answer) : null;
+            const rows = withSceneRowMedia(scene.activity_rows, project);
+            if (final || rows !== scene.activity_rows) {
+                out = { ...out, _anchor_activity_scene: { ...scene, activity_rows: rows, ...(final ? { final_answer_display: final.text, final_answer_media: final.media } : {}) } };
+            }
+        }
+        return out;
+    });
+}
 /** TAL-456: a settled user or assistant body longer than this ships a collapsed excerpt for clients to render. */
 export const BODY_EXCERPT_LIMIT = 3000;
 const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
@@ -663,7 +970,7 @@ function bodyExcerpt(text) {
     return head.slice(0, cut).trimEnd();
 }
 /**
- * TAL-456: stamps `_display_excerpt` and `_display_truncated` on settled user and assistant rows whose text is longer than
+ * TAL-456: stamps `_display_excerpt` and `_display_truncated` on settled user and assistant rows whose display text is longer than
  * `BODY_EXCERPT_LIMIT`, and `final_answer_excerpt` on a settled scene whose final answer is, so clients render a bounded
  * excerpt instead of laying out the whole body. Full text stays for copy and edit; the running turn's rows are left alone.
  * Runs after scene hydration. Returns copies; stored rows are untouched.
@@ -675,12 +982,13 @@ export function withBodyExcerpts(messages, activeTurnId) {
         if (activeTurnId && m._turn_id === activeTurnId)
             return m;
         let out = m;
-        const text = messageText(m.content);
+        const text = typeof m._display_content === 'string' ? m._display_content : messageText(m.content);
         if (text.length > BODY_EXCERPT_LIMIT)
             out = { ...out, _display_excerpt: bodyExcerpt(text), _display_truncated: true };
         const scene = m._anchor_activity_scene;
-        if (isDict(scene) && typeof scene.final_answer === 'string' && scene.final_answer.length > BODY_EXCERPT_LIMIT) {
-            out = { ...out, _anchor_activity_scene: { ...scene, final_answer_excerpt: bodyExcerpt(scene.final_answer) } };
+        const finalAnswer = isDict(scene) ? (typeof scene.final_answer_display === 'string' ? scene.final_answer_display : scene.final_answer) : null;
+        if (isDict(scene) && typeof finalAnswer === 'string' && finalAnswer.length > BODY_EXCERPT_LIMIT) {
+            out = { ...out, _anchor_activity_scene: { ...scene, final_answer_excerpt: bodyExcerpt(finalAnswer) } };
         }
         return out;
     });