@maudecode/talaria-web 1.16.1 → 1.17.2

package/dist/sessions/service.js

@@ -3,15 +3,16 @@ 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, CLI_IDENTITY_FIELDS, 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, sessionSearchMatches, sessionSearchMessageText, sessionSearchPreview, sessionSearchTerms } from './list.js';
 import { anchorSceneIntOrNull, fullToolResult, hydrateAnchorActivityScenes, normalizeAnchorSceneMessageRef, readAnchorSceneRows, storeAnchorScene, withTurnIds } from './anchor.js';
-import { isSafeSessionId, lastMessageTimestamp, Session, stripAttachedFilesMarker, titleFrom } from './session.js';
+import { isSafeSessionId, lastMessageTimestamp, Session, sharePath, 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 { UNSETTLED_TODO_KEY, attachTodoState } from './todo.js';
+import { isClaudeCodeSessionId } from './claude-code.js';
+import { stateDbCompressionLineage, stateDbSessionMessages, stateDbSessionRead, stateDbSessionRow, stateDbSessionSources } from './state-db.js';
+import { anchorMessageKey, anchorSummary, CompressionJobs, compressionReference, 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 { agentSteerText, attachedFilesPrompt, attachmentObjects, dedupeContext, isContextCompressionMarker, journalOutputRows, looksLikeCurrentUserTurn, stoppedTurnContext, workspaceContextPrefix, mergeSessionMessagesAppendOnly, messageIdentity, pendingUserRow, reasoningFieldsText, sanitizeMessagesForApi, stateDbSeenId, 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';
@@ -50,6 +51,9 @@ export async function ensureAgentRuntimeCurrent(sidecar) {
 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 } : {}) });
 }
