@maudecode/talaria-web 1.15.0 → 1.17.2

package/dist/sessions/merge.js

@@ -3,9 +3,11 @@
  * `_merge_display_messages_after_agent_result`, `_message_identity`,
  * `_extract_tool_calls_from_messages`, `_build_partial_message`).
  */
-import { buildActiveTurnToken } from '../redact.js';
+import { buildActiveTurnToken, completedToolIndex } from '../redact.js';
+import { RunJournal } from './journal.js';
 import { str } from '../util.js';
 import { stripAttachedFilesMarker } from './session.js';
+import { decidedEditDiff, toolEditDiff, toolName } from './tool-display.js';
 export const WORKSPACE_PREFIX_RE = /^\s*\[Workspace::v1:\s*(?:\\.|[^\]\\])+\]\s*/;
 const LEGACY_WORKSPACE_PREFIX_RE = /^\s*\[Workspace:[^\]]+\]\s*/;
 const TOOL_RESULT_SNIPPET_MAX = 4000;
@@ -55,7 +57,7 @@ export function messageText(content) {
     }
     return str(content);
 }
-export function messageIdentity(msg) {
+export function messageIdentity(msg, textLimit = 500) {
     if (!isDict(msg))
         return null;
     const role = str(msg.role);
@@ -75,7 +77,7 @@ export function messageIdentity(msg) {
         return null;
     }
     const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
-    return JSON.stringify([role, text.split(/\s+/).join(' ').trim().slice(0, 500), str(msg.tool_call_id), JSON.stringify(sortKeysDeep(toolCalls))]);
+    return JSON.stringify([role, text.split(/\s+/).join(' ').trim().slice(0, textLimit), str(msg.tool_call_id), JSON.stringify(sortKeysDeep(toolCalls))]);
 }
 function sortKeysDeep(value) {
     if (Array.isArray(value))
@@ -96,13 +98,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);
@@ -196,6 +228,17 @@ export function injectMaxIterationSummaryFallback(messages, finalResponse) {
         return messages;
     return [...messages, { role: 'assistant', content: finalResponse, _max_iteration_summary_fallback: true }];
 }
+/**
+ * TAL-537: the user row the Agent appends to ask for that summary is its own prompt, neither shown nor sent back. It is
+ * the exhausted turn's last user row; any other row with the same text (one the user typed) stays.
+ */
+export function withoutMaxIterationSummaryRequest(messages, request, msgText) {
+    const at = messages.findLastIndex((m) => m.role === 'user');
+    const row = messages[at];
+    if (!request || row?.content !== request || looksLikeCurrentUserTurn(row, msgText))
+        return messages;
+    return messages.filter((_, i) => i !== at);
+}
 export function mergeDisplayMessagesAfterAgentResult(previousDisplay, previousContext, resultMessages, msgText, opts = {}) {
     const display = previousDisplay.filter((m) => !isContextCompressionMarker(m));
     const seenPartial = new Set();
@@ -314,10 +357,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 +499,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 +611,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`).
@@ -515,25 +683,70 @@ export function withToolCallOutcomes(messages, sessionToolCalls, activeTurnId) {
         if (!calls.length && !records.length)
             return m;
         const running = Boolean(activeTurnId) && m._turn_id === activeTurnId;
-        const resolve = (id, rec, answered) => {
+        const resolve = (id, name, rec, answered) => {
             const reply = id ? replies.get(key(index, id)) : undefined;
             const outcome = reply ? { ...toolOutcome(reply.content), flagged: reply.is_error } : null;
+            // TAL-448: a file edit's change, from its full reply, else the one its live record decided.
+            const editDiff = reply ? toolEditDiff(name, reply.content) : decidedEditDiff(rec?.edit_diff);
             return {
+                ...(editDiff ? { edit_diff: editDiff } : {}),
                 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 = [
-            ...calls.map((call) => (isDict(call) ? { ...call, ...resolve(callId(call), recorded.get(callId(call)), false) } : call)),
+            ...calls.map((call) => (isDict(call) ? { ...call, ...resolve(callId(call), toolName(call), recorded.get(callId(call)), false) } : call)),
             ...records.map((tc) => ({
                 ...(str(tc.tid) ? { id: str(tc.tid) } : {}), type: 'function', function: { name: str(tc.name), arguments: JSON.stringify(tc.args ?? {}) },
                 // A session-level entry was answered; a live call says whether it completed.
-                ...resolve(str(tc.tid), tc, typeof tc.done === 'boolean' ? tc.done : true),
+                ...resolve(str(tc.tid), tc.name, tc, typeof tc.done === 'boolean' ? tc.done : true),
             })),
         ];
         return { ...m, tool_calls: projected };
     });
 }
+/** The prompt text naming every attached file by path after it (TAL-276), so an attachment-only turn still asks something. */
+export function attachedFilesPrompt(text, attachments) {
+    const named = attachments.map((att) => (isDict(att) ? str(att.path).trim() : '')).filter(Boolean).map(escapeWorkspacePrefixPath);
+    return named.length ? `${text}\n\n[Attached files: ${named.join(', ')}]` : text;
+}
+const TOOL_IMAGE_PART_TYPES = new Set(['image', 'image_url', 'input_image']);
+/**
+ * TAL-544, Python `_compact_image_parts_for_persistence`: a settled turn's tool-result images (browser and vision
+ * screenshots) become `[screenshot]` text, so saves, loads and later turns stop carrying the base64. A result is a `tool`
+ * row or an Anthropic-style `tool_result` block in a user row; the user's own attachments stay.
+ */
+export function withoutToolImages(messages) {
+    const isImage = (p) => isDict(p) && TOOL_IMAGE_PART_TYPES.has(p.type);
+    const hasImage = (parts) => Array.isArray(parts) && parts.some(isImage);
+    const compact = (parts) => parts.map((p) => (isImage(p) ? { type: 'text', text: '[screenshot]' } : p));
+    const isImageResult = (p) => isDict(p) && p.type === 'tool_result' && hasImage(p.content);
+    const out = messages.map((m) => {
+        const content = m.content;
+        if (m.role === 'tool' && hasImage(content))
+            return { ...m, content: compact(content) };
+        if (m.role === 'user' && Array.isArray(content) && content.some(isImageResult)) {
+            return { ...m, content: content.map((p) => (isImageResult(p) ? { ...p, content: compact(p.content) } : p)) };
+        }
+        return m;
+    });
+    // The same array when nothing changed, so a caller can tell whether its rows were rewritten.
+    return out.some((m, i) => m !== messages[i]) ? out : messages;
+}
+/** A settled model context without an assistant row repeated back to back, and without tool-result images. */
+export function dedupeContext(messages) {
+    const out = [];
+    let lastKey = null;
+    for (const m of withoutToolImages(messages)) {
+        const key = messageIdentity(m);
+        if (key !== null && key === lastKey && m.role === 'assistant')
+            continue;
+        out.push(m);
+        lastKey = key;
+    }
+    return out;
+}
 /** Python `_build_partial_message`. */
 export function buildPartialMessage(contentText, reasoningText, toolCalls, now = Date.now() / 1000) {
     let stripped = '';
@@ -553,21 +766,196 @@ 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();
+/**
+ * TAL-536: a dead run's journaled output as partial rows, in order: each row is a stretch of reasoning and prose with the
+ * tool calls that followed it, the shape a Stop's snapshot keeps. A run that ended in `done` gets its answer as a settled
+ * row: its last prose row, else the one the `done` frame's session carries (an answer that never streamed, like the
+ * tool-limit summary). `answered` says the run finished with one.
+ */
+export function journalOutputRows(events, turnId) {
+    const rows = [];
+    const calls = [];
+    let text = '';
+    let reasoning = '';
+    let tools = [];
+    let at = 0;
+    const flush = () => {
+        const row = buildPartialMessage(text, reasoning, tools, at);
+        if (row)
+            rows.push({ ...row, _turn_id: turnId });
+        text = '';
+        reasoning = '';
+        tools = [];
+    };
+    for (const e of events) {
+        const p = isDict(e.payload) ? e.payload : {};
+        if ((e.event === 'token' || e.event === 'reasoning') && tools.length)
+            flush();
+        if (e.event === 'token')
+            text += str(p.text);
+        else if (e.event === 'reasoning')
+            reasoning += str(p.text);
+        else if (e.event === 'tool') {
+            const call = { name: p.name, args: p.args ?? {}, tid: str(p.id), done: false };
+            calls.push(call);
+            tools.push(call);
+        }
+        else if (e.event === 'tool_complete') {
+            // The record is shared with the row that holds it, so a completion after its row closed still lands.
+            const call = calls[completedToolIndex(calls, str(p.id), p.name)];
+            if (call)
+                Object.assign(call, { done: true, snippet: p.preview, is_error: p.is_error === true, duration: p.duration ?? null, ...(isDict(p.result_view) ? { result_view: p.result_view } : {}), ...(isDict(p.edit_diff) ? { edit_diff: p.edit_diff } : {}) });
+        }
+        else
+            continue;
+        at = e.created_at || at;
+    }
+    flush();
+    const done = RunJournal.selectAuthoritativeTerminalEvent(events);
+    if (done?.event !== 'done')
+        return { rows, answered: false };
+    // The last row answers only with visible prose and no calls after it (a reasoning-only segment is no answer).
+    const last = rows[rows.length - 1];
+    if (last && !last._partial_tool_calls && str(last.content)) {
+        delete last._partial;
+        return { rows, answered: true };
+    }
+    const settled = isDict(done.payload) && isDict(done.payload.session) && Array.isArray(done.payload.session.messages) ? done.payload.session.messages : [];
+    const answer = settled.findLast((m) => isDict(m) && m.role === 'assistant' && m._turn_id === turnId);
+    // Its visible prose, from string or structured content, as the scene's final answer reads it.
+    const content = answer && !answer._error && !(Array.isArray(answer.tool_calls) && answer.tool_calls.length) ? splitDisplayText(messageText(answer.content))[0] : '';
+    if (!content)
+        return { rows, answered: false };
+    rows.push({ role: 'assistant', content, timestamp: Math.trunc(done.created_at), _turn_id: turnId });
+    return { rows, answered: true };
+}
+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 : ''));
 }
-/** 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];
+/** 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');
+}
+/** 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.
+ * TAL-493: once a boundary or settled turn recorded the highest state.db id it read (`stateDbSeenId`) and the rows carry
+ * ids, identity replaces the timestamp rules: rows up to that id are covered, and every newer row not already in the
+ * sidecar is appended, even one a writer stamped before the newest local row or the watermark but committed later.
  * 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.
  */
@@ -578,6 +966,31 @@ export function mergeSessionMessagesAppendOnly(sidecar, state, opts = {}) {
         return sidecar;
     const ts = (m) => { const n = Number(m.timestamp); return Number.isFinite(n) ? n : null; };
     const key = (m) => `${String(m.role)}\0${String(ts(m) ?? '')}\0${typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? null)}`;
+    const seenId = opts.stateDbSeenId;
+    if (typeof seenId === 'number' && Number.isFinite(seenId) && state.some((m) => stateDbRowId(m) !== null)) {
+        // Each local row stands for at most one new state.db row: a persisted copy by its id, any other by its key.
+        const localIds = new Set(sidecar.map(stateDbRowId));
+        const localKeys = new Map();
+        for (const m of sidecar)
+            if (stateDbRowId(m) === null)
+                localKeys.set(key(m), (localKeys.get(key(m)) ?? 0) + 1);
+        const merged = [...sidecar];
+        for (const m of state) {
+            const id = stateDbRowId(m);
+            if (id !== null && localIds.has(id))
+                continue;
+            // In state.db order, so a covered row matches its own local copy before a newer duplicate can.
+            const left = localKeys.get(key(m)) ?? 0;
+            if (left > 0) {
+                localKeys.set(key(m), left - 1);
+                continue;
+            }
+            if (id === null || id <= seenId)
+                continue;
+            merged.push(m);
+        }
+        return merged;
+    }
     if (!sidecar.length) {
         if (!hasWatermark) {
             const seen = new Set();
@@ -586,7 +999,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 +1008,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,13 +1018,28 @@ 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);
     }
     return merged;
 }
+/** The Agent's `messages.id` a state.db row was read with, or null for a database without the column. */
+function stateDbRowId(m) {
+    const id = m._state_db_row_id;
+    return typeof id === 'number' && Number.isFinite(id) ? id : null;
+}
+/** TAL-493: the `state_db_seen_id` after reading `rows`: their highest id, or null when they carry none. */
+export function stateDbSeenId(rows) {
+    let max = null;
+    for (const m of rows) {
+        const id = stateDbRowId(m);
+        if (id !== null && (max === null || id > max))
+            max = id;
+    }
+    return max;
+}
 /**
  * TAL-316: the merged transcript without the running turn's output, which the run journal replays from its start. The turn
  * begins at its checkpointed prompt, else at its first stamped row or the first state.db row appended past the sidecar
@@ -644,6 +1074,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 +1133,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 +1145,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;
     });
@@ -758,7 +1229,8 @@ export function stoppedTurnContext(previousContext, checkpoint, prompt, msgText,
     // A tool result is a `tool` row or an Anthropic-style user row of `tool_result` blocks. A steer the Agent applied is
     // neither a prompt nor a result: the boundary goes after it, and it never makes the turn look unanswered.
     const toolResult = (m) => m?.role === 'tool' || (m?.role === 'user' && Array.isArray(m.content) && m.content.some((part) => isDict(part) && part.type === 'tool_result'));
-    const tail = () => sanitizeMessagesForApi(rows.filter((m) => agentSteerText(m) === null)).at(-1);
+    // The next turn's own history projection, so an answer the Agent replays from `api_content` counts.
+    const tail = () => sanitizeMessagesForApi(rows.filter((m) => agentSteerText(m) === null), { preserveApiContent: true }).at(-1);
     if (toolResult(tail()))
         rows.push({ role: 'assistant', content: unsettled || 'Operation interrupted.' });
     else if (unsettled)
@@ -783,6 +1255,10 @@ export function agentSteerText(m) {
         return inner.trim();
     return m.display_kind === 'steer' ? content.trim() : null;
 }
+/** The Agent's `api_content` replay sidecar: the exact bytes a user/assistant row was sent as, else undefined. */
+function apiContent(msg) {
+    return (msg.role === 'user' || msg.role === 'assistant') && typeof msg.api_content === 'string' && msg.api_content ? msg.api_content : undefined;
+}
 /** Python `_is_reasoning_only_assistant_message`: a display-only Thinking card with no visible reply. */
 function isReasoningOnlyAssistant(msg) {
     if (msg.role !== 'assistant' || (Array.isArray(msg.tool_calls) && msg.tool_calls.length))
@@ -807,8 +1283,10 @@ function stripOobBlocks(content) {
  * reasoning-only assistants), orphaned tool rows and unanswered tool calls, keeps only API-safe keys, strips consumed
  * out-of-band blocks, and keeps a cancelled (`_recovered`) user prompt only where it separates two assistant turns —
  * otherwise the neighbours fuse cleanly or the prompt is stale, and replaying it would answer it again.
+ * `preserveApiContent` (Python `_sanitize_messages_for_agent`) keeps the Agent's `api_content` replay sidecar on
+ * user/assistant rows for turn history; compression and other projections strip it.
  */
-export function sanitizeMessagesForApi(messages) {
+export function sanitizeMessagesForApi(messages, { preserveApiContent = false } = {}) {
     // Calls are OpenAI `tool_calls` or Anthropic-style `tool_use` content blocks; results name them by `tool_call_id`,
     // `tool_use_id`, or a user row's `tool_result` blocks.
     const toolUseIds = (msg) => (Array.isArray(msg.content) ? msg.content.flatMap((part) => (isDict(part) && part.type === 'tool_use' && str(part.id) ? [str(part.id)] : [])) : []);
@@ -828,7 +1306,9 @@ export function sanitizeMessagesForApi(messages) {
     for (const msg of messages) {
         if (!msg || typeof msg !== 'object')
             continue;
-        if (isReasoningOnlyAssistant(msg))
+        // A reasoning-only clean stop the Agent answered from `api_content` is a reply, not a Thinking card.
+        const replay = preserveApiContent ? apiContent(msg) : undefined;
+        if (isReasoningOnlyAssistant(msg) && !replay)
             continue;
         // The Agent already received a steer mid-turn; its persisted row is display-only.
         if (msg._error || isDict(msg._steer))
@@ -844,6 +1324,8 @@ export function sanitizeMessagesForApi(messages) {
         const sanitized = Object.fromEntries(Object.entries(msg).filter(([k]) => API_SAFE_MSG_KEYS.has(k)));
         if (Array.isArray(sanitized.tool_calls) && !sanitized.tool_calls.length)
             Reflect.deleteProperty(sanitized, 'tool_calls');
+        if (replay)
+            sanitized.api_content = replay;
         if (recovered)
             sanitized._recovered = true;
         if ('content' in sanitized)
@@ -866,7 +1348,7 @@ export function sanitizeMessagesForApi(messages) {
                 continue;
             msg = { ...msg, content: parts };
             // Reasoning left behind by a dropped call is not an answer either.
-            if (isReasoningOnlyAssistant(msg))
+            if (isReasoningOnlyAssistant(msg) && !apiContent(msg))
                 continue;
         }
         if (msg.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length) {
@@ -895,4 +1377,33 @@ export function sanitizeMessagesForApi(messages) {
     }
     return final;
 }
+const isNativeImagePart = (part) => isDict(part) && (part.type === 'image_url' || 'image_url' in part);
+/** True when any row's content carries a native `image_url` part. */
+export function hasNativeImages(messages) {
+    return messages.some((msg) => Array.isArray(msg.content) && msg.content.some(isNativeImagePart));
+}
+/**
+ * Python `_strip_native_image_parts_from_content` (TAL-545): the history for a turn whose image mode resolved to text.
+ * Native `image_url` parts are dropped and the text kept; a lone text part collapses to its string, as a text-only
+ * provider rejects a replayed image before the Agent's own strip-and-retry guard can recover.
+ */
+export function withoutNativeImages(messages) {
+    return messages.map((msg) => {
+        if (!Array.isArray(msg.content) || !msg.content.some(isNativeImagePart))
+            return msg;
+        const parts = msg.content.filter((part) => isDict(part) && !isNativeImagePart(part));
+        const content = !parts.length ? '' : parts.length === 1 && parts[0].type === 'text' ? str(parts[0].text) : parts;
+        return { ...msg, content };
+    });
+}
+/**
+ * TAL-545: the image-free history is one request's projection, never the session's. The Agent hands the history it got
+ * back ahead of its own rows, so each row it returned exactly as sent (`sent[i]`, stripped from `original[i]`) is swapped
+ * back for the original; a row the Agent rewrote stays its own.
+ */
+export function withNativeImagesRestored(rows, sent, original) {
+    if (sent === original)
+        return rows;
+    return rows.map((row, i) => (i < sent.length && sent[i] !== original[i] && JSON.stringify(row) === JSON.stringify(sent[i]) ? original[i] : row));
+}
 //# sourceMappingURL=merge.js.map