@maudecode/talaria-web 1.15.0 → 1.16.1

package/dist/sessions/service.js

@@ -4,19 +4,22 @@ import { rmSync } from 'node:fs';
 import { buildActiveTurnToken, copyJson, redactSessionData, redactValue, stripPublicInternalFields, withSceneToolDisplay } from '../redact.js';
 import { DraftVersionConflict, normalizeDraftVersion } from './drafts.js';
 import { allSessions, buildSessionListPayload, CLI_IDENTITY_FIELDS, isClaimableCliSource, isMessagingSessionRecord, withOwnerLocks, withSessionWireFlags, lineageRootId, mergeCliSidebarMetadata, sessionListResponse, sessionSearchMessageText, sessionSearchPreview } from './list.js';
-import { anchorSceneIntOrNull, hydrateAnchorActivityScenes, normalizeAnchorSceneMessageRef, readAnchorSceneRows, storeAnchorScene, withTurnIds } from './anchor.js';
-import { isSafeSessionId, lastMessageTimestamp, Session, titleFrom } from './session.js';
+import { anchorSceneIntOrNull, fullToolResult, hydrateAnchorActivityScenes, normalizeAnchorSceneMessageRef, readAnchorSceneRows, storeAnchorScene, withTurnIds } from './anchor.js';
+import { isSafeSessionId, lastMessageTimestamp, Session, stripAttachedFilesMarker, titleFrom } from './session.js';
 import { SessionBusy, SessionNotFound, statSignature } from './store.js';
 import { attachTodoState } from './todo.js';
 import { stateDbSessionMessages, stateDbSessionRow, stateDbSessionSources } from './state-db.js';
 import { anchorMessageKey, anchorSummary, CompressionJobs, visibleMessagesForAnchor } from './compress.js';
 import { SidecarError } from '../sidecar/client.js';
-import { attachmentObjects, isContextCompressionMarker, mergeSessionMessagesAppendOnly, pendingUserRow, sanitizeMessagesForApi, withAttachmentObjects, withBodyExcerpts, withPendingUserTurn, withToolCallOutcomes, withoutRunningTurnOutput } from './merge.js';
+import { attachmentObjects, isContextCompressionMarker, mergeSessionMessagesAppendOnly, pendingUserRow, sanitizeMessagesForApi, stripWorkspacePrefix, withAttachmentObjects, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withSceneRowMedia, withPendingUserTurn, withToolCallOutcomes, withoutRunningTurnOutput } from './merge.js';
 import { withBackgroundUpdates } from './background-updates.js';
 import { withBackgroundLinks } from './background-tasks.js';
 import { messagesForLimitedPayload, messageWindowForDisplay, MAX_MSG_LIMIT, parseMsgLimit, toolCallsForMessageWindow } from './window.js';
 import { redactText } from '../redact.js';
+import { workspaceDisplayName } from '../workspace/workspaces.js';
 import { buildShareSnapshot } from './shares.js';