+/** TAL-536: the most of a dead run's journal stale-stream cleanup reads (Python's recovery window). */
+const RECOVERY_JOURNAL_MAX_BYTES = 8 * 1024 * 1024;
+const RECOVERY_JOURNAL_MAX_ROWS = 65536;
 const isDict = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
 export class SessionService {
     deps;
@@ -185,9 +189,18 @@ export class SessionService {
     }
     /** The Agent's state.db rows for this session (empty for subagent views, which never merge). */
     stateDbRows(s) {
+        return this.stateDbRead(s).rows;
+    }
+    /** `stateDbRows` and whether the read succeeded on a state.db whose messages carry ids (TAL-493). */
+    stateDbRead(s) {
         if (str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() === 'subagent')
-            return [];
-        return stateDbSessionMessages(join(this.deps.profileHome(s.profile ?? this.deps.activeProfile()), 'state.db'), s.session_id, { stitch: false });
+            return { rows: [], idCapable: false, ok: false };
+        // TAL-529: after a compression rotation the Agent writes to the continuation, so the read follows the recorded lineage.
+        const lineage = s.state_db_lineage?.[0] === s.session_id ? s.state_db_lineage : null;
+        return stateDbSessionRead(this.stateDbPath(s.profile), s.session_id, { stitch: false, lineage });
+    }
+    stateDbPath(profile) {
+        return join(this.deps.profileHome(profile ?? this.deps.activeProfile()), 'state.db');
     }
     /**
      * Python `_merged_session_messages_for_display`: the sidecar transcript merged append-only with the Agent's state.db
@@ -197,7 +210,91 @@ 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, compressedWatermark: s.truncation_watermark_compressed });
+        return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: currentStateDbSeenId(s, stateRows) });
+    }
+    /**
+     * TAL-493: record the highest state.db id this boundary or settled turn read, under the session lock in the same save,
+     * so the merge never replays a covered row and appends every row committed after the read. Call it after the boundary
+     * fields are set: the marker holds only while they and the row it names stay as recorded.
+     */
+    markStateDbSeen(s, read = this.stateDbRead(s), opts = {}) {
+        // A failed read says nothing. A settlement keeps the marker; a boundary drops it (fail closed): it may cut rows the
+        // marker still admits without moving a field, and the timestamp rules honour its watermark.
+        if (!read.ok) {
+            if (opts.boundary) {
+                s.state_db_seen_id = null;
+                s.state_db_seen_boundary = null;
+                s.state_db_seen_stamp = null;
+            }
+            return;
+        }
+        // A successful read with no rows yet is a baseline: every row the session gets later is new.
+        s.state_db_seen_id = stateDbSeenId(read.rows) ?? (read.idCapable ? 0 : null);
+        s.state_db_seen_boundary = stateDbMarkKey(s, read.rows, s.state_db_seen_id);
+        s.state_db_seen_stamp = s.updated_at;
+    }
+    /**
+     * TAL-493: a turn's settlement. Each state.db row the merge shows now is matched to what the turn holds: a row already
+     * in the context it started from (by id), or one row the Agent added this turn (`agentRows` past that context, matched
+     * one to one by full text). An unmatched row is a CLI or gateway row committed while the turn ran: it joins the
+     * transcript and the model context before the marker passes it. Without the Agent's rows (`agentRows` empty), rows past
+     * `startId` (the highest id the turn read when it started) are its own unreported work: covered, never shown. Rows the
+     * turn started from but the transcript lacks (a CLI continuation read into its context) are kept before the turn.
+     */
+    settleStateDb(s, turn) {
+        const read = this.stateDbRead(s);
+        const startedWith = new Set(turn.previousContext.flatMap((m) => (typeof m._state_db_row_id === 'number' ? [m._state_db_row_id] : [])));
+        const earlier = mergeSessionMessagesAppendOnly(s.messages, read.rows.filter((m) => typeof m._state_db_row_id === 'number' && startedWith.has(m._state_db_row_id)), { stateDbSeenId: -1 }).slice(s.messages.length);
+        const added = new Map();
+        for (const m of withoutRows(turn.agentRows ?? [], turn.previousContext))
+            added.set(settledIdentity(m), (added.get(settledIdentity(m)) ?? 0) + 1);
+        const ownWorkAfter = turn.agentRows?.length ? null : turn.startId ?? null;
+        // Without a current marker, the turn's own starting read is the baseline: rows committed after it are judged here.
+        const seenId = currentStateDbSeenId(s, read.rows) ?? turn.startId ?? null;
+        const shown = read.rows.length ? mergeSessionMessagesAppendOnly(s.messages, read.rows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: seenId }) : s.messages;
+        const fresh = new Set(shown.slice(s.messages.length));
+        // The turn's own rows the merge already matched to their local copies use up their share before any shown row can.
+        if (seenId !== null) {
+            for (const m of read.rows) {
+                const id = m._state_db_row_id;
+                if (typeof id !== 'number' || id <= seenId || startedWith.has(id) || fresh.has(m))
+                    continue;
+                const left = added.get(settledIdentity(m)) ?? 0;
+                if (left > 0)
+                    added.set(settledIdentity(m), left - 1);
+            }
+        }
+        const missed = [...fresh].filter((m) => {
+            const id = m._state_db_row_id;
+            if (typeof id === 'number' && startedWith.has(id))
+                return false;
+            const key = settledIdentity(m);
+            const left = added.get(key) ?? 0;
+            if (left > 0) {
+                added.set(key, left - 1);
+                return false;
+            }
+            return !(ownWorkAfter !== null && typeof id === 'number' && id > ownWorkAfter);
+        });
+        if (earlier.length) {
+            const at = s.messages.findIndex((m) => m._turn_id === turn.turnId);
+            s.messages.splice(at < 0 ? s.messages.length : at, 0, ...copyJson(earlier));
+        }
+        if (missed.length) {
+            s.messages.push(...copyJson(missed));
+            if (s.context_messages.length)
+                s.context_messages.push(...copyJson(missed));
+        }
+        this.markStateDbSeen(s, read);
+        // TAL-529: a compression rotation moved the Agent to a continuation, whose first rows restate the compressed context.
+        // The read follows the new lineage from here, and everything it holds now is covered.
+        // ponytail: a CLI row committed to the continuation before this settlement is covered with them; telling them apart
+        // needs the Agent to mark the rows it writes at rotation.
+        const lineage = stateDbCompressionLineage(this.stateDbPath(s.profile), s.session_id);
+        if (JSON.stringify(lineage) !== JSON.stringify(s.state_db_lineage ?? [s.session_id])) {
+            s.state_db_lineage = lineage.length > 1 ? lineage : null;
+            this.markStateDbSeen(s);
+        }
     }
     /**
      * Python `reconciled_state_db_messages_for_session(prefer_context=True)`: the model history is the owner context
@@ -220,12 +317,17 @@ export class SessionService {
     /** Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile. */
     lookupCliMeta(sid) {
         try {
+            if (isClaudeCodeSessionId(sid))
+                return this.claudeCodeRows().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;
         }
     }
+    claudeCodeRows() {
+        return this.deps.claudeCode?.rows(this.deps.workspaces.lastWorkspace(this.deps.activeProfile())) ?? [];
+    }
     /** Python `_session_index_marks_was_webui`: an index row that once owned a WebUI sidecar (self-heal 404). */
     indexMarksWasWebui(sid) {
         let entries;
@@ -262,7 +364,7 @@ export class SessionService {
         const subagentChild = stateDbSource === 'subagent';
         if ((this.indexMarksWasWebui(sid) || (this.store.wasDeleted(sid) && ['', 'webui', 'fork'].includes(stateDbSource))) && !subagentChild)
             return { session: null, reason: 'was_webui' };
-        const msgs = stateDbSessionMessages(dbPath, sid, { stitch: true });
+        const msgs = isClaudeCodeSessionId(sid) ? this.deps.claudeCode?.messages(sid) ?? [] : stateDbSessionMessages(dbPath, sid, { stitch: true });
         if (!msgs.length)
             return { session: null, reason: 'no_foreign_state' };
         const meta = { ...(metaIn ?? this.lookupCliMeta(sid) ?? {}) };
@@ -309,7 +411,16 @@ export class SessionService {
             throw error;
         }
     }
+    /**
+     * TAL-551: a Claude Code import is a live view of a transcript Claude Code keeps writing. Web never stores a copy,
+     * which would freeze its messages and pin it to one profile.
+     */
+    rejectClaudeCode(sid, verb) {
+        if (isClaudeCodeSessionId(sid))
+            throw new HttpFailure(400, `Claude Code sessions are view-only and cannot be ${verb} from WebUI`);
+    }
     rejectSubagent(sid, verb) {
+        this.rejectClaudeCode(sid, verb);
         if (this.isSubagentViewOnly(sid))
             throw new HttpFailure(400, `Subagent sessions are view-only and cannot be ${verb} from WebUI`);
     }
@@ -321,8 +432,10 @@ export class SessionService {
     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)
+        if (withMessages) {
             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) }));
+            payload.compression_reference = compressionReference(s, payload.messages);
+        }
         return redactSessionData(payload, this.deps.redactEnabled());
     }
     /** `compact()` with the wire streaming/read-only flags (TAL-312), for replies that return the session row. */
@@ -442,8 +555,10 @@ export class SessionService {
         };
         if (loadMessages)
             raw.transcript_seq = journaled ? { stream_id: journaled.turnId, seq: 0 } : null;
-        if (loadMessages && all.length)
-            attachTodoState(raw, all);
+        if (loadMessages)
+            attachTodoState(raw, all, s.extra[UNSETTLED_TODO_KEY]);
+        if (loadMessages)
+            raw.compression_reference = compressionReference(s, all);
         if (mergedLast) {
             raw.last_message_at = Math.max(Number(raw.last_message_at ?? 0) || 0, mergedLast);
             raw.updated_at = Math.max(Number(raw.updated_at ?? 0) || 0, mergedLast);
@@ -518,7 +633,7 @@ export class SessionService {
         const merged = withSessionWireFlags(meta ? mergeCliSidebarMetadata(sess, meta) : sess, this.deps.runtime.activeStreamIds);
         return redactSessionData(merged, this.deps.redactEnabled());
     }
-    /** Clear persisted streaming flags when no live stream backs them (Python `_clear_stale_stream_state`, no journal recovery). */
+    /** Clear persisted streaming flags when no live stream backs them (Python `_clear_stale_stream_state`). */
     clearStaleStreamState(session) {
         const streamId = session.active_stream_id;
         if (!streamId)
@@ -545,15 +660,40 @@ export class SessionService {
                 return false;
             }
         }
-        // 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.
+        // Python `_materialize_pending_user_turn_before_error` (#1361) and `_recover_dead_run_journal`: the prompt that was in
+        // flight becomes a durable user turn, the output its journal holds follows it, and an interruption marker closes a
+        // run that never finished with an answer, so a dead stream never silently drops what the user sent or what streamed.
+        const turnId = str(target.active_stream_id);
+        // ponytail: one bounded tail read (Python's recovery window); a journal past it recovers its latest output only.
+        const events = this.deps.journal?.readRunEventTail(target.session_id, turnId, RECOVERY_JOURNAL_MAX_BYTES, RECOVERY_JOURNAL_MAX_ROWS).events ?? [];
+        const { rows: output, answered } = journalOutputRows(events, turnId);
         const pendingText = str(target.pending_user_message);
+        const attachments = [...target.pending_attachments];
+        // The run's starting read died with its worker: the state.db rows from before it started stand in for it. Its own
+        // rows open with its prompt and run to the next prompt; anything else another client wrote meanwhile stays.
+        const read = this.stateDbRead(target);
+        const runStart = target.pending_started_at || events[0]?.created_at || this.deps.now();
+        const before = read.rows.filter((m) => Number(m.timestamp) < runStart);
+        const ownRows = target.hasPendingPrompt ? runStateDbRows(read.rows.filter((m) => Number(m.timestamp) >= runStart), pendingText) : null;
+        // Without this turn's rows: an eager save already put its prompt in the transcript a fresh context falls back to.
+        const previousContext = this.modelContext(target, before).filter((m) => m._turn_id !== turnId);
         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];
-            target.messages.push({ role: 'user', content: pendingText, timestamp: Math.trunc(startedAt), ...(attachments.length ? { attachments } : {}), _recovered: true, _source: target.pending_user_source ?? 'webui', ...(turnId ? { _turn_id: turnId } : {}) });
-            target.messages.push({ role: 'assistant', content: '**Interrupted:** The reply was interrupted before it could be saved.', timestamp: Math.trunc(this.deps.now()), _error: true, ...(turnId ? { _turn_id: turnId } : {}) });
+            // An eager save already checkpointed this prompt as the turn's user row.
+            if (!target.messages.some((m) => m.role === 'user' && !m._steer && m._turn_id === turnId))
+                target.messages.push({ role: 'user', content: pendingText, timestamp: Math.trunc(startedAt), ...(attachments.length ? { attachments } : {}), _recovered: true, _source: target.pending_user_source ?? 'webui', _turn_id: turnId });
+            // The model context settles as a Stop's does: the Agent's own rows when it committed the prompt, else the prompt it
+            // was sent; then the prose that streamed past them.
+            const prompt = attachedFilesPrompt((str(target.workspace) ? workspaceContextPrefix(str(target.workspace)) : '') + pendingText, attachments);
+            const streamed = output.map((m) => str(m.content)).filter(Boolean).join('\n\n');
+            target.context_messages = dedupeContext(stoppedTurnContext(previousContext, ownRows ? [...previousContext, ...ownRows] : null, prompt, pendingText, streamed, previousContext.length) ?? [...structuredClone(previousContext), { role: 'user', content: prompt }]);
+        }
+        if (target.hasPendingPrompt || output.length) {
+            target.messages.push(...output);
+            if (!answered)
+                target.messages.push({ role: 'assistant', content: '**Interrupted:** The reply was interrupted before it could be saved.', timestamp: Math.trunc(this.deps.now()), _error: true, _turn_id: turnId });
+            // Settled like a turn: the Agent's own rows are covered by the recovered turn; without them, every row past the run's start is.
+            this.settleStateDb(target, { turnId, previousContext, agentRows: ownRows, startId: stateDbSeenId(before) ?? (read.idCapable ? 0 : null) });
         }
         target.active_stream_id = null;
         target.pending_user_message = null;
@@ -582,7 +722,8 @@ export class SessionService {
         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 cliRead = wantState ? this.deps.cliSessions(activeProfile, { sourceFilter: params.sourceFilter ?? null }) : undefined;
-        const cliRows = cliRead?.rows;
+        const claudeCodeRows = params.showCliSessions && params.showClaudeCodeSessions ? this.claudeCodeRows() : [];
+        const cliRows = cliRead ? [...cliRead.rows, ...claudeCodeRows] : undefined;
         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 });
@@ -609,15 +750,16 @@ export class SessionService {
         const query = q.toLowerCase().trim();
         if (!query)
             return { sessions: sessions.map((s) => redactRow({ ...s })), all_profiles: opts.allProfiles, active_profile: activeProfile };
+        const terms = sessionSearchTerms(query);
         const results = [];
         for (const s of sessions) {
-            if (str(s.title).toLowerCase().includes(query)) {
+            if (sessionSearchMatches(str(s.title), terms)) {
                 results.push(redactRow({ ...s, match_type: 'title' }));
                 continue;
             }
             if (!opts.content)
                 continue;
-            const hit = this.contentMatch(str(s.session_id), query, opts.depth);
+            const hit = this.contentMatch(str(s.session_id), terms, opts.depth);
             if (hit)
                 results.push(redactRow({ ...s, ...hit }));
         }
@@ -638,22 +780,23 @@ export class SessionService {
         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 terms = sessionSearchTerms(query);
         const results = [];
         for (const row of rows) {
-            if (str(row.title).toLowerCase().includes(query))
+            if (sessionSearchMatches(str(row.title), terms))
                 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)))
+            else if (['workspace', 'workspace_name', 'model', 'model_provider', 'profile', 'source_label'].some((k) => sessionSearchMatches(str(row[k]), terms)))
                 results.push({ ...row, match_type: 'metadata' });
             else if (opts.content) {
-                const hit = this.contentMatch(str(row.session_id), query, opts.depth);
+                const hit = this.contentMatch(str(row.session_id), terms, opts.depth);
                 if (hit)
                     results.push({ ...row, ...hit });
             }
         }
         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) {
+    /** The first of a stored session's first `depth` messages (0: all) containing every term, with its redacted excerpt. */
+    contentMatch(sid, terms, depth) {
         let sess;
         try {
             sess = this.store.get(sid, { promote: false, cacheOnMiss: false });
@@ -663,10 +806,10 @@ export class SessionService {
         }
         for (const m of depth ? sess.messages.slice(0, depth) : sess.messages) {
             const c = sessionSearchMessageText(m);
-            if (!c.toLowerCase().includes(query))
+            if (!sessionSearchMatches(c, terms))
                 continue;
             const item = { match_type: 'content' };
-            const preview = sessionSearchPreview(c, query);
+            const preview = sessionSearchPreview(c, terms);
             if (preview)
                 item.match_preview = redactText(preview, this.deps.redactEnabled());
             return item;
@@ -721,14 +864,16 @@ export class SessionService {
         const [workspace] = this.deps.workspaces.resolveImplicitWithRecovery(value, (p) => this.deps.workspaces.profileDefaultWorkspaceForBoot(p), profile);
         return workspace;
     }
+    /** The server owns the names' normalization (TAL-631): trimmed, blanks dropped, and nothing left is the profile's defaults. */
     validateToolsetsShape(toolsets) {
         if (toolsets === null || toolsets === undefined)
             return null;
-        if (!Array.isArray(toolsets) || !toolsets.length)
-            throw new HttpFailure(400, 'toolsets must be a non-empty list or null');
-        if (!toolsets.every((t) => typeof t === 'string' && t))
-            throw new HttpFailure(400, 'each toolset must be a non-empty string');
-        return toolsets;
+        if (!Array.isArray(toolsets))
+            throw new HttpFailure(400, 'toolsets must be a list or null');
+        if (!toolsets.every((t) => typeof t === 'string'))
+            throw new HttpFailure(400, 'each toolset must be a string');
+        const names = toolsets.map((t) => t.trim()).filter(Boolean);
+        return names.length ? names : null;
     }
     create(body, opts = {}) {
         // Python `new_session`: a body without a profile takes the request's active profile (cookie first).
@@ -923,6 +1068,7 @@ export class SessionService {
             throw new HttpFailure(400, 'keep_count must be non-negative');
         await this.store.withLock(sid, () => {
             truncateSessionAtKeep(s, keep);
+            this.markStateDbSeen(s, undefined, { boundary: true });
             this.store.save(s);
         });
         this.deps.runtime.evictAgent(sid);
@@ -1034,7 +1180,8 @@ export class SessionService {
                 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);
+                const read = this.stateDbRead(live);
+                const stateRows = read.rows;
                 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
@@ -1065,6 +1212,7 @@ export class SessionService {
                 live.truncation_watermark = truncationWatermarkFor(compressed);
                 live.truncation_boundary = live.truncation_watermark;
                 live.truncation_watermark_compressed = true;
+                this.markStateDbSeen(live, read, { boundary: true });
                 live.last_prompt_tokens = result.after_tokens;
                 live.post_compression_context_tokens_estimate = result.after_tokens;
                 this.store.save(live);
@@ -1126,6 +1274,7 @@ export class SessionService {
             s.pending_user_source = null;
             s.clear_generation = hadMessages ? randomUUID().replace(/-/g, '') : null;
             applySessionTitleRename(s, 'Untitled');
+            this.markStateDbSeen(s, undefined, { boundary: true });
             this.store.save(s);
             if (hadMessages) {
                 try {
@@ -1156,6 +1305,7 @@ export class SessionService {
                 return { error: 'The last message has nothing to resend.' };
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
+            this.markStateDbSeen(s, undefined, { boundary: true });
             this.store.save(s);
             return { ok: true, last_user_text: lastUserText, last_user_prompt: lastUserPrompt, last_user_attachments: lastUserAttachments, removed_count: removed };
         });
@@ -1171,6 +1321,7 @@ export class SessionService {
             const removedText = extractText(history[lastUser]?.content);
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
+            this.markStateDbSeen(s, undefined, { boundary: true });
             this.store.save(s);
             const preview = removedText.length > 40 ? `${removedText.slice(0, 40)}...` : removedText;
             return { ok: true, removed_count: removed, removed_preview: preview };
@@ -1246,6 +1397,19 @@ export class SessionService {
         }
         return { session_id: branch.session_id, title, parent_session_id: source.session_id };
     }
+    /** The run that keeps `delete` answering 409, if any; stream status reports it so a draining client can wait on it (TAL-622). */
+    activeRunBlocking(sid) {
+        const live = this.deps.runtime.activeRunStream(sid);
+        if (live)
+            return live;
+        try {
+            const candidate = str(this.store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false }).active_stream_id).trim();
+            if (candidate && this.deps.runtime.activeStreamIds.has(candidate))
+                return candidate;
+        }
+        catch { /* absent */ }
+        return null;
+    }
     async delete(sid) {
         if (!sid)
             throw new HttpFailure(400, 'session_id is required');
@@ -1278,24 +1442,11 @@ export class SessionService {
                 return true;
         }
         catch { /* absent */ } const meta = this.lookupCliMeta(sid); return meta !== null && isMessagingSessionRecord(meta); })();
-        const blocking = () => {
-            const live = this.deps.runtime.activeRunStream(sid);
-            if (live)
-                return live;
-            try {
-                const snapshot = this.store.get(sid, { metadataOnly: true });
-                const candidate = str(snapshot.active_stream_id).trim();
-                if (candidate && this.deps.runtime.activeStreamIds.has(candidate))
-                    return candidate;
-            }
-            catch { /* absent */ }
-            return null;
-        };
-        if (blocking())
+        if (this.activeRunBlocking(sid))
             throw new HttpFailure(409, 'Session has an active run; stop it before deleting');
         try {
             await this.store.withLock(sid, () => {
-                if (blocking())
+                if (this.activeRunBlocking(sid))
                     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 {
@@ -1329,11 +1480,15 @@ export class SessionService {
         // messaging channel's memory is never erased from the WebUI; the actual outcome is reported.
         let stateDbCleanupFailed = false;
         if (!isMessaging) {
-            try {
-                stateDbCleanupFailed = !(await this.deps.runtime.deleteCliSession(eventProfile, sid));
-            }
-            catch {
-                stateDbCleanupFailed = true;
+            // TAL-529: the compression continuations go too, tip first; the Agent's delete keeps and detaches them otherwise.
+            for (const id of stateDbCompressionLineage(this.stateDbPath(eventProfile), sid).reverse()) {
+                try {
+                    if (!(await this.deps.runtime.deleteCliSession(eventProfile, id)))
+                        stateDbCleanupFailed = true;
+                }
+                catch {
+                    stateDbCleanupFailed = true;
+                }
             }
         }
         this.publish('session_delete', eventProfile);
@@ -1603,6 +1758,7 @@ export class SessionService {
     }
     // ── shares ───────────────────────────────────────────────────────────────
     createShare(sid) {
+        this.rejectClaudeCode(sid, 'shared');
         let s = this.get404(sid);
         if (!this.visibleToActiveProfile(s.profile))
             throw new HttpFailure(404, 'Session not found');
@@ -1621,7 +1777,7 @@ export class SessionService {
         this.publish('session_share_create', s.profile, sid);
         return {
             ok: true,
-            share: { token: meta.share_token, url: `/share/${meta.share_token}`, title: meta.share_title, message_count: meta.share_message_count, created_at: meta.share_created_at, updated_at: meta.share_updated_at },
+            share: { token: meta.share_token, url: sharePath(meta.share_token) ?? '', title: meta.share_title, message_count: meta.share_message_count, created_at: meta.share_created_at, updated_at: meta.share_updated_at },
             session: this.publicSession(s),
         };
     }
@@ -1688,6 +1844,44 @@ function findLastUserIndex(history) {
 export function sanitizePaths(error) {
     return str(error?.message ?? error).replace(/(?:(?:\/[a-zA-Z0-9_.-]+)+|(?:[A-Z]:\\[^\s]+))/g, '<path>');
 }
+/** TAL-536: a dead run's own state.db rows: from its prompt to the next prompt (tool results and applied steers stay in it). */
+function runStateDbRows(rows, prompt) {
+    const at = rows.findIndex((m) => looksLikeCurrentUserTurn(m, prompt));
+    if (at < 0)
+        return null;
+    const toolResult = (m) => Array.isArray(m.content) && m.content.some((part) => isDict(part) && part.type === 'tool_result');
+    const end = rows.findIndex((m, i) => i > at && m.role === 'user' && !toolResult(m) && agentSteerText(m) === null);
+    return rows.slice(at, end < 0 ? undefined : end);
+}
+/** TAL-493: a row's full-text identity; one with no text (reasoning or media only) by its raw role, content, and reasoning. */
+function settledIdentity(m) {
+    return messageIdentity(m, Infinity) ?? JSON.stringify([m.role ?? null, m.content ?? null, reasoningFieldsText(m)]);
+}
+/** `rows` minus one occurrence of each row of `base`, by `settledIdentity`. */
+function withoutRows(rows, base) {
+    const left = new Map();
+    for (const m of base)
+        left.set(settledIdentity(m), (left.get(settledIdentity(m)) ?? 0) + 1);
+    return rows.filter((m) => { const key = settledIdentity(m); const n = left.get(key) ?? 0; if (n > 0)
+        left.set(key, n - 1); return n === 0; });
+}
+/**
+ * TAL-493: what the state.db marker was recorded under: the boundary fields every boundary writer sets (an older release
+ * moves them without the marker) and the role, timestamp, and database file identity of the row the marker names (a
+ * recreated state.db, whose ids start over, has no such row).
+ */
+function stateDbMarkKey(s, stateRows, seenId) {
+    const anchor = seenId === null ? undefined : stateRows.find((m) => m._state_db_row_id === seenId);
+    return JSON.stringify([s.truncation_watermark ?? null, s.truncation_boundary ?? null, s.intentional_shrink_generation ?? null, s.clear_generation ?? null, anchor ? [anchor.role ?? null, anchor.timestamp ?? null, anchor._state_db_generation ?? null] : null]);
+}
+/**
+ * The recorded state.db marker while what it was recorded under still holds and this version wrote the session last (an
+ * older release can apply a boundary that changes no field), else null (the timestamp rules apply).
+ */
+function currentStateDbSeenId(s, stateRows) {
+    const seenId = s.state_db_seen_id;
+    return seenId !== null && s.state_db_seen_stamp === s.updated_at && s.state_db_seen_boundary === stateDbMarkKey(s, stateRows, seenId) ? seenId : null;
+}
 function truncationWatermarkFor(messages) {
     if (!messages.length)
         return 0.0;