@maudecode/talaria-web 1.13.0 → 1.15.0

package/dist/sessions/service.js

@@ -3,13 +3,17 @@ 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 { 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 { SessionBusy, SessionNotFound, statSignature } from './store.js';
 import { attachTodoState } from './todo.js';
 import { stateDbSessionMessages, stateDbSessionRow, stateDbSessionSources } from './state-db.js';
-import { mergeSessionMessagesAppendOnly, pendingUserRow, 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, withAttachmentObjects, withBodyExcerpts, 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 { buildShareSnapshot } from './shares.js';
@@ -25,11 +29,32 @@ 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; }
     publish(reason, profile, sessionId) {
@@ -135,16 +160,24 @@ 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 });
     }
+    /**
+     * 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));
+    }
     /** 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 +247,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 +270,25 @@ 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(withTurnIds(s.messages), s), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id }));
         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 }), read_only: this.isReadOnly(s), assistant_name: this.assistantName(s) }, this.deps.runtime.activeStreamIds);
+    }
+    /** 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 +328,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(transcript), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: msgLimit !== null }) : [];
+        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) : [];
         let truncated = [];
         let offset = 0;
         let summaryCount = null;
@@ -317,12 +362,12 @@ 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 }),
             messages: truncated,
             message_count: mergedCount,
             tool_calls: toolCalls,
             pending_user_message: s.pending_user_message,
-            pending_attachments: loadMessages ? s.pending_attachments : [],
+            pending_attachments: loadMessages ? attachmentObjects(s.pending_attachments) : [],
             pending_started_at: s.pending_started_at,
             pending_user_source: s.pending_user_source,
             context_length: Number(s.context_length ?? 0) || this.deps.contextLengthFor(s.model, s.model_provider) || 0,
@@ -344,7 +389,9 @@ 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);
         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());
     }
     /**
@@ -398,6 +445,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),
         };
         attachTodoState(sess, msgs);
         const merged = withSessionWireFlags(meta ? mergeCliSidebarMetadata(sess, meta) : sess, this.deps.runtime.activeStreamIds);
@@ -413,7 +461,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 +481,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,9 +514,11 @@ 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 });
+        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());
     }
     search(q, opts) {
@@ -535,10 +585,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,
         };
     }
@@ -774,6 +824,175 @@ 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.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');
@@ -930,11 +1149,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 {
@@ -993,6 +1214,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) {
@@ -1316,6 +1540,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;