+import { mediaAnchorRoot, mediaRefPath, mediaTarget } from '../workspace/media.js';
+import { projectMediaRefs } from '../workspace/media-refs.js';
 import { loadGatewaySessionIdentityMap } from './list.js';
 import { join } from 'node:path';
 export class HttpFailure extends Error {
@@ -57,6 +60,37 @@ export class SessionService {
         this.compressionJobs = new CompressionJobs();
     }
     get store() { return this.deps.store; }
+    /**
+     * TAL-186: rewrites a session's media references to their URLs. A local path is rewritten only when `/api/media`
+     * serves it for this session, under the same resolution, so every rewritten reference loads.
+     */
+    mediaProjector(s) {
+        const media = this.deps.media;
+        const served = new Map();
+        const localUrl = (path) => {
+            if (!media?.localIo(s.profile))
+                return null;
+            if (served.has(path))
+                return served.get(path) ?? null;
+            let url = null;
+            try {
+                const target = mediaTarget(mediaRefPath(path));
+                if (mediaAnchorRoot(target, s, media.access))
+                    url = `./api/media?${new URLSearchParams({ path: target, session_id: s.session_id }).toString()}`;
+            }
+            catch { /* an invalid path stays text */ }
+            served.set(path, url);
+            return url;
+        };
+        const workspace = s.workspace.trim() || null;
+        // A scene's final answer usually repeats its row's text: each distinct text is parsed once.
+        const projected = new Map();
+        return (text) => {
+            if (!projected.has(text))
+                projected.set(text, projectMediaRefs(text, { workspace, localUrl }));
+            return projected.get(text) ?? null;
+        };
+    }
     publish(reason, profile, sessionId) {
         this.deps.events.publish(reason, { profile: profile ?? null, sessionId: sessionId ?? null });
     }
@@ -163,7 +197,7 @@ export class SessionService {
     mergedTranscript(s, local = s.messages, stateRows = this.stateDbRows(s)) {
         if (!stateRows.length)
             return local;
-        return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark });
+        return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed });
     }
     /**
      * Python `reconciled_state_db_messages_for_session(prefer_context=True)`: the model history is the owner context
@@ -174,6 +208,15 @@ export class SessionService {
         const local = s.context_messages.length ? s.context_messages : s.messages.filter((m) => !m._error && !m._partial);
         return local.some((m) => isContextCompressionMarker(m)) ? local : this.mergedTranscript(s, local, stateRows ?? this.stateDbRows(s));
     }
+    /**
+     * TAL-518: the model context a `/btw` clone inherits: the chat's history plus its running turn's prompt, which
+     * deferred save keeps out of `messages` and `context_messages` until settlement.
+     */
+    sideQuestionContext(s) {
+        const context = structuredClone(this.modelContext(s));
+        const pending = this.pendingTurn(s);
+        return pending ? withPendingUserTurn(context, pending) : context;
+    }
     /** Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile. */
     lookupCliMeta(sid) {
         try {
@@ -279,12 +322,33 @@ export class SessionService {
         const payload = this.wireRow(s);
         // Mutation replies replace a client's transcript, so they carry the same server-built scenes as the detail.
         if (withMessages)
-            payload.messages = this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withTurnIds(s.messages), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id }));
+            payload.messages = this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withMarkerKinds(withTurnIds(s.messages)), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, runningScene: !this.journaledActiveTurn(s) }));
         return redactSessionData(payload, this.deps.redactEnabled());
     }
     /** `compact()` with the wire streaming/read-only flags (TAL-312), for replies that return the session row. */
     wireRow(s) {
-        return withSessionWireFlags({ ...s.compact({ contextLengthFor: this.deps.contextLengthFor }), read_only: this.isReadOnly(s), assistant_name: this.assistantName(s) }, this.deps.runtime.activeStreamIds);
+        return withSessionWireFlags({ ...s.compact({ contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }), read_only: this.isReadOnly(s), assistant_name: this.assistantName(s), workspace_name: this.workspaceNames()(s) }, this.deps.runtime.activeStreamIds);
+    }
+    /**
+     * TAL-303: the label for a session's workspace, from its own profile's registry (a profileless row is the root's).
+     * One resolver serves one response, so each profile's registry is read once however many rows it names.
+     */
+    workspaceNames() {
+        const registries = new Map();
+        return (row) => {
+            const profile = str(row.profile) || 'default';
+            let entries = registries.get(profile);
+            if (!entries) {
+                try {
+                    entries = this.deps.workspaces.entries(profile);
+                }
+                catch {
+                    entries = [];
+                }
+                registries.set(profile, entries);
+            }
+            return workspaceDisplayName(str(row.workspace), entries);
+        };
     }
     /** The agent's display name for a session's profile (`assistant_name`). */
     assistantName(s) {
@@ -328,7 +392,7 @@ export class SessionService {
         if (journaled)
             transcript = withoutRunningTurnOutput(transcript, { ...journaled, localCount: s.messages.length });
         // Turn ids, tool outcomes and scenes are computed over the full transcript, so every window reports the same values.
-        const all = loadMessages ? withBodyExcerpts(this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withTurnIds(withAttachmentObjects(transcript)), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: msgLimit !== null })), s.active_stream_id) : [];
+        const all = loadMessages ? this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(withMarkerKinds(withTurnIds(withAttachmentObjects(transcript))), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, runningScene: !journaled, clipToolResults: msgLimit !== null })) : [];
         let truncated = [];
         let offset = 0;
         let summaryCount = null;
@@ -344,6 +408,8 @@ export class SessionService {
                 truncated = all.slice(prompt, offset + truncated.length);
                 offset = prompt;
             }
+            // Per-row display fields (TAL-186 media, TAL-456 excerpts cut from that display text) only for the rows sent.
+            truncated = withBodyExcerpts(withDisplayMedia(truncated, this.mediaProjector(s)), s.active_stream_id);
             if (msgLimit !== null)
                 truncated = messagesForLimitedPayload(truncated);
         }
@@ -362,7 +428,7 @@ export class SessionService {
         }
         const activeStreamIds = this.deps.runtime.activeStreamIds;
         const raw = {
-            ...s.compact({ includeRuntime: true, activeStreamIds, contextLengthFor: this.deps.contextLengthFor }),
+            ...s.compact({ includeRuntime: true, activeStreamIds, contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }),
             messages: truncated,
             message_count: mergedCount,
             tool_calls: toolCalls,
@@ -390,6 +456,7 @@ export class SessionService {
         raw._load_revision = revisionBefore !== null && revisionBefore === revisionAfter ? hashRevision(revisionBefore) : `unstable-${randomUUID().replace(/-/g, '')}`;
         raw.read_only = this.isReadOnly(s);
         raw.assistant_name = this.assistantName(s);
+        raw.workspace_name = this.workspaceNames()(s);
         withSessionWireFlags(raw, activeStreamIds);
         raw.pending_steers = raw.active_stream_id ? (this.deps.runtime.pendingSteers?.(str(raw.active_stream_id)) ?? []) : [];
         return redactSessionData(raw, this.deps.redactEnabled());
@@ -437,7 +504,7 @@ export class SessionService {
     foreignSessionDetail(sid) {
         const { synth, meta } = this.foreignSession(sid);
         // The same turn projection as a WebUI session: turn ids, tool outcomes, then each completed turn's scene.
-        const msgs = hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(synth.messages), [], null), {});
+        const msgs = hydrateAnchorActivityScenes(withToolCallOutcomes(withMarkerKinds(withTurnIds(synth.messages)), [], null), {});
         const lastTs = Number(msgs[msgs.length - 1]?.timestamp ?? 0) || 0;
         const sess = {
             session_id: synth.session_id, title: synth.title, workspace: synth.workspace, model: synth.model, message_count: msgs.length,
@@ -445,7 +512,7 @@ export class SessionService {
             pinned: synth.pinned, archived: synth.archived, project_id: synth.project_id ?? null, profile: synth.profile,
             is_cli_session: synth.is_cli_session, source_tag: synth.source_tag, raw_source: synth.raw_source, session_source: synth.session_source,
             source_label: synth.source_label, read_only: synth.read_only, can_duplicate: false, messages: msgs, tool_calls: [], transcript_seq: null,
-            assistant_name: this.assistantName(synth),
+            assistant_name: this.assistantName(synth), workspace_name: this.workspaceNames()(synth),
         };
         attachTodoState(sess, msgs);
         const merged = withSessionWireFlags(meta ? mergeCliSidebarMetadata(sess, meta) : sess, this.deps.runtime.activeStreamIds);
@@ -519,7 +586,7 @@ export class SessionService {
         const gatewayIdentity = loadGatewaySessionIdentityMap(join(this.deps.profileHome(activeProfile), 'sessions', 'sessions.json'));
         const truncatedSources = cliRead?.truncated;
         const payload = buildSessionListPayload(this.store, { ...params, ...(cliRows ? { cliRows } : {}), ...(truncatedSources ? { truncatedSources } : {}), gatewayIdentity, stateDbSources: this.stateDbSources, activeProfile, isolatedProfileMode: this.deps.isolatedProfileMode(), profilesMatch: this.deps.profilesMatch });
-        return sessionListResponse(payload, this.deps.runtime, this.deps.redactEnabled(), this.deps.now());
+        return sessionListResponse(payload, this.deps.runtime, this.deps.redactEnabled(), this.deps.now(), this.workspaceNames());
     }
     search(q, opts) {
         const activeProfile = this.deps.activeProfile();
@@ -528,8 +595,10 @@ export class SessionService {
             sessions = sessions.filter((r) => this.deps.profilesMatch(str(r.profile) || null, activeProfile));
         sessions = withOwnerLocks(sessions, this.stateDbSources);
         const redact = this.deps.redactEnabled();
+        const workspaceName = this.workspaceNames();
         const redactRow = (item) => {
             withSessionWireFlags(item, this.deps.runtime.activeStreamIds);
+            item.workspace_name = workspaceName(item);
             if (typeof item.title === 'string')
                 item.title = redactText(item.title, redact);
             for (const f of ['display_title', '_state_db_title', 'parent_title'])
@@ -548,27 +617,61 @@ export class SessionService {
             }
             if (!opts.content)
                 continue;
-            let sess;
-            try {
-                sess = this.store.get(str(s.session_id), { promote: false, cacheOnMiss: false });
+            const hit = this.contentMatch(str(s.session_id), query, opts.depth);
+            if (hit)
+                results.push(redactRow({ ...s, ...hit }));
+        }
+        return { sessions: results, query, count: results.length, all_profiles: opts.allProfiles, active_profile: activeProfile };
+    }
+    /**
+     * TAL-308: the sidebar search. The candidates are exactly the `/api/sessions` rows for `params` (visibility, source,
+     * archived, projection and order), narrowed to `projectId` (`none`: rows without a project), then matched on the
+     * title, then the metadata the row shows (workspace path and name, model, provider, profile, source label), then message content.
+     */
+    sidebarSearch(q, params, opts) {
+        let rows = this.list(params).body.sessions;
+        if (opts.projectId === 'none')
+            rows = rows.filter((r) => !r.project_id);
+        else if (opts.projectId)
+            rows = rows.filter((r) => str(r.project_id) === opts.projectId);
+        const query = q.toLowerCase().trim();
+        const base = { all_profiles: params.allProfiles, active_profile: this.deps.activeProfile(), include_archived: params.includeArchived, sidebar_filtered: true };
+        if (!query)
+            return { ...base, sessions: rows };
+        const results = [];
+        for (const row of rows) {
+            if (str(row.title).toLowerCase().includes(query))
+                results.push({ ...row, match_type: 'title' });
+            else if (['workspace', 'workspace_name', 'model', 'model_provider', 'profile', 'source_label'].some((k) => str(row[k]).toLowerCase().includes(query)))
+                results.push({ ...row, match_type: 'metadata' });
+            else if (opts.content) {
+                const hit = this.contentMatch(str(row.session_id), query, opts.depth);
+                if (hit)
+                    results.push({ ...row, ...hit });
             }
-            catch {
+        }
+        return { ...base, sessions: results, query, count: results.length };
+    }
+    /** The first of a stored session's first `depth` messages (0: all) containing `query`, with its redacted excerpt. */
+    contentMatch(sid, query, depth) {
+        let sess;
+        try {
+            sess = this.store.get(sid, { promote: false, cacheOnMiss: false });
+        }
+        catch {
+            return null;
+        }
+        for (const m of depth ? sess.messages.slice(0, depth) : sess.messages) {
+            const c = sessionSearchMessageText(m);
+            if (!c.toLowerCase().includes(query))
                 continue;
-            }
-            const msgs = opts.depth ? sess.messages.slice(0, opts.depth) : sess.messages;
-            for (const m of msgs) {
-                const c = sessionSearchMessageText(m);
-                if (c.toLowerCase().includes(query)) {
-                    const item = { ...s, match_type: 'content' };
-                    const preview = sessionSearchPreview(c, query);
-                    if (preview)
-                        item.match_preview = redactText(preview, redact);
-                    results.push(redactRow(item));
-                    break;
-                }
-            }
+            const item = { match_type: 'content' };
+            const preview = sessionSearchPreview(c, query);
+            if (preview)
+                item.match_preview = redactText(preview, this.deps.redactEnabled());
+            return item;
         }
-        return { sessions: results, query, count: results.length, all_profiles: opts.allProfiles, active_profile: activeProfile };
+        return null;
     }
     // ── status / usage ───────────────────────────────────────────────────────
     status(sid) {
@@ -628,7 +731,8 @@ export class SessionService {
         return toolsets;
     }
     create(body, opts = {}) {
-        const profile = (typeof body.profile === 'string' && body.profile) || null;
+        // Python `new_session`: a body without a profile takes the request's active profile (cookie first).
+        const profile = (typeof body.profile === 'string' && body.profile) || this.deps.activeProfile();
         let prevSessionId = typeof body.prev_session_id === 'string' && body.prev_session_id ? body.prev_session_id : null;
         if (prevSessionId && !this.sessionIdVisible(prevSessionId))
             prevSessionId = null;
@@ -960,6 +1064,7 @@ export class SessionService {
                 // #4836: an intentional-shrink boundary, so append-only state.db reconciliation does not replay compressed rows.
                 live.truncation_watermark = truncationWatermarkFor(compressed);
                 live.truncation_boundary = live.truncation_watermark;
+                live.truncation_watermark_compressed = true;
                 live.last_prompt_tokens = result.after_tokens;
                 live.post_compression_context_tokens_estimate = result.after_tokens;
                 this.store.save(live);
@@ -1029,7 +1134,7 @@ export class SessionService {
                 catch { /* ignore */ }
             }
         });
-        this.deps.runtime.evictAgent(sid);
+        this.deps.runtime.evictAgent(sid, true);
         return { ok: true, session: this.wireRow(s) };
     }
     async retry(sid) {
@@ -1040,11 +1145,19 @@ export class SessionService {
             const lastUser = findLastUserIndex(history);
             if (lastUser === null)
                 return { error: 'No previous message to retry.' };
-            const lastUserText = extractText(history[lastUser]?.content);
+            // What a client resends (TAL-515): the files that reached the model, which only ever got attachments with a path,
+            // and the prompt as typed. The attached-files line is the server's only when such files exist; otherwise the user
+            // typed it. Nothing to resend fails before the exchange is removed.
+            const prompt = history[lastUser];
+            const lastUserText = extractText(prompt.content);
+            const lastUserAttachments = attachmentObjects(Array.isArray(prompt.attachments) ? prompt.attachments : []).filter((a) => isDict(a) && Boolean(str(a.path).trim()));
+            const lastUserPrompt = stripWorkspacePrefix(lastUserAttachments.length ? stripAttachedFilesMarker(lastUserText) : lastUserText, true);
+            if (!lastUserPrompt && !lastUserAttachments.length)
+                return { error: 'The last message has nothing to resend.' };
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
             this.store.save(s);
-            return { ok: true, last_user_text: lastUserText, removed_count: removed };
+            return { ok: true, last_user_text: lastUserText, last_user_prompt: lastUserPrompt, last_user_attachments: lastUserAttachments, removed_count: removed };
         });
     }
     async undo(sid) {
@@ -1069,12 +1182,14 @@ export class SessionService {
         if (!session)
             throw new HttpFailure(404, 'Session not found');
         const now = this.deps.now();
+        // A truncation cut names deleted state.db rows of the source; the copy's own state.db rows are all genuine (TAL-504).
+        const watermark = session.truncation_watermark_compressed ? { truncation_watermark: session.truncation_watermark, truncation_boundary: session.truncation_boundary, truncation_watermark_compressed: true } : {};
         const copied = new Session({
             title: `${session.title || 'Untitled'} (copy)`, workspace: session.workspace, model: session.model, model_provider: session.model_provider,
             messages: copyJson(session.messages), tool_calls: copyJson(session.tool_calls), pinned: false, archived: false, project_id: session.project_id, profile: session.profile,
             input_tokens: session.input_tokens, output_tokens: session.output_tokens, estimated_cost: session.estimated_cost, cache_read_tokens: session.cache_read_tokens, cache_write_tokens: session.cache_write_tokens,
             personality: session.personality, enabled_toolsets: session.enabled_toolsets, context_length: session.context_length, threshold_tokens: session.threshold_tokens,
-            truncation_watermark: session.truncation_watermark, truncation_boundary: session.truncation_boundary, context_messages: copyJson(session.context_messages),
+            ...watermark, context_messages: copyJson(session.context_messages),
             gateway_routing: copyJson(session.gateway_routing), gateway_routing_history: copyJson(session.gateway_routing_history), llm_title_generated: session.llm_title_generated,
             manual_title: session.manual_title, composer_draft: copyJson(session.composer_draft), context_engine: session.context_engine, context_engine_state: copyJson(session.context_engine_state),
             created_at: now, updated_at: now,
@@ -1182,6 +1297,14 @@ export class SessionService {
             await this.store.withLock(sid, () => {
                 if (blocking())
                     throw new HttpFailure(409, 'Session has an active run; stop it before deleting');
+                // A public share outlives its session file, and revokeShare needs the session, so revoke it first.
+                try {
+                    this.deps.shares.revoke(this.store.get(sid, { metadataOnly: true }));
+                }
+                catch (error) {
+                    if (!(error instanceof SessionNotFound))
+                        throw error;
+                }
                 if (!this.store.deleteFiles(sid))
                     throw new HttpFailure(500, 'Failed to delete session data');
             }, { timeoutMs: 5000 });
@@ -1191,7 +1314,7 @@ export class SessionService {
                 throw new HttpFailure(503, 'Session busy, try again');
             throw error;
         }
-        this.deps.runtime.evictAgent(sid);
+        this.deps.runtime.evictAgent(sid, true);
         try {
             rmSync(this.deps.attachmentDir(sid), { recursive: true, force: true });
         }
@@ -1226,6 +1349,13 @@ export class SessionService {
             const shouldDelete = zeroOnly ? s.messages.length === 0 : s.title === 'Untitled' && s.messages.length === 0;
             if (!shouldDelete)
                 continue;
+            // A cleared session keeps its share; keep the session (and its revoke route) if the share cannot be revoked.
+            try {
+                this.deps.shares.revoke(s);
+            }
+            catch {
+                continue;
+            }
             this.store.sessions.delete(s.session_id);
             rmSync(this.store.pathFor(s.session_id), { force: true });
             cleaned += 1;
@@ -1426,36 +1556,50 @@ export class SessionService {
             return { ok: true, ...placement };
         });
     }
-    readAnchorScene(query) {
-        const sid = str(query.session_id).trim();
-        const messageRef = normalizeAnchorSceneMessageRef(query.message_ref);
-        const messageIndex = anchorSceneIntOrNull(query.message_index);
-        if (!sid || (!messageRef && messageIndex === null))
-            throw new HttpFailure(400, 'session_id and message_ref or message_index are required');
-        let session;
-        let transcript;
+    /** The session and the full transcript its detail is built from; a state.db-only session gives its synthesized one. */
+    fullTranscript(sid) {
         try {
-            session = this.store.get(sid);
+            let session = this.store.get(sid);
             if (session.loadedMetadataOnly)
                 session = this.store.load(sid) ?? session;
             if (!this.visibleToActiveProfile(session.profile))
                 throw new HttpFailure(404, 'Session not found');
-            transcript = this.mergedTranscript(session);
+            return { session, transcript: this.mergedTranscript(session), stored: true };
         }
         catch (error) {
             if (error instanceof HttpFailure)
                 throw error;
-            // A state.db-only session pages the same synthesized transcript its detail was built from.
-            session = this.foreignSession(sid).synth;
-            transcript = session.messages;
+            const session = this.foreignSession(sid).synth;
+            return { session, transcript: session.messages, stored: false };
         }
+    }
+    readAnchorScene(query) {
+        const sid = str(query.session_id).trim();
+        const messageRef = normalizeAnchorSceneMessageRef(query.message_ref);
+        const messageIndex = anchorSceneIntOrNull(query.message_index);
+        if (!sid || (!messageRef && messageIndex === null))
+            throw new HttpFailure(400, 'session_id and message_ref or message_index are required');
+        const { session, transcript, stored } = this.fullTranscript(sid);
         const result = readAnchorSceneRows(session, { messageRef, messageIndex, before: anchorSceneIntOrNull(query.before), limit: anchorSceneIntOrNull(query.limit) }, withToolCallOutcomes(withTurnIds(transcript), session.tool_calls, session.active_stream_id));
         if (!result)
             throw new HttpFailure(404, 'Anchor activity scene not found');
         // Paged rows come from the raw transcript, so they take the same credential redaction as the detail's preview.
         const enabled = this.deps.redactEnabled();
         const redacted = redactValue(result, enabled);
-        return { ...redacted, rows: withSceneToolDisplay(result.rows, redacted.rows, enabled) };
+        const rows = withSceneToolDisplay(result.rows, redacted.rows, enabled);
+        // `/api/media` serves stored sessions only, so a state.db-only session's rows stay as written, as its detail does.
+        return { ...redacted, rows: stored ? withSceneRowMedia(rows, this.mediaProjector(session)) : rows };
+    }
+    /** TAL-331: one tool call's whole result, which a limited response clipped (`result_truncated`), redacted like the detail. */
+    readToolResult(query) {
+        const sid = query.session_id.trim();
+        const id = query.tool_call_id.trim();
+        if (!sid || !id)
+            throw new HttpFailure(400, 'session_id and tool_call_id are required');
+        const full = fullToolResult(this.fullTranscript(sid).transcript, id);
+        if (full === null)
+            throw new HttpFailure(404, 'Tool result not found');
+        return { tool_call_id: id, ...redactValue(full, this.deps.redactEnabled()) };
     }
     // ── shares ───────────────────────────────────────────────────────────────
     createShare(sid) {
@@ -1557,17 +1701,142 @@ function stampIntentionalShrink(session, oldCount, newCount) {
     session.intentional_shrink_generation = randomUUID().replace(/-/g, '');
     return true;
 }
-/** Align model context with the display prefix (Python `truncate_context_for_display_keep`, simplified to the row-count contract). */
+/** Python truthiness for the JSON values a transcript row carries. */
+function pyTruthy(v) {
+    if (Array.isArray(v))
+        return v.length > 0;
+    if (isDict(v))
+        return Object.keys(v).length > 0;
+    return Boolean(v);
+}
+/** JSON with sorted object keys (Python `json.dumps(..., sort_keys=True)`). */
+function sortedJson(v) {
+    return JSON.stringify(v, (_key, value) => (isDict(value) ? Object.fromEntries(Object.keys(value).sort().map((k) => [k, value[k]])) : value)) ?? '';
+}
+/** Equality key for a row `id`/`timestamp`; `null` when the value is absent. Numbers compare by value (`2 == 2.0`). */
+function identityKey(v) {
+    if (v === null || v === undefined)
+        return null;
+    return typeof v === 'string' ? `s${v}` : typeof v === 'number' ? `n${String(v)}` : `j${sortedJson(v)}`;
+}
+function rowSignature(row) {
+    if (!isDict(row))
+        return null;
+    const field = (v) => (!pyTruthy(v) ? '' : typeof v === 'string' ? v : sortedJson(v));
+    return JSON.stringify([field(row.role), field(row.content), field(row.tool_call_id), field(row.tool_use_id), field(row.tool_name || row.name), field(row.tool_calls)]);
+}
+/** First index in sorted `positions` whose value is `>= start`. */
+function lowerBound(positions, start) {
+    let lo = 0;
+    let hi = positions.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (positions[mid] < start)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/**
+ * Map each display row to the context row it represents, scanning forward. An `id` match wins; otherwise the role+content
+ * signature must match, and a shared `timestamp` makes it exact. A signature match where an identity is missing is weak:
+ * one weak candidate counts as a match, a second one before any exact match leaves the row ambiguous.
+ */
+function alignDisplayToContext(ctx, full) {
+    const index = () => new Map();
+    const push = (map, key, idx) => {
+        const list = map.get(key);
+        if (list)
+            list.push(idx);
+        else
+            map.set(key, [idx]);
+    };
+    const first = (list, start) => list?.[lowerBound(list, start)];
+    const byId = index(), bySigTs = index(), bySigTsNoId = index();
+    const weakAny = index(), weakNoId = index(), weakNoTs = index(), weakNoIdNoTs = index();
+    ctx.forEach((row, idx) => {
+        const sig = rowSignature(row);
+        if (sig === null)
+            return;
+        const id = identityKey(row.id);
+        const ts = identityKey(row.timestamp);
+        push(weakAny, sig, idx);
+        if (id === null)
+            push(weakNoId, sig, idx);
+        if (ts === null)
+            push(weakNoTs, sig, idx);
+        if (id === null && ts === null)
+            push(weakNoIdNoTs, sig, idx);
+        if (id !== null)
+            push(byId, id, idx);
+        if (ts !== null) {
+            push(bySigTs, `${sig}\0${ts}`, idx);
+            if (id === null)
+                push(bySigTsNoId, `${sig}\0${ts}`, idx);
+        }
+    });
+    const matches = [];
+    const ambiguous = [];
+    let next = 0;
+    for (const message of full) {
+        let match = null;
+        let ambiguousAt = null;
+        const sig = rowSignature(message);
+        if (sig !== null) {
+            const id = identityKey(message.id);
+            const ts = identityKey(message.timestamp);
+            const exact = [id !== null ? first(byId.get(id), next) : undefined, ts !== null ? first((id !== null ? bySigTsNoId : bySigTs).get(`${sig}\0${ts}`), next) : undefined]
+                .filter((idx) => idx !== undefined);
+            const exactIdx = exact.length ? Math.min(...exact) : null;
+            const weakList = (id !== null ? (ts !== null ? weakNoIdNoTs : weakNoId) : ts !== null ? weakNoTs : weakAny).get(sig) ?? [];
+            const w = lowerBound(weakList, next);
+            const [firstWeak, secondWeak] = [weakList[w], weakList[w + 1]];
+            if (secondWeak !== undefined && (exactIdx === null || secondWeak < exactIdx))
+                ambiguousAt = firstWeak;
+            else
+                match = exactIdx ?? firstWeak ?? null;
+        }
+        matches.push(match);
+        ambiguous.push(ambiguousAt);
+        if (match !== null)
+            next = match + 1;
+    }
+    return { matches, ambiguous };
+}
+/** Align model context with the display prefix `full[:keep]` (Python `truncate_context_for_display_keep`, #5096/#5563). */
 export function truncateContextForDisplayKeep(context, full, keep) {
     if (keep <= 0)
         return [];
-    const rows = context ?? [];
-    if (!rows.length)
+    const ctx = context ?? [];
+    if (!ctx.length || !full.length)
         return [];
-    if (keep >= full.length)
-        return [...rows];
-    // ponytail: context rows map 1:1 onto display rows for WebUI-authored transcripts; fuzzy alignment stays in Python until compression lands.
-    return rows.slice(0, Math.min(rows.length, keep));
+    if (keep < full.length) {
+        const { matches, ambiguous } = alignDisplayToContext(ctx, full);
+        const lastKept = matches[keep - 1];
+        const firstUnkept = matches[keep];
+        const boundary = full[keep - 1];
+        const keptUser = isDict(boundary) && boundary.role === 'user';
+        // Cut at the first unkept display row; a kept user turn ends at its own row so unkept tool rows after it drop.
+        if (firstUnkept !== null)
+            return lastKept !== null && keptUser ? ctx.slice(0, lastKept + 1) : ctx.slice(0, firstUnkept);
+        if (lastKept !== null) {
+            const ambiguousUnkept = ambiguous[keep];
+            return ambiguousUnkept !== null && isDict(boundary) && !keptUser ? ctx.slice(0, ambiguousUnkept) : ctx.slice(0, lastKept + 1);
+        }
+        // Both boundary rows unresolved in a shorter (compressed) context: cut past the last kept display row that resolved,
+        // accepting a weak match. Under-keeping beats slicing at the raw display index.
+        if (ctx.length < full.length) {
+            for (let i = keep - 1; i >= 0; i -= 1) {
+                const resolved = matches[i] ?? ambiguous[i];
+                if (resolved !== null && resolved !== undefined)
+                    return ctx.slice(0, resolved + 1);
+            }
+        }
+    }
+    // Unalignable (or nothing cut): keep the compaction prefix a longer context carries, then `keep` rows (#5096).
+    const prefixLen = Math.max(0, ctx.length - full.length);
+    return ctx.slice(0, prefixLen + keep);
 }
 export function truncateSessionAtKeep(session, keep) {
     const full = [...session.messages];
@@ -1578,6 +1847,7 @@ export function truncateSessionAtKeep(session, keep) {
     session.context_messages = truncateContextForDisplayKeep(session.context_messages, full, keep);
     session.truncation_watermark = truncationWatermarkFor(session.messages);
     session.truncation_boundary = session.truncation_watermark;
+    session.truncation_watermark_compressed = false;
     return [oldMsgCount, oldCtxCount];
 }
 function shrinkTo(session, lastUserIdx) {
@@ -1586,6 +1856,7 @@ function shrinkTo(session, lastUserIdx) {
     stampIntentionalShrink(session, history.length, session.messages.length);
     session.truncation_watermark = truncationWatermarkFor(session.messages);
     session.truncation_boundary = session.truncation_watermark;
+    session.truncation_watermark_compressed = false;
     if (session.context_messages.length) {
         const ctxLast = findLastUserIndex(session.context_messages);
         if (ctxLast !== null)