@maudecode/talaria-web 1.14.0 → 1.16.1

package/dist/sessions/service.js

@@ -3,16 +3,23 @@ import { randomUUID } from 'node:crypto';
 import { rmSync } from 'node:fs';
 import { buildActiveTurnToken, copyJson, redactSessionData, redactValue, stripPublicInternalFields, withSceneToolDisplay } from '../redact.js';
 import { DraftVersionConflict, normalizeDraftVersion } from './drafts.js';
-import { allSessions, buildSessionListPayload, 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 { allSessions, buildSessionListPayload, CLI_IDENTITY_FIELDS, isClaimableCliSource, isMessagingSessionRecord, withOwnerLocks, withSessionWireFlags, lineageRootId, mergeCliSidebarMetadata, sessionListResponse, sessionSearchMessageText, sessionSearchPreview } from './list.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 { attachmentObjects, mergeSessionMessagesAppendOnly, pendingUserRow, withAttachmentObjects, withPendingUserTurn, withToolCallOutcomes, withoutRunningTurnOutput } from './merge.js';
+import { anchorMessageKey, anchorSummary, CompressionJobs, visibleMessagesForAnchor } from './compress.js';
+import { SidecarError } from '../sidecar/client.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 {
@@ -25,13 +32,65 @@ export class HttpFailure extends Error {
         this.name = 'HttpFailure';
     }
 }
+/**
+ * Python `_agent_runtime_barrier_response`: a stale local Agent checkout is refused with a typed 409 before the caller
+ * mutates anything. Any other failure of the check is not a verdict and lets the caller proceed.
+ */
+export async function ensureAgentRuntimeCurrent(sidecar) {
+    if (!sidecar)
+        return;
+    try {
+        await sidecar.call('runtime.ensure_current', {});
+    }
+    catch (error) {
+        if (error instanceof SidecarError && error.condition === 'agent_runtime_stale')
+            throw staleRuntimeFailure(error);
+    }
+}
+function staleRuntimeFailure(error) {
+    return new HttpFailure(409, error.message, { type: 'agent_runtime_stale', retryable: true, restart_scheduled: false, ...(error.data.agent_update_state !== undefined ? { agent_update_state: error.data.agent_update_state } : {}) });
+}
 const isDict = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
 export class SessionService {
     deps;
+    /** TAL-255: one manual compression worker per session, shared by every compress route. */
+    compressionJobs;
     constructor(deps) {
         this.deps = deps;
+        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 });
     }
@@ -135,16 +194,33 @@ export class SessionService {
      * rows (a WebUI conversation continued from the CLI shows the CLI turns). This is the coordinate space `GET
      * /api/session` exposes, so branching and the next model history slice/extend the same list.
      */
-    mergedTranscript(s, local = s.messages) {
-        const stateRows = this.stateDbRows(s);
+    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
+     * extended append-only with the Agent's state.db rows (a CLI continuation of this session reaches the model), except
+     * for a compressed context whose anchor cannot be verified — that stays context-only.
+     */
+    modelContext(s, stateRows) {
+        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 {
-            return this.deps.cliSessions(this.deps.activeProfile(), { sourceFilter: null }).find((r) => str(r.session_id) === sid) ?? null;
+            return this.deps.cliSessions(this.deps.activeProfile(), { sourceFilter: null }).rows.find((r) => str(r.session_id) === sid) ?? null;
         }
         catch {
             return null;
@@ -214,6 +290,10 @@ export class SessionService {
             messages: msgs, created_at: Number(meta.created_at) || 0, updated_at: Number(meta.updated_at) || 0, profile: str(meta.profile) || null,
             is_cli_session: claimable ? true : !subagentChild, source_tag: str(meta.source_tag) || null, raw_source: str(meta.raw_source) || null,
             session_source: str(meta.session_source) || null, source_label: str(meta.source_label) || null, read_only: !claimable,
+            // Python `import_cli_session`: the claimed sidecar keeps the row's lineage, background project and channel identity
+            // (identity persists through `Session.extra`).
+            parent_session_id: str(meta.parent_session_id) || null, project_id: str(meta.project_id) || null,
+            ...Object.fromEntries(CLI_IDENTITY_FIELDS.filter((k) => meta[k] != null && meta[k] !== '').map((k) => [k, meta[k]])),
         }, defaults);
         return { session, reason: claimable ? 'materialized' : 'not_claimable' };
     }
@@ -233,17 +313,46 @@ export class SessionService {
         if (this.isSubagentViewOnly(sid))
             throw new HttpFailure(400, `Subagent sessions are view-only and cannot be ${verb} from WebUI`);
     }
+    /** TAL-372: each delegation row of a turn's scene carries the status of the work it started. */
+    backgroundLinked(s, messages) {
+        return withBackgroundLinks(messages, this.deps.backgroundReceipts?.(s.session_id) ?? []);
+    }
     /** `compact()` plus messages, redacted for the wire (Python `_public_session_projection`). */
     publicSession(s, withMessages = true) {
         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 = hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(s.messages), 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(), read_only: this.isReadOnly(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) {
+        return this.deps.assistantName(s.profile);
     }
     /** Python `public_session_projection(s.__dict__)`: every persisted field, redacted (session export). */
     publicSessionDocument(s) {
@@ -283,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 ? hydrateAnchorActivityScenes(withToolCallOutcomes(withTurnIds(withAttachmentObjects(transcript)), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: msgLimit !== null }) : [];
+        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;
@@ -299,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);
         }
@@ -317,7 +428,7 @@ export class SessionService {
         }
         const activeStreamIds = this.deps.runtime.activeStreamIds;
         const raw = {
-            ...s.compact({ includeRuntime: true, activeStreamIds }),
+            ...s.compact({ includeRuntime: true, activeStreamIds, contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }),
             messages: truncated,
             message_count: mergedCount,
             tool_calls: toolCalls,
@@ -344,7 +455,10 @@ export class SessionService {
         const revisionAfter = this.loadRevision(s);
         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());
     }
     /**
@@ -390,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,
@@ -398,6 +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), workspace_name: this.workspaceNames()(synth),
         };
         attachTodoState(sess, msgs);
         const merged = withSessionWireFlags(meta ? mergeCliSidebarMetadata(sess, meta) : sess, this.deps.runtime.activeStreamIds);
@@ -413,7 +528,7 @@ export class SessionService {
         if (this.deps.runtime.activeRunStream(session.session_id))
             return false;
         const pendingAge = session.pending_started_at ? this.deps.now() - session.pending_started_at : null;
-        if (session.pending_user_message && pendingAge !== null && pendingAge < 30)
+        if (session.hasPendingPrompt && pendingAge !== null && pendingAge < 30)
             return false;
         let target = session;
         if (session.loadedMetadataOnly) {
@@ -433,7 +548,7 @@ export class SessionService {
         // Python `_materialize_pending_user_turn_before_error` (#1361): the prompt that was in flight becomes a durable user
         // turn and an interruption marker follows it, so a dead stream never silently drops what the user sent.
         const pendingText = str(target.pending_user_message);
-        if (pendingText) {
+        if (target.hasPendingPrompt) {
             const turnId = str(target.active_stream_id);
             const startedAt = typeof target.pending_started_at === 'number' && target.pending_started_at > 0 ? target.pending_started_at : this.deps.now();
             const attachments = [...target.pending_attachments];
@@ -466,10 +581,12 @@ export class SessionService {
         const activeProfile = this.deps.activeProfile();
         const wantState = params.showCliSessions || params.showCronSessions || params.showWebhookSessions || params.showKanbanSessions;
         // Python reads every profile's state.db under all_profiles; this port projects the active profile only.
-        const cliRows = wantState ? this.deps.cliSessions(activeProfile, { sourceFilter: params.sourceFilter ?? null }) : undefined;
+        const cliRead = wantState ? this.deps.cliSessions(activeProfile, { sourceFilter: params.sourceFilter ?? null }) : undefined;
+        const cliRows = cliRead?.rows;
         const gatewayIdentity = loadGatewaySessionIdentityMap(join(this.deps.profileHome(activeProfile), 'sessions', 'sessions.json'));
-        const payload = buildSessionListPayload(this.store, { ...params, ...(cliRows ? { cliRows } : {}), 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());
+        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(), this.workspaceNames());
     }
     search(q, opts) {
         const activeProfile = this.deps.activeProfile();
@@ -478,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'])
@@ -498,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) {
@@ -535,10 +688,10 @@ export class SessionService {
         catch {
             hermesHome = '';
         }
-        const { is_streaming: streaming, active_stream_id: live, read_only: readOnly } = this.wireRow(full);
+        const { is_streaming: streaming, active_stream_id: live, read_only: readOnly, active_turn_origin: origin } = this.wireRow(full);
         return {
             session_id: full.session_id, title: full.title, model: full.model, profile, hermes_home: hermesHome, workspace: full.workspace, personality: full.personality,
-            message_count: full.messages.length, created_at: full.created_at, updated_at: full.updated_at, agent_running: streaming, is_streaming: streaming, active_stream_id: live, read_only: readOnly,
+            message_count: full.messages.length, created_at: full.created_at, updated_at: full.updated_at, agent_running: streaming, is_streaming: streaming, active_stream_id: live, active_turn_origin: origin, read_only: readOnly,
             input_tokens: inp, output_tokens: out, total_tokens: inp + out, estimated_cost: full.estimated_cost,
         };
     }
@@ -578,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;
@@ -774,6 +928,176 @@ export class SessionService {
         this.deps.runtime.evictAgent(sid);
         return { ok: true, session: this.publicSession(s) };
     }
+    // ── manual compression (TAL-255) ────────────────────────────────────────
+    /**
+     * Python `_handle_session_compress_start`: validate, then join the session's running job or start a fresh one (a
+     * finished job is replaced). The stale-runtime refusal comes before a job exists; a running job is joined without it.
+     */
+    async startCompression(sid, focusRaw) {
+        const running = () => { const job = this.compressionJobs.get(sid); return job?.status === 'running' ? job : undefined; };
+        // A running job is joined first: once it has installed its short context, the guards below would refuse a new one.
+        const existing = running();
+        if (existing)
+            return existing;
+        const { s } = this.compressionTarget(sid);
+        const focusTopic = str(focusRaw).trim().slice(0, 500) || null;
+        await ensureAgentRuntimeCurrent(this.deps.sidecar?.() ?? null);
+        // Another start may have admitted a job while the runtime check awaited.
+        const admitted = running();
+        if (admitted)
+            return admitted;
+        // The detached job (and its finalize) is the profile's activity until it settles; checked and taken in one step.
+        const profile = s.profile ?? null;
+        if (this.deps.profileDeleting?.(profile))
+            throw new HttpFailure(409, `Profile '${str(profile)}' is being deleted.`);
+        const release = this.deps.profileActivity?.(profile);
+        const now = this.deps.now();
+        const job = { session_id: sid, focus_topic: focusTopic, status: 'running', started_at: now, updated_at: now, done: Promise.resolve() };
+        job.done = this.compressSession(sid, focusTopic).finally(() => { release?.(); this.compressionJobs.expireLater(job); }).then((result) => { Object.assign(job, { status: 'done', result, updated_at: this.deps.now() }); }, (error) => {
+            const known = error instanceof HttpFailure;
+            if (!known)
+                this.deps.log(`[webui] Manual compression worker failed for session ${sid}: ${error.message}`);
+            Object.assign(job, { status: 'error', error: known ? error.message : `Compression failed: ${sanitizePaths(error)}`, error_status: known ? error.status : 500, error_extra: known ? error.extra : {}, updated_at: this.deps.now() });
+        });
+        this.compressionJobs.set(job);
+        return job;
+    }
+    /** The session a compression may run on now, and the model history it compresses: the context a turn would send, so a
+     * repeat compression builds on the previous summary instead of re-reading the whole display transcript. */
+    compressionTarget(sid) {
+        this.rejectSubagent(sid, 'compressed');
+        const s = this.mutationTarget(sid, 'compressed');
+        if (s.active_stream_id)
+            throw new HttpFailure(409, 'Session is still streaming; wait for the current turn to finish.');
+        const history = sanitizeMessagesForApi(this.modelContext(s));
+        if (history.length < 4)
+            throw new HttpFailure(400, 'Not enough conversation to compress (need at least 4 messages).');
+        return { s, history };
+    }
+    /** The session's compression job; a deleted session's finished result is dropped rather than served. */
+    compressionJob(sid) {
+        try {
+            this.store.get(sid, { metadataOnly: true });
+        }
+        catch {
+            this.compressionJobs.delete(sid);
+            throw new HttpFailure(404, 'Session not found');
+        }
+        return this.compressionJobs.get(sid);
+    }
+    /**
+     * Python `_handle_session_compress`: compress the sanitized transcript in the sidecar outside the lock, then under the
+     * session lock refuse a result the session moved past (stream state or transcript changed) and install it as the
+     * model context with the manual anchor and the #4836 boundary that keeps state.db from replaying compressed rows.
+     * The guards run again first: a stream may have started while the caller awaited the runtime check.
+     */
+    async compressSession(sid, focusTopic) {
+        const { s, history } = this.compressionTarget(sid);
+        // The display transcript and the model context must both be where the compression found them; the key starts from
+        // the exact history sent, so a state.db row that lands after this read fails the commit instead of being dropped.
+        const transcriptKey = (x, context) => JSON.stringify([sanitizeMessagesForApi(x.messages), context]);
+        const historyKey = transcriptKey(s, history);
+        const streamState = (x) => JSON.stringify([x.active_stream_id ?? null, x.pending_user_message ?? null, x.pending_attachments ?? null, x.pending_started_at ?? null]);
+        const streamBefore = streamState(s);
+        const sidecar = this.deps.sidecar?.();
+        if (!sidecar)
+            throw new HttpFailure(400, 'Compression failed: the Agent sidecar is not running');
+        const [model, provider] = this.deps.modelStateFromRequest(s.model, s.model_provider, s.model_provider);
+        let result;
+        try {
+            result = await sidecar.call('chat.compress', {
+                profile_home: this.deps.profileHome(s.profile ?? this.deps.activeProfile()), session_id: sid, model: model ?? '', model_provider: provider,
+                conversation_history: history, focus_topic: focusTopic, enabled_toolsets: s.enabled_toolsets,
+            }, { timeoutMs: 0 });
+        }
+        catch (error) {
+            if (error instanceof SidecarError && error.condition === 'agent_runtime_stale')
+                throw staleRuntimeFailure(error);
+            if (error instanceof SidecarError && error.condition === 'credential_missing')
+                throw new HttpFailure(400, 'No provider configured -- cannot compress.');
+            throw new HttpFailure(400, `Compression failed: ${sanitizePaths(error)}`);
+        }
+        // A held compression lock is a conflict to retry; `nothing_to_do` is the Agent's verdict on this transcript.
+        if (result.status !== 'compressed')
+            throw new HttpFailure(result.status === 'lock_skipped' ? 409 : 400, result.message ?? 'Nothing to compress yet.');
+        const summary = result.summary ?? {};
+        let committed = false;
+        try {
+            const current = await this.store.withLock(sid, () => {
+                let live;
+                try {
+                    live = this.store.get(sid);
+                }
+                catch {
+                    throw new HttpFailure(404, 'Session not found');
+                }
+                if (streamState(live) !== streamBefore)
+                    throw new HttpFailure(409, 'Session stream state changed during compression; please retry.');
+                // One state.db read serves the check, the kept display rows, and the boundary.
+                const stateRows = this.stateDbRows(live);
+                if (transcriptKey(live, sanitizeMessagesForApi(this.modelContext(live, stateRows))) !== historyKey)
+                    throw new HttpFailure(409, 'Session was modified during compression; please retry.');
+                // Rows the sidecar returns without a timestamp take the newest one this compression saw, never the clock: the
+                // boundary then hides no state.db row the append-only merge would still show (it already drops rows at or
+                // before the newest local row), so a CLI row committed after the read follows the compressed context.
+                const seen = [...live.messages, ...live.context_messages, ...stateRows].map((m) => Number(m.timestamp)).filter(Number.isFinite);
+                const stamp = seen.length ? Math.max(...seen) : this.deps.now();
+                const compressed = copyJson(result.messages);
+                for (const m of compressed)
+                    m.timestamp ??= stamp;
+                live.context_messages = compressed;
+                live.active_stream_id = null;
+                live.pending_user_message = null;
+                live.pending_attachments = [];
+                live.pending_started_at = null;
+                live.pending_user_source = null;
+                // The compressed history included any state.db-only continuation; the new boundary would hide those rows from
+                // the display, so the transcript keeps them before it is applied (and the anchor counts them).
+                const display = this.mergedTranscript(live, live.messages, stateRows);
+                if (display.length > live.messages.length)
+                    live.messages = copyJson(display);
+                const visible = visibleMessagesForAnchor(live.messages);
+                live.compression_anchor_visible_idx = visible.length ? visible.length - 1 : null;
+                live.compression_anchor_message_key = anchorMessageKey(visible.at(-1));
+                live.compression_anchor_summary = anchorSummary(summary, compressed);
+                live.compression_anchor_mode = 'manual';
+                // #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);
+                // A backup from before the compression would restore the uncompressed context.
+                try {
+                    rmSync(`${this.store.pathFor(sid)}.bak`, { force: true });
+                }
+                catch { /* ignore */ }
+                return live;
+            });
+            committed = true;
+            // The cached turn agent still carries the uncompressed state; the next turn builds a fresh one (gateway parity).
+            // Awaited, so a turn sent right after the reply cannot reuse the old agent.
+            try {
+                await sidecar.call('chat.evict_agent', { session_id: sid });
+            }
+            catch (error) {
+                this.deps.log(`[webui] agent eviction after compression of ${sid} failed: ${error.message}`);
+            }
+            return { ok: true, session: this.publicSession(current), summary, focus_topic: focusTopic };
+        }
+        finally {
+            // Second phase: the Agent's context-engine notification fires only for a result the session now holds.
+            if (result.commit_token) {
+                try {
+                    await sidecar.call('chat.compress_finalize', { commit_token: result.commit_token, committed });
+                }
+                catch (error) {
+                    this.deps.log(`[webui] compression finalize for ${sid} failed: ${error.message}`);
+                }
+            }
+        }
+    }
     async clear(sid) {
         this.rejectSubagent(sid, 'modified');
         const s = this.mutationTarget(sid, 'modified');
@@ -810,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) {
@@ -821,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) {
@@ -850,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,
@@ -930,11 +1264,13 @@ export class SessionService {
             return {};
         } })();
         let eventProfile = null;
+        let hadSidecar = true;
         try {
             eventProfile = this.store.get(sid, { metadataOnly: true }).profile;
         }
         catch {
             eventProfile = null;
+            hadSidecar = false;
         }
         // Python `_is_messaging_session_id`: decided before the JSON is gone, from WebUI metadata or the Agent's row.
         const isMessaging = (() => { try {
@@ -961,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 });
@@ -970,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 });
         }
@@ -993,6 +1337,9 @@ export class SessionService {
             }
         }
         this.publish('session_delete', eventProfile);
+        // Only a sidecar session is ever published to the relay.
+        if (hadSidecar)
+            this.deps.clearRelayCompletions?.(sid, eventProfile);
         return { ok: true, state_db_cleanup_failed: stateDbCleanupFailed, ...retained };
     }
     cleanup(zeroOnly) {
@@ -1002,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;
@@ -1202,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) {
@@ -1316,6 +1684,10 @@ function findLastUserIndex(history) {
             return i;
     return null;
 }
+/** Python `_sanitize_error`: absolute paths in an error message never reach the client. */
+export function sanitizePaths(error) {
+    return str(error?.message ?? error).replace(/(?:(?:\/[a-zA-Z0-9_.-]+)+|(?:[A-Z]:\\[^\s]+))/g, '<path>');
+}
 function truncationWatermarkFor(messages) {
     if (!messages.length)
         return 0.0;
@@ -1329,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];
@@ -1350,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) {
@@ -1358,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)