@maudecode/talaria-web 1.17.2 → 1.19.0

package/dist/sessions/service.js

@@ -1,25 +1,32 @@
+import { filterAsync } from '../util.js';
+import { statSignature } from '../fs/stat.js';
+import { SessionPrefixIndex } from './prefix-index.js';
 import { str } from '../util.js';
-import { randomUUID } from 'node:crypto';
+import { createHmac, 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, sessionSearchMatches, sessionSearchMessageText, sessionSearchPreview, sessionSearchTerms } from './list.js';
+import { allSessions, buildSessionListPayload, reconcileLocalSessionRows, sessionLineageIds, CLI_IDENTITY_FIELDS, isClaimableCliSource, isMessagingSessionRecord, ownerLockCandidates, withOwnerLocks, withSessionWireFlags, lineageRootId, mergeCliSidebarMetadata, sessionListResponse, sessionSearchMatches, sessionSearchPreview, sessionSearchTerms } from './list.js';
 import { anchorSceneIntOrNull, fullToolResult, hydrateAnchorActivityScenes, normalizeAnchorSceneMessageRef, readAnchorSceneRows, storeAnchorScene, withTurnIds } from './anchor.js';
-import { isSafeSessionId, lastMessageTimestamp, Session, sharePath, stripAttachedFilesMarker, titleFrom } from './session.js';
-import { SessionBusy, SessionNotFound, statSignature } from './store.js';
-import { UNSETTLED_TODO_KEY, attachTodoState } from './todo.js';
+import { contextUsage, COMPRESSION_RECOVERY_ACTION_START_FOCUSED, compressionRecoveryPayload, forgetContextFigures, isSafeSessionId, lastMessageTimestamp, Session, sharePath, stripAttachedFilesMarker, titleFrom } from './session.js';
+import { SessionBusy, SessionNotFound } from './store.js';
+import { UNSETTLED_TODO_KEY, attachTodoSnapshot, attachTodoState } from './todo.js';
 import { isClaudeCodeSessionId } from './claude-code.js';
-import { stateDbCompressionLineage, stateDbSessionMessages, stateDbSessionRead, stateDbSessionRow, stateDbSessionSources } from './state-db.js';
+import { auditSessionRecovery, repairSafeSessionRecovery } from './recovery.js';
+import { agentSessionRowsExisting, agentSessionRowsExistingAsync, CANONICAL_READ_ONLY_REASON, OWNERSHIP_UNAVAILABLE_REASON, CONVERSATION_ROUND_THRESHOLD, countConversationRounds, stateDbCompressionLineage, stateDbTailToolContent, stateDbLineageReport, stateDbLocalTarget, stateDbSessionMessages, stateDbSessionRead, stateDbSessionTailRead, stateDbSessionRow, stateDbSessionSources, stateDbSessionSourcesAsync, stateDbTimestampSeconds } from './state-db.js';
+import { completionIncomplete, fallbackHandoffSummary, HANDOFF_SYSTEM_PROMPT, handoffMarker, handoffPayload, handoffTranscript, messageHandoffPayload, sameHandoff } from './handoff.js';
 import { anchorMessageKey, anchorSummary, CompressionJobs, compressionReference, visibleMessagesForAnchor } from './compress.js';
-import { SidecarError } from '../sidecar/client.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 { chatReadiness, runtimeFailureDetails, SidecarError } from '../sidecar/client.js';
+import { agentSteerText, ApiMessageSummary, appendStateDbIdentityRows, attachedFilesPrompt, attachmentObjects, checkpointTurnStart, dedupeContext, isContextCompressionMarker, journalOutputRows, looksLikeCurrentUserTurn, stoppedTurnContext, mergeSessionMessagesAppendOnly, messageIdentity, pendingUserRow, reasoningFieldsText, sanitizeMessagesForApi, stateDbSeenId, stripWorkspacePrefix, withAttachmentObjects, newestSettledReply, withBodyExcerpts, withDisplayMedia, withMarkerKinds, withMirrorSources, withSceneRowMedia, withPendingUserTurn, withToolCallOutcomes, withoutRunningTurnOutput } from './merge.js';
 import { withBackgroundUpdates } from './background-updates.js';
+import { markedStateDbGeneration, stateDbIdentityKeys, stampStateDbGeneration, stateDbMessageRepresented } from './state-db-identity.js';
+import { sourceKind } from './source-kind.js';
 import { withBackgroundLinks } from './background-tasks.js';
-import { messagesForLimitedPayload, messageWindowForDisplay, MAX_MSG_LIMIT, parseMsgLimit, toolCallsForMessageWindow } from './window.js';
+import { messagesForLimitedPayload, messageCountsAsRenderable, 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 { mediaAnchorRootResolved, resolveMediaAccess, mediaRefPath, mediaTarget } from '../workspace/media.js';
 import { projectMediaRefs } from '../workspace/media-refs.js';
 import { loadGatewaySessionIdentityMap } from './list.js';
 import { join } from 'node:path';
@@ -48,8 +55,31 @@ export async function ensureAgentRuntimeCurrent(sidecar) {
             throw staleRuntimeFailure(error);
     }
 }
+/** The health probe is also the browser's server-reachability probe (30 s), so the readiness check answers well inside it. */
+const CHAT_READINESS_CHECK_TIMEOUT_MS = 5_000;
+/**
+ * TAL-951: whether a chat turn would be admitted now. Ready and source-stale incompatible sidecars both run turn
+ * admission's live check: recovery state can change after the handshake. A check
+ * that cannot answer fails closed as `sidecar_unavailable`.
+ */
+export async function currentChatReadiness(sidecar) {
+    const readiness = chatReadiness(sidecar);
+    if (!sidecar || (!readiness.available && readiness.condition !== 'agent_runtime_stale'))
+        return readiness;
+    try {
+        await sidecar.call('runtime.ensure_current', {}, { timeoutMs: CHAT_READINESS_CHECK_TIMEOUT_MS });
+    }
+    catch (error) {
+        if (error instanceof SidecarError && error.condition === 'agent_runtime_stale')
+            return { available: false, ...runtimeFailureDetails(error.condition, error.data), condition: 'agent_runtime_stale' };
+        return { available: false, condition: error instanceof SidecarError && error.condition === 'agent_incompatible' ? 'agent_incompatible' : 'sidecar_unavailable' };
+    }
+    // The live guard can clear after a rollback, but the client's incompatible admission gate still refuses chat.
+    return readiness.available ? readiness : { available: false, ...runtimeFailureDetails('agent_runtime_stale'), condition: 'agent_runtime_stale' };
+}
 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 { message, ...details } = runtimeFailureDetails(error.condition, error.data);
+    return new HttpFailure(409, message ?? error.message, details);
 }
 /** 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;
@@ -57,29 +87,67 @@ const RECOVERY_JOURNAL_MAX_ROWS = 65536;
 const isDict = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
 export class SessionService {
     deps;
+    owner = null;
     /** TAL-255: one manual compression worker per session, shared by every compress route. */
     compressionJobs;
+    /** TAL-1005: the turns now waiting on their session's compression job before they read its history. */
+    compactionWaiters = new Set();
     constructor(deps) {
         this.deps = deps;
         this.compressionJobs = new CompressionJobs();
     }
     get store() { return this.deps.store; }
+    /**
+     * User-turn admission shared by `chat.start` and automatic turns through `TurnRunner.startServerTurn`.
+     * A requested workspace must be trusted; the session's own one, when its directory is gone, falls back to the last one.
+     */
+    async turnWorkspace(s, requested) {
+        const ws = this.deps.workspaces;
+        if (requested !== undefined && requested !== null && requested !== '') {
+            try {
+                return (await ws.resolveTrusted(str(requested), s.profile));
+            }
+            catch (error) {
+                throw new HttpFailure(400, error.message);
+            }
+        }
+        try {
+            const [workspace, recovered] = (await ws.resolveImplicitWithRecovery(s.workspace, async (p) => (await ws.lastWorkspace(p)), s.profile));
+            if (recovered)
+                s.workspace = workspace;
+            return workspace;
+        }
+        catch (error) {
+            throw new HttpFailure(400, error.message);
+        }
+    }
+    /** A `@provider:` id is split; any other model an explicit pick did not just choose is checked against the catalog (TAL-542). */
+    turnModel(s, body = {}) {
+        const requestedModel = str(body.model) || s.model;
+        const requestedProvider = 'model_provider' in body ? body.model_provider : s.model_provider;
+        const [model, provider] = this.deps.modelStateFromRequest(requestedModel, requestedProvider, s.model_provider);
+        if (model !== requestedModel || !model || body.explicit_model_pick === true)
+            return [model, provider, model !== requestedModel];
+        const repaired = this.deps.repairSessionModel?.(s.profile ?? null, model, provider);
+        return repaired ? [repaired[0], repaired[1], true] : [model, provider, false];
+    }
     /**
      * 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) {
+    async mediaProjector(s) {
         const media = this.deps.media;
+        const access = media ? await resolveMediaAccess(media.access) : null;
         const served = new Map();
         const localUrl = (path) => {
-            if (!media?.localIo(s.profile))
+            if (!media?.localIo(s.profile) || !access)
                 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))
+                if (mediaAnchorRootResolved(target, s, access))
                     url = `./api/media?${new URLSearchParams({ path: target, session_id: s.session_id }).toString()}`;
             }
             catch { /* an invalid path stays text */ }
@@ -106,7 +174,7 @@ export class SessionService {
      * not slip past the profile check into a handler that trims and trusts it. A non-empty id that is still unsafe after
      * trimming can name no session and is refused here instead of falling through.
      */
-    sessionIdVisible(raw) {
+    async sessionIdVisible(raw) {
         if (typeof raw !== 'string' || !raw.trim())
             return true;
         const sid = raw.trim();
@@ -114,70 +182,196 @@ export class SessionService {
             return false;
         let session;
         try {
-            session = this.store.get(sid, { metadataOnly: true });
+            session = (await this.store.get(sid, { metadataOnly: true }));
         }
         catch {
             return true;
         }
         return this.visibleToActiveProfile(session.profile);
     }
+    localTargets = null;
+    /** One receipt-backed physical target for every operation on a local conversation alias. */
+    resolveSessionId(sid) {
+        try {
+            const path = this.stateDbPath(null);
+            const key = JSON.stringify([statSignature(path), statSignature(`${path}-wal`), path]);
+            if (this.localTargets?.key !== key)
+                this.localTargets = { key, ids: new Map() };
+            const cached = this.localTargets.ids.get(sid);
+            if (cached)
+                return cached;
+            return stateDbLocalTarget(path, sid, { onRead: (target) => {
+                    // A failed or changing read cannot seed a routing cache.
+                    if (key !== JSON.stringify([statSignature(path), statSignature(`${path}-wal`), path]))
+                        return;
+                    if (this.localTargets.ids.size >= 500)
+                        this.localTargets.ids.clear();
+                    this.localTargets.ids.set(sid, target);
+                } });
+        }
+        catch {
+            return sid;
+        }
+    }
     /** Python `_lookup_cli_session_metadata(...).get('read_only')` plus the persisted sidecar flag and a not-claimable foreign owner. */
-    isReadOnlyImport(sid) {
+    async isReadOnlyImport(sid) {
         try {
-            const s = this.store.get(sid, { metadataOnly: true });
-            if (this.isReadOnly(s))
+            const s = (await this.store.get(sid, { metadataOnly: true }));
+            if ((await this.isReadOnly(s)))
                 return true;
         }
         catch {
             // No sidecar: a foreign state.db transcript whose owner refuses claiming is read-only too.
-            const { session, reason } = this.claimOrSynthesizeCliSession(sid);
+            const { session, reason } = (await this.claimOrSynthesizeCliSession(sid));
             if (session && reason === 'not_claimable')
                 return true;
         }
-        const meta = this.lookupCliMeta(sid);
+        const meta = (await this.lookupCliMeta(sid));
         return meta !== null && Boolean(meta.read_only);
     }
     /** Python `_session_is_subagent_view_only`: a delegated child by any signal — the persisted sidecar or the state.db row. */
-    isSubagentViewOnly(sid) {
+    async isSubagentViewOnly(sid) {
         try {
-            const s = this.store.get(sid);
+            const s = (await this.store.get(sid, { metadataOnly: true, cacheOnMiss: false, promote: false }));
             if (str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() === 'subagent')
                 return true;
         }
         catch { /* no sidecar */ }
-        const meta = this.lookupCliMeta(sid);
+        const meta = (await this.lookupCliMeta(sid));
         return meta !== null && str(meta.source_tag || meta.raw_source || meta.source).trim().toLowerCase() === 'subagent';
     }
     /** TAL-358: batched `sessions.source` owners from the active profile's state.db. */
-    stateDbSources = (ids) => stateDbSessionSources(join(this.deps.profileHome(this.deps.activeProfile()), 'state.db'), ids);
+    stateDbSources = (ids, profile = this.deps.activeProfile()) => {
+        try {
+            return stateDbSessionSources(this.stateDbPath(profile), ids);
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * TAL-590 (Python #3238): the read-only CLI or API-server imports among `rows` whose active-profile state.db row is
+     * gone, so their source was deleted outside Web and no Web action could remove them. An unreadable state.db proves
+     * nothing (`agentSessionRowsExisting`); another profile's session or one with a run the runtime still holds is never
+     * an orphan, while a stream id a crash left behind does not count as one.
+     */
+    async orphanedImports(rows, existing, owners) {
+        const candidates = (await this.orphanCandidates(rows));
+        if (!candidates.length)
+            return new Set();
+        existing ??= agentSessionRowsExisting(this.stateDbPath(null), candidates);
+        if (owners === undefined)
+            owners = this.stateDbSources(candidates);
+        return new Set(candidates.filter((sid) => !existing.has(sid) && owners !== null && typeof owners.get(sid) !== 'object'));
+    }
+    async orphanCandidates(rows) {
+        return (await filterAsync(rows, async (r) => r.read_only && ['cli', 'api'].includes(sourceKind(r)) && this.visibleToActiveProfile(str(r.profile) || null) && !(await this.activeRunBlocking(str(r.session_id)))))
+            .map((r) => str(r.session_id));
+    }
+    async isOrphanedImport(sid) {
+        try {
+            return (await this.orphanedImports([(await this.store.get(sid, { metadataOnly: true })).compact()])).size > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * The list's owner locks and orphan prune (an orphan's sidecar goes, as nothing else ever removes it), with their
+     * state.db reads made on the listing worker up front so the synchronous build never opens state.db (TAL-920).
+     */
+    async listStateDbLookups(rows, cliRowIds) {
+        const dbPath = this.stateDbPath(null);
+        const activeProfile = this.deps.activeProfile();
+        const byProfile = ownerLockCandidates(rows);
+        const activeIds = byProfile.get(activeProfile) ?? new Set();
+        for (const id of cliRowIds)
+            activeIds.add(id);
+        byProfile.set(activeProfile, activeIds);
+        const owners = new Map(await Promise.all([...byProfile].map(async ([profile, ids]) => [profile, ids.size ? await stateDbSessionSourcesAsync(this.stateDbPath(profile), ids) : new Map()])));
+        const checked = new Set((await this.orphanCandidates(rows)));
+        const existing = checked.size ? await agentSessionRowsExistingAsync(dbPath, checked) : new Set();
+        return {
+            stateDbSources: (_ids, profile = activeProfile) => owners.get(profile) ?? null,
+            pruneOrphanedImports: async (current) => {
+                // Only an id the worker checked can be an orphan; a row that became a candidate meanwhile waits for the next list.
+                const orphans = (await this.orphanedImports(current.filter((r) => checked.has(str(r.session_id))), existing, owners.get(activeProfile) ?? null));
+                for (const sid of orphans)
+                    (await this.store.delete(sid));
+                return orphans;
+            },
+        };
+    }
     /** The persisted flag folded with the state.db owner lock (TAL-358): the one read-only rule for mutation gates and the wire. */
-    isReadOnly(s) {
-        if (s.read_only)
-            return true;
-        const [row] = withOwnerLocks([{ session_id: s.session_id, source_tag: s.source_tag, raw_source: s.raw_source, session_source: s.session_source }], this.stateDbSources);
-        return Boolean(row?.read_only);
+    async readOnlyReason(s, profile) {
+        if (typeof s === 'string') {
+            try {
+                s = await this.store.get(s, { metadataOnly: true, cacheOnMiss: false, promote: false });
+            }
+            catch (error) {
+                if (!(error instanceof SessionNotFound))
+                    return OWNERSHIP_UNAVAILABLE_REASON;
+            }
+        }
+        return this.loadedReadOnlyReason(s, profile);
+    }
+    loadedReadOnlyReason(s, profile) {
+        let raw = typeof s === 'string' ? { session_id: s, profile: this.deps.activeProfile() }
+            : { session_id: s.session_id, profile: s.profile, source_tag: s.source_tag, raw_source: s.raw_source, session_source: s.session_source, read_only: s.read_only };
+        if (profile !== undefined)
+            raw = this.deps.profilesMatch(str(raw.profile) || null, profile) ? { ...raw, profile } : { session_id: raw.session_id, profile };
+        const row = withOwnerLocks([raw], this.stateDbSources)[0];
+        return row.read_only ? str(row.read_only_reason) || 'Read-only imported sessions cannot be modified from WebUI' : null;
+    }
+    assertWritable(session, profile) {
+        const check = (reason) => { if (reason)
+            throw new HttpFailure(403, reason); };
+        if (typeof session === 'string')
+            return this.readOnlyReason(session, profile).then(check);
+        check(this.loadedReadOnlyReason(session, profile));
+    }
+    /** Controls can exist without a local session file; use the same id the sidecar will address. */
+    async idForMutation(sid) {
+        sid = sid.trim();
+        if (!sid)
+            throw new HttpFailure(400, 'Missing required field(s): session_id');
+        await this.assertWritable(sid);
+        return sid;
+    }
+    async isReadOnly(s) { return (await this.readOnlyReason(s)) !== null; }
+    /** Recheck after the mutex wait; legacy local metadata/handoff actions keep their existing read-only allowance. */
+    withMutationLock(sid, fn, opts = {}) {
+        return this.store.withLock(sid, async () => {
+            if (opts.allowReadOnly)
+                (await this.rejectViewOnly(sid, 'modified'));
+            else
+                (await this.assertWritable(sid));
+            return fn();
+        }, opts);
     }
     /** Full session for mutation, refusing read-only imports (Python `_get_or_materialize_session`). */
-    getForMutation(sid) {
-        let s = this.get404(sid);
-        s = this.store.ensureFull(sid, s);
-        if (this.isReadOnly(s))
-            throw new HttpFailure(403, 'Read-only imported sessions cannot be modified from WebUI');
+    async getForMutation(sid) {
+        let s = (await this.get404(sid));
+        s = (await this.store.ensureFull(sid, s));
+        this.assertWritable(s);
         if (str(s.source_tag || s.raw_source).trim().toLowerCase() === 'subagent')
             throw new HttpFailure(403, 'Read-only subagent child session');
         return s;
     }
-    get404(sid, opts = {}) {
+    async get404(sid, opts = {}) {
+        sid = this.resolveSessionId(sid);
         try {
-            return this.store.get(sid, opts);
+            return (await this.store.get(sid, opts));
         }
         catch (error) {
             if (error instanceof SessionNotFound) {
                 // Python `_get_or_materialize_session`: a claimable foreign (CLI/TUI/Desktop) session gains a WebUI sidecar
                 // on its first mutation; a read-only foreign source answers 403 from `getForMutation`, a missing one 404.
-                const synth = this.claimOrSynthesizeCliSession(sid);
+                const synth = (await this.claimOrSynthesizeCliSession(sid));
                 if (synth.session && synth.reason === 'materialized') {
-                    this.store.save(synth.session);
+                    await this.store.save(synth.session);
+                    await this.store.touch(synth.session);
+                    this.deps.titleClaimed?.(synth.session);
                     return synth.session;
                 }
                 if (synth.session)
@@ -194,11 +388,16 @@ export class SessionService {
     /** `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 { rows: [], idCapable: false, ok: false };
+            return { rows: [], idCapable: false, ok: false, reason: null, generation: null };
         // 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 });
     }
+    /** Preserve existing transcript provenance before a turn adds Agent rows from its starting database read. */
+    beginStateDbTurn(s) {
+        stampStateDbGeneration([...s.messages, ...s.context_messages], markedStateDbGeneration(s));
+        return this.stateDbRead(s);
+    }
     stateDbPath(profile) {
         return join(this.deps.profileHome(profile ?? this.deps.activeProfile()), 'state.db');
     }
@@ -210,7 +409,7 @@ export class SessionService {
     mergedTranscript(s, local = s.messages, stateRows = this.stateDbRows(s)) {
         if (!stateRows.length)
             return local;
-        return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: currentStateDbSeenId(s, stateRows) });
+        return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: currentStateDbSeenId(s, stateRows), stateDbGeneration: markedStateDbGeneration(s) });
     }
     /**
      * TAL-493: record the highest state.db id this boundary or settled turn read, under the session lock in the same save,
@@ -218,6 +417,10 @@ export class SessionService {
      * fields are set: the marker holds only while they and the row it names stay as recorded.
      */
     markStateDbSeen(s, read = this.stateDbRead(s), opts = {}) {
+        // Freeze numeric provenance before replacing the marker, including after a database replacement.
+        const priorGeneration = markedStateDbGeneration(s);
+        if (priorGeneration !== null)
+            stampStateDbGeneration([...s.messages, ...s.context_messages], priorGeneration);
         // 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) {
@@ -242,22 +445,38 @@ export class SessionService {
      * 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 read = turn.read ?? this.stateDbRead(s);
+        const agentAdded = withoutRows(turn.agentRows ?? [], turn.previousContext);
+        const contextAdded = withoutRows(s.context_messages, turn.previousContext);
+        if (typeof turn.startGeneration === 'string') {
+            stampStateDbGeneration(s.messages.filter((m) => m._turn_id !== turn.turnId), markedStateDbGeneration(s));
+            stampStateDbGeneration([...s.messages.filter((m) => m._turn_id === turn.turnId), ...contextAdded, ...agentAdded], turn.startGeneration);
+        }
+        const startGeneration = turn.previousContext.findLast((m) => typeof m._state_db_generation === 'string')?._state_db_generation;
+        const generation = turn.startGeneration ?? markedStateDbGeneration(s) ?? (typeof startGeneration === 'string' ? startGeneration : null);
+        const readGeneration = read.generation;
+        const generationChanged = generation !== null && typeof readGeneration === 'string' && generation !== readGeneration;
+        const includeUids = read.rows.some((m) => stateDbIdentityKeys(m).some((id) => id.startsWith('uid:')));
+        const identities = (m) => stateDbIdentityKeys(m, includeUids, generation);
+        const startedWith = new Set(turn.previousContext.flatMap((m) => identities(m)));
+        const wasInContext = (m) => stateDbMessageRepresented(m, startedWith, includeUids, generation);
+        const earlier = mergeSessionMessagesAppendOnly(s.messages, read.rows.filter(wasInContext), { stateDbSeenId: -1, stateDbGeneration: generation }).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;
+        const addedIds = new Set(agentAdded.flatMap((m) => identities(m)));
+        for (const m of agentAdded) {
+            if (!identities(m).length)
+                added.set(settledIdentity(m), (added.get(settledIdentity(m)) ?? 0) + 1);
+        }
+        const ownWorkAfter = turn.agentRows?.length || generationChanged ? 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 seenId = currentStateDbSeenId(s, read.rows) ?? (generationChanged ? null : turn.startId ?? null);
+        const shown = read.rows.length ? mergeSessionMessagesAppendOnly(s.messages, read.rows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: seenId, stateDbGeneration: generation }) : 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))
+                if (typeof id !== 'number' || id <= seenId || wasInContext(m) || fresh.has(m))
                     continue;
                 const left = added.get(settledIdentity(m)) ?? 0;
                 if (left > 0)
@@ -266,7 +485,9 @@ export class SessionService {
         }
         const missed = [...fresh].filter((m) => {
             const id = m._state_db_row_id;
-            if (typeof id === 'number' && startedWith.has(id))
+            if (wasInContext(m))
+                return false;
+            if (stateDbMessageRepresented(m, addedIds, includeUids, generation))
                 return false;
             const key = settledIdentity(m);
             const left = added.get(key) ?? 0;
@@ -283,7 +504,7 @@ export class SessionService {
         if (missed.length) {
             s.messages.push(...copyJson(missed));
             if (s.context_messages.length)
-                s.context_messages.push(...copyJson(missed));
+                s.context_messages = mergeSessionMessagesAppendOnly(s.context_messages, copyJson(missed), { stateDbSeenId: -1, stateDbGeneration: generation });
         }
         this.markStateDbSeen(s, read);
         // TAL-529: a compression rotation moved the Agent to a continuation, whose first rows restate the compressed context.
@@ -296,6 +517,30 @@ export class SessionService {
             this.markStateDbSeen(s);
         }
     }
+    /**
+     * TAL-921: the model context a turn leaves when it ends without its settled result (an error, a Stop, a dead run), as a
+     * Stop's: the Agent's rows when they hold the turn's prompt, else its own rows among `stateRows` (the state.db rows
+     * committed after it started), then the prose that streamed past them. Null when it captured nothing the model can use.
+     */
+    unsettledTurnContext(turn) {
+        const reported = turn.agentRows && checkpointTurnStart(turn.agentRows, turn.msgText, turn.historyLength) !== null ? turn.agentRows : null;
+        const own = reported ? null : runStateDbRows(turn.stateRows, turn.msgText);
+        const checkpoint = reported ?? (own && [...turn.previousContext, ...own]);
+        const context = stoppedTurnContext(turn.previousContext, checkpoint, turn.prompt, turn.msgText, turn.streamedText, turn.historyLength);
+        if (!context)
+            return null;
+        if (!own || !checkpoint || checkpointTurnStart(checkpoint, turn.msgText, turn.historyLength) === null)
+            return dedupeContext(context);
+        // The context holds the turn's own state.db rows from its prompt on. The Agent persisted the prompt's text only, so the
+        // prompt row carries what the turn sent (attached files, images). This turn's settlement covers the rows: without
+        // their ids, the next one never reads them as a CLI continuation the transcript lacks.
+        const at = turn.previousContext.length;
+        return dedupeContext(context.map((m, i) => {
+            if (i === at)
+                return { role: 'user', content: turn.prompt, ...(m.timestamp != null ? { timestamp: m.timestamp } : {}) };
+            return i > at && i < at + own.length ? Object.fromEntries(Object.entries(m).filter(([k]) => k !== '_state_db_row_id' && k !== '_state_db_generation')) : m;
+        }));
+    }
     /**
      * 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
@@ -314,25 +559,37 @@ export class SessionService {
         const pending = this.pendingTurn(s);
         return pending ? withPendingUserTurn(context, pending) : context;
     }
+    /** Python `_is_messaging_session_id`: from the WebUI metadata or the Agent's row. */
+    async isMessagingSession(sid) {
+        try {
+            if (isMessagingSessionRecord((await this.store.get(sid, { metadataOnly: true })).compact()))
+                return true;
+        }
+        catch { /* absent */ }
+        const meta = (await this.lookupCliMeta(sid));
+        return meta !== null && isMessagingSessionRecord(meta);
+    }
     /** Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile. */
-    lookupCliMeta(sid) {
+    async 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;
+                return (await this.claudeCodeRows()).find((r) => str(r.session_id) === sid) ?? null;
+            const profile = this.deps.activeProfile();
+            return (await this.deps.cliSessionsSync(profile, { sourceFilter: null })).rows.find((r) => str(r.session_id) === sid)
+                ?? (await this.deps.cliSessionsSync(profile, { sourceFilter: null, sessionIds: [sid] })).rows[0] ?? null;
         }
         catch {
             return null;
         }
     }
-    claudeCodeRows() {
-        return this.deps.claudeCode?.rows(this.deps.workspaces.lastWorkspace(this.deps.activeProfile())) ?? [];
+    async claudeCodeRows() {
+        return this.deps.claudeCode?.rows((await 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) {
+    async indexMarksWasWebui(sid) {
         let entries;
         try {
-            entries = this.store.readIndexEntries();
+            entries = (await this.store.readIndexEntries());
         }
         catch {
             return false;
@@ -354,20 +611,23 @@ export class SessionService {
      * a WebUI sidecar. `materialized` sessions are writeable (the caller persists the sidecar), `not_claimable` ones are
      * read-only stubs, `was_webui`/`no_foreign_state`/`invalid_sid` answer 404.
      */
-    claimOrSynthesizeCliSession(sid, metaIn) {
+    async claimOrSynthesizeCliSession(sid, metaIn) {
         if (!isSafeSessionId(sid))
             return { session: null, reason: 'invalid_sid' };
         const profile = this.deps.activeProfile();
         const dbPath = join(this.deps.profileHome(profile), 'state.db');
+        sid = this.resolveSessionId(sid);
         const row = stateDbSessionRow(dbPath, sid);
         const stateDbSource = str(row?.source).trim().toLowerCase();
         const subagentChild = stateDbSource === 'subagent';
-        if ((this.indexMarksWasWebui(sid) || (this.store.wasDeleted(sid) && ['', 'webui', 'fork'].includes(stateDbSource))) && !subagentChild)
+        const owners = this.stateDbSources([sid]);
+        const canonical = typeof owners?.get(sid) === 'object';
+        if (((await this.indexMarksWasWebui(sid)) || ((await this.store.wasDeleted(sid)) && ['', 'webui', 'fork'].includes(stateDbSource))) && !subagentChild && !canonical)
             return { session: null, reason: 'was_webui' };
         const msgs = isClaudeCodeSessionId(sid) ? this.deps.claudeCode?.messages(sid) ?? [] : stateDbSessionMessages(dbPath, sid, { stitch: true });
-        if (!msgs.length)
+        const meta = { ...(metaIn ?? (await this.lookupCliMeta(sid)) ?? {}) };
+        if (!msgs.length && !(meta._lineage_root_id && meta._lineage_tip_id))
             return { session: null, reason: 'no_foreign_state' };
-        const meta = { ...(metaIn ?? this.lookupCliMeta(sid) ?? {}) };
         if (row) {
             if (!meta.source_tag && stateDbSource)
                 meta.source_tag = stateDbSource;
@@ -384,12 +644,16 @@ export class SessionService {
             if (!meta.updated_at && (row.ended_at || row.started_at))
                 meta.updated_at = row.ended_at || row.started_at;
         }
-        const claimable = isClaimableCliSource(meta, stateDbSource);
-        const workspace = str(meta.workspace || meta.cwd).trim() || this.deps.workspaces.lastWorkspace(profile);
-        const defaults = this.store.deps.defaults(profile);
+        // An owner read that fails is an unknown owner, which never releases a claim (TAL-793).
+        const claimable = owners !== null && isClaimableCliSource(meta, owners.get(sid) || stateDbSource);
+        const workspace = str(meta.workspace || meta.cwd).trim() || (await this.deps.workspaces.lastWorkspace(profile));
+        const defaults = (await this.store.deps.defaults(profile));
+        const context = Array.isArray(meta._lineage_ids) ? stateDbSessionMessages(dbPath, sid, { stitch: false }) : null;
         const session = new Session({
             session_id: sid, title: str(meta.title) || 'CLI Session', workspace, model: str(meta.model) || 'unknown', model_provider: str(meta.model_provider) || null,
             messages: msgs, created_at: Number(meta.created_at) || 0, updated_at: Number(meta.updated_at) || 0, profile: str(meta.profile) || null,
+            pinned: Boolean(meta.pinned), archived: Boolean(meta.archived),
+            ...(context ? { context_messages: context } : {}),
             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
@@ -399,9 +663,9 @@ export class SessionService {
         }, defaults);
         return { session, reason: claimable ? 'materialized' : 'not_claimable' };
     }
-    mutationTarget(sid, verb) {
+    async mutationTarget(sid, verb) {
         try {
-            return this.getForMutation(sid);
+            return (await this.getForMutation(sid));
         }
         catch (error) {
             if (error instanceof SessionNotFound)
@@ -419,49 +683,61 @@ export class SessionService {
         if (isClaudeCodeSessionId(sid))
             throw new HttpFailure(400, `Claude Code sessions are view-only and cannot be ${verb} from WebUI`);
     }
-    rejectSubagent(sid, verb) {
+    async rejectViewOnly(sid, verb) {
+        sid = sid.trim();
         this.rejectClaudeCode(sid, verb);
-        if (this.isSubagentViewOnly(sid))
+        let profile = this.deps.activeProfile();
+        try {
+            profile = (await this.store.get(sid, { metadataOnly: true, cacheOnMiss: false, promote: false })).profile || 'default';
+        }
+        catch { /* foreign row */ }
+        const owners = this.stateDbSources([sid], profile);
+        const owner = owners?.get(sid);
+        if (!owners || typeof owner === 'object')
+            throw new HttpFailure(403, typeof owner === 'object' ? owner.reason ?? CANONICAL_READ_ONLY_REASON : OWNERSHIP_UNAVAILABLE_REASON);
+        if ((await this.isSubagentViewOnly(sid)))
             throw new HttpFailure(400, `Subagent sessions are view-only and cannot be ${verb} from WebUI`);
+        return sid;
+    }
+    /** All transcript transports use the same live-run and durable-pending evidence. */
+    async backgroundUpdates(s, messages, reviewRows) {
+        return withBackgroundUpdates(messages, s, { activeTurnId: this.deps.runtime.activeRunStream(s.session_id), pendingDelegations: (await this.deps.backgroundPending?.(s.session_id)) ?? new Set(), ...(reviewRows ? { reviewRows } : {}) });
     }
     /** 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) ?? []);
+    async backgroundLinked(s, messages) {
+        return withBackgroundLinks(messages, (await 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);
+    async publicSession(s, withMessages = true, messages = s.messages) {
+        const payload = (await this.wireRow(s));
         // Mutation replies replace a client's transcript, so they carry the same server-built scenes as the detail.
         if (withMessages) {
-            payload.messages = this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes(withBackgroundUpdates(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.messages = (await this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes((await this.backgroundUpdates(s, withMarkerKinds(withTurnIds(messages), s))), s.tool_calls, s.active_stream_id), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, runningScene: !(await 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. */
-    wireRow(s) {
-        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);
+    async wireRow(s) {
+        return withSessionWireFlags(withOwnerLocks([{ ...s.compact({ contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }), assistant_name: this.assistantName(s), workspace_name: (await this.workspaceNames([s]))(s) }], this.stateDbSources)[0], 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() {
+    async workspaceNames(rows) {
         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);
+        for (const profile of new Set(rows.map((row) => str(row.profile) || 'default'))) {
+            let entries;
+            try {
+                entries = await this.deps.workspaces.entries(profile);
             }
-            return workspaceDisplayName(str(row.workspace), entries);
-        };
+            catch {
+                entries = [];
+            }
+            registries.set(profile, entries);
+        }
+        return (row) => workspaceDisplayName(str(row.workspace), registries.get(str(row.profile) || 'default') ?? []);
     }
     /** The agent's display name for a session's profile (`assistant_name`). */
     assistantName(s) {
@@ -472,47 +748,219 @@ export class SessionService {
         return redactSessionData(s.toDocument(), this.deps.redactEnabled());
     }
     // ── detail ──────────────────────────────────────────────────────────────
-    loadRevision(s) {
-        return statSignature(this.store.pathFor(s.session_id));
+    async loadRevision(s) {
+        return (await this.store.revision(s.session_id));
+    }
+    pageTails = new WeakMap();
+    pageContexts = new WeakMap();
+    prefixIndex(s, revision) {
+        const previous = s.prefixIndex;
+        if (previous?.rows === s.messages && previous.revision === revision && previous.length <= s.messages.length) {
+            previous.extend();
+            return previous;
+        }
+        return s.prefixIndex = new SessionPrefixIndex(s.messages, revision, markedStateDbGeneration(s), { toolCalls: s.tool_calls });
+    }
+    /** Existing projections, once per complete turn range, in absolute transcript coordinates. */
+    async deriveRange(s, rows, baseIndex, initialTurn, journaled, refs, calls, reviewRows) {
+        return (await this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes((await this.backgroundUpdates(s, withMarkerKinds(withTurnIds(withAttachmentObjects(rows), baseIndex, initialTurn), s), reviewRows)), calls, s.active_stream_id, baseIndex), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, runningScene: !journaled, clipToolResults: true, baseIndex, refCounts: refs })));
+    }
+    async limitedDetail(s, index, limit, before, pending, journaled) {
+        let prefixEnd = s.messages.length;
+        const turnId = pending?.turnId ?? journaled?.turnId;
+        if (turnId)
+            prefixEnd = Math.min(prefixEnd, index.turns.get(turnId)?.first ?? prefixEnd);
+        const prompt = pending ? index.prompts.get(pending.activeTurnToken) : undefined;
+        if (prompt !== undefined)
+            prefixEnd = Math.min(prefixEnd, prompt);
+        const dbPath = this.stateDbPath(s.profile);
+        const key = JSON.stringify([index.revision, index.length, statSignature(dbPath), statSignature(`${dbPath}-wal`), s.active_stream_id, pending, journaled, s.state_db_seen_id, s.state_db_seen_boundary, s.state_db_seen_stamp, s.updated_at, this.deps.activeProfile(), s.compression_anchor_summary, s.compression_anchor_message_key, s.compression_anchor_visible_idx, this.compactionWaiters.has(s.active_stream_id ?? '')]);
+        let cached = this.pageTails.get(index);
+        if (cached?.key !== key || cached.contextRows !== s.context_messages || cached.contextLength !== s.context_messages.length) {
+            const streaming = Boolean(s.active_stream_id && !this.compactionWaiters.has(s.active_stream_id));
+            const contextKey = JSON.stringify([index.revision, s.active_stream_id, index.length, streaming]);
+            let context = this.pageContexts.get(index);
+            if (context?.key !== contextKey || context.contextRows !== s.context_messages || context.contextLength !== s.context_messages.length) {
+                const summary = !s.context_messages.length && !s.active_stream_id ? index.model : new ApiMessageSummary(s.active_stream_id, !s.context_messages.length);
+                if (summary !== index.model && !streaming) {
+                    for (const row of s.context_messages.length ? s.context_messages : s.messages) {
+                        summary.add(row);
+                        if (summary.enough)
+                            break;
+                    }
+                    summary.finish();
+                }
+                context = { key: contextKey, local: summary.rows, enough: summary.enough, contextRows: s.context_messages, contextLength: s.context_messages.length, marker: summary.marker, unidentified: summary.enough ? [] : summary.unidentified };
+                this.pageContexts.set(index, context);
+            }
+            let stateRows;
+            let effectiveSeenId = null;
+            let cacheable = true;
+            let appended = null;
+            if (typeof s.state_db_seen_id === 'number' && str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() !== 'subagent') {
+                const read = stateDbSessionTailRead(dbPath, s.session_id, s.state_db_seen_id, { lineage: s.state_db_lineage?.[0] === s.session_id ? s.state_db_lineage : null, unidentified: [...index.unidentified, ...context.unidentified] });
+                if (!read.ok)
+                    cacheable = false;
+                const markerRows = read.anchor ? [read.anchor, ...read.rows] : read.rows;
+                if (read.ok && read.idCapable && currentStateDbSeenId(s, markerRows) !== null) {
+                    // Covered rows consume unidentified local copies before a new duplicate. Any such match needs the full snapshot.
+                    const ambiguous = read.requiresFullRead === true;
+                    if (!ambiguous) {
+                        const includeUids = read.rows.some((m) => stateDbIdentityKeys(m).some((id) => id.startsWith('uid:')));
+                        const mode = includeUids ? 1 : 0;
+                        appended = appendStateDbIdentityRows(read.rows, s.state_db_seen_id, index.identities[mode], index.unidentified[mode], index.generation, includeUids);
+                        stateRows = read.rows;
+                        effectiveSeenId = s.state_db_seen_id;
+                    }
+                }
+            }
+            if (appended === null) {
+                stateRows = this.stateDbRows(s);
+                effectiveSeenId = currentStateDbSeenId(s, stateRows);
+                appended = this.mergedTranscript(s, s.messages, stateRows).slice(s.messages.length);
+            }
+            let tail = [...s.messages.slice(prefixEnd), ...appended];
+            if (pending)
+                tail = withPendingUserTurn(tail, { ...pending, localCount: s.messages.length - prefixEnd });
+            if (journaled)
+                tail = withoutRunningTurnOutput(tail, { ...journaled, localCount: s.messages.length - prefixEnd });
+            const tailIndex = new SessionPrefixIndex(tail, index.revision, index.generation, { toolCalls: index.toolCalls(prefixEnd, tail.length), baseIndex: prefixEnd, initialTurn: prefixEnd ? index.turnId(prefixEnd - 1) : 'legacy:start', timestampFloor: index.summary(prefixEnd).maxTimestamp, todoFloor: index.summary(prefixEnd).maxTodoTimestamp, parent: { index, end: prefixEnd } });
+            const enoughContext = !streaming && (context.enough || sanitizeMessagesForApi(context.marker ? context.local : mergeSessionMessagesAppendOnly(context.local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: effectiveSeenId, stateDbGeneration: index.generation }).filter((m) => !s.active_stream_id || m._turn_id !== s.active_stream_id), { maxMessages: 4 }).length >= 4);
+            const owners = new Map();
+            const sources = (ids, profile) => {
+                const ownerKey = JSON.stringify([ids, profile]);
+                const existing = owners.get(ownerKey);
+                if (existing)
+                    return existing;
+                const result = this.stateDbSources(ids, profile);
+                if (result)
+                    owners.set(ownerKey, result);
+                return result;
+            };
+            cached = { key, tail, index: tailIndex, enoughContext, sources, contextRows: s.context_messages, contextLength: s.context_messages.length,
+                summary: { total: prefixEnd + tail.length, last: Math.max(index.summary(prefixEnd).maxTimestamp, tailIndex.summary().maxTimestamp), todo: tailIndex.summary().todo ?? index.summary(prefixEnd).todo, compression: index.compressionReference(s, prefixEnd, tailIndex) } };
+            if (cacheable)
+                this.pageTails.set(index, cached);
+        }
+        const { tail, index: tailIndex } = cached;
+        const total = prefixEnd + tail.length;
+        const end = before === null ? total : Math.max(0, Math.min(before, total));
+        const readRange = (start, stop) => start >= prefixEnd ? tail.slice(start - prefixEnd, stop - prefixEnd) : [...s.messages.slice(start, Math.min(stop, prefixEnd)), ...(stop > prefixEnd ? tail.slice(0, stop - prefixEnd) : [])];
+        const idAt = (at) => at < prefixEnd ? index.turnId(at) : tailIndex.turnId(at);
+        const turnSpan = (id) => {
+            const prefix = index.turns.get(id), suffix = tailIndex.turns.get(id);
+            return { first: Math.min(prefix && prefix.first < prefixEnd ? prefix.first : total, suffix?.first ?? total), last: Math.max(prefix && prefix.first < prefixEnd ? Math.min(prefix.last, prefixEnd - 1) : -1, suffix?.last ?? -1) + 1 };
+        };
+        const spanAt = (at) => {
+            const id = idAt(at), own = turnSpan(id);
+            const dependencies = [index.dependencies.get(id), tailIndex.dependencies.get(id)];
+            const first = Math.min(...dependencies.map((span) => span?.first ?? total));
+            const last = Math.max(...dependencies.map((span) => span ? Math.min(span.last, total - 1) : -1));
+            return { first: Math.min(own.first, first), last: Math.max(own.last, last + 1) };
+        };
+        // A notification can refer to a parent turn outside this page. Read that indexed turn, never the whole prefix.
+        const reviewTurns = new Map();
+        const reviewRows = (id) => {
+            let rows = reviewTurns.get(id);
+            if (!rows) {
+                const span = turnSpan(id);
+                rows = span.first < span.last ? withTurnIds(readRange(span.first, span.last), span.first, span.first ? idAt(span.first - 1) : 'legacy:start').filter((row) => row._turn_id === id) : [];
+                reviewTurns.set(id, rows);
+            }
+            return rows;
+        };
+        const refs = { get: (ref) => index.refCountBefore(ref, prefixEnd) + (tailIndex.refCounts.get(ref) ?? 0) };
+        if (cached.newestReply === undefined) {
+            let newestReply = null;
+            const excluded = new Set(s.active_stream_id ? [s.active_stream_id] : []);
+            selection: for (const owner of [tailIndex, index])
+                for (const candidate of owner.replyTurns(owner === index ? prefixEnd : total, excluded)) {
+                    const span = turnSpan(idAt(candidate)), rows = readRange(span.first, span.last);
+                    const derived = await this.deriveRange(s, rows, span.first, span.first ? idAt(span.first - 1) : 'legacy:start', Boolean(journaled), refs, index.toolCalls(span.first, rows.length), reviewRows);
+                    const newest = newestSettledReply(derived, s.active_stream_id, span.first);
+                    if (newest !== null) {
+                        newestReply = newest;
+                        break selection;
+                    }
+                }
+            cached.newestReply = newestReply;
+        }
+        let start = end ? spanAt(Math.max(0, end - limit)).first : 0;
+        if (pending && before === null)
+            start = Math.min(start, prefixEnd);
+        let stop = end ? spanAt(end - 1).last : 0;
+        // Stamped ids can recur non-contiguously. Include every row of a selected turn, as the full derivation does.
+        let derived = [];
+        for (;;) {
+            for (let at = start; at < stop; at += 1) {
+                const span = spanAt(at);
+                if (span.first < start) {
+                    start = span.first;
+                    at = start - 1;
+                }
+                stop = Math.max(stop, span.last);
+            }
+            const rows = readRange(start, stop);
+            const calls = index.toolCalls(start, rows.length);
+            derived = (await this.deriveRange(s, rows, start, start ? idAt(start - 1) : 'legacy:start', Boolean(journaled), refs, calls, reviewRows));
+            const [page, relative] = messageWindowForDisplay(derived, limit, end - start);
+            if (relative > 0 || start === 0 || page.filter((m) => messageCountsAsRenderable(m)).length >= limit) {
+                let offset = start + relative;
+                let messages = page;
+                if (pending && before === null) {
+                    const at = derived.findIndex((m) => m.role === 'user' && m._active_turn_token === pending.activeTurnToken);
+                    if (at >= 0 && start + at < offset) {
+                        messages = derived.slice(at, relative + messages.length);
+                        offset = start + at;
+                    }
+                }
+                return { messages, offset, newestReply: cached.newestReply, ...cached.summary, enoughContext: cached.enoughContext, sources: cached.sources };
+            }
+            start = spanAt(Math.max(0, start - Math.max(limit, stop - start))).first;
+        }
     }
     /** Python `_handle_session_get` on the WebUI sidecar (state.db merge pending). */
-    detail(sid, query) {
+    async detail(sid, query) {
         if (!sid)
             throw new HttpFailure(400, 'session_id is required');
+        sid = this.resolveSessionId(sid);
         const loadMessages = (query.messages ?? '1') !== '0';
         const msgLimit = parseMsgLimit(query.msg_limit ?? null);
         const msgBeforeRaw = query.msg_before;
         const msgBefore = msgBeforeRaw ? (Number.isInteger(Number(msgBeforeRaw)) ? Number(msgBeforeRaw) : null) : null;
         let s;
         try {
-            s = this.store.get(sid, { metadataOnly: !loadMessages });
+            s = (await this.store.get(sid, { metadataOnly: !loadMessages }));
         }
         catch {
-            return this.foreignSessionDetail(sid);
+            return (await this.foreignSessionDetail(sid, loadMessages, msgLimit, msgBefore));
         }
-        const revisionBefore = this.loadRevision(s);
+        const revisionBefore = (await this.loadRevision(s));
         if (!this.visibleToActiveProfile(s.profile)) {
             if (s.profile)
                 throw new HttpFailure(409, 'Session belongs to a different profile', { code: 'session_profile_mismatch', session_id: sid, profile: s.profile });
             throw new HttpFailure(404, 'Session not found');
         }
-        this.clearStaleStreamState(s);
-        const journaled = loadMessages ? this.journaledActiveTurn(s) : null;
-        let transcript = loadMessages ? this.mergedTranscript(s) : [];
+        await this.clearStaleStreamState(s);
+        const journaled = loadMessages ? (await this.journaledActiveTurn(s)) : null;
         const pending = loadMessages ? this.pendingTurn(s) : null;
-        if (pending)
+        const prefix = loadMessages && msgLimit !== null ? this.prefixIndex(s, revisionBefore) : null;
+        const limited = prefix && msgLimit !== null ? (await this.limitedDetail(s, prefix, msgLimit, msgBefore, pending, journaled)) : null;
+        const stateRows = loadMessages && !limited ? this.stateDbRows(s) : [];
+        let transcript = loadMessages && !limited ? this.mergedTranscript(s, s.messages, stateRows) : [];
+        if (pending && !limited)
             transcript = withPendingUserTurn(transcript, pending);
-        if (journaled)
+        if (journaled && !limited)
             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 ? 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;
-        let summaryLast = null;
+        const all = loadMessages && !limited ? (await this.backgroundLinked(s, hydrateAnchorActivityScenes(withToolCallOutcomes((await this.backgroundUpdates(s, 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 = limited?.messages ?? [];
+        let offset = limited?.offset ?? 0;
+        let summaryCount = limited?.total ?? null;
+        let summaryLast = limited?.last ?? null;
         if (loadMessages) {
-            ;
-            [truncated, offset] = messageWindowForDisplay(all, msgLimit, msgBefore);
+            if (!limited)
+                [truncated, offset] = messageWindowForDisplay(all, msgLimit, msgBefore);
             // TAL-368: a tail window starts no later than the running turn's prompt, so a turn whose output stays in the
             // transcript (no journal to replay it) keeps its prompt; older pages end before it, so it is never sent twice.
             // ponytail: the window grows with that turn's persisted rows; clip the turn instead if degraded runs get long.
@@ -522,7 +970,7 @@ export class SessionService {
                 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);
+            truncated = withBodyExcerpts(withDisplayMedia(truncated, (await this.mediaProjector(s))), s.active_stream_id, limited ? limited.newestReply : newestSettledReply(all, s.active_stream_id), offset);
             if (msgLimit !== null)
                 truncated = messagesForLimitedPayload(truncated);
         }
@@ -530,10 +978,10 @@ export class SessionService {
             summaryCount = s.metadataMessageCount ?? s.messages.length;
             summaryLast = lastMessageTimestamp(s.messages) ?? 0;
         }
-        const windowed = loadMessages && msgLimit !== null && (msgBefore !== null || truncated.length < all.length);
+        const windowed = loadMessages && msgLimit !== null && (msgBefore !== null || truncated.length < (limited?.total ?? all.length));
         let toolCalls = loadMessages ? s.tool_calls : [];
         if (windowed)
-            toolCalls = toolCallsForMessageWindow(toolCalls, offset, truncated.length);
+            toolCalls = prefix ? prefix.toolCalls(offset, truncated.length, true) : toolCallsForMessageWindow(toolCalls, offset, truncated.length);
         const mergedCount = summaryCount ?? all.length;
         let mergedLast = summaryLast ?? 0;
         if (summaryLast === null && all.length) {
@@ -541,7 +989,7 @@ export class SessionService {
         }
         const activeStreamIds = this.deps.runtime.activeStreamIds;
         const raw = {
-            ...s.compact({ includeRuntime: true, activeStreamIds, contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }),
+            ...s.compact({ ...(prefix ? { transcriptSummary: prefix.summary() } : {}), includeRuntime: true, activeStreamIds, contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }),
             messages: truncated,
             message_count: mergedCount,
             tool_calls: toolCalls,
@@ -555,10 +1003,12 @@ export class SessionService {
         };
         if (loadMessages)
             raw.transcript_seq = journaled ? { stream_id: journaled.turnId, seq: 0 } : null;
-        if (loadMessages)
+        if (limited)
+            attachTodoSnapshot(raw, limited.todo, s.extra[UNSETTLED_TODO_KEY]);
+        else if (loadMessages)
             attachTodoState(raw, all, s.extra[UNSETTLED_TODO_KEY]);
         if (loadMessages)
-            raw.compression_reference = compressionReference(s, all);
+            raw.compression_reference = limited ? limited.compression : 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);
@@ -567,25 +1017,66 @@ export class SessionService {
         raw._messages_truncated = isTruncated;
         raw._messages_offset = offset;
         raw._msg_limit_max = MAX_MSG_LIMIT;
-        const revisionAfter = this.loadRevision(s);
+        const revisionAfter = (await this.loadRevision(s));
         raw._load_revision = revisionBefore !== null && revisionBefore === revisionAfter ? hashRevision(revisionBefore) : `unstable-${randomUUID().replace(/-/g, '')}`;
-        raw.read_only = this.isReadOnly(s);
+        Object.assign(raw, withOwnerLocks([raw], limited?.sources ?? this.stateDbSources)[0]);
         raw.assistant_name = this.assistantName(s);
-        raw.workspace_name = this.workspaceNames()(s);
+        raw.workspace_name = (await this.workspaceNames([s]))(s);
+        raw.branched_from = (await this.branchedFrom(s));
         withSessionWireFlags(raw, activeStreamIds);
+        // A metadata-only read lacks the history the gate counts, so it carries no flag.
+        if (loadMessages)
+            raw.can_compress = limited ? raw.read_only !== true && !isClaudeCodeSessionId(s.session_id) && (!s.active_stream_id || this.compactionWaiters.has(s.active_stream_id)) && limited.enoughContext : this.canCompress(s, raw.read_only === true, stateRows);
+        raw.confirms_deep_truncate = true;
         raw.pending_steers = raw.active_stream_id ? (this.deps.runtime.pendingSteers?.(str(raw.active_stream_id)) ?? []) : [];
-        return redactSessionData(raw, this.deps.redactEnabled());
+        // TAL-1006: the compression a client shows on load: the running manual job's, else the live run's open span.
+        const job = this.compressionJobs.get(s.session_id);
+        raw.run_status = this.currentRunStatus(s.session_id, str(raw.active_stream_id) || null);
+        raw.compression_started_at = job?.status === 'running' ? job.started_at : raw.active_stream_id ? (this.deps.runtime.compressionStartedAt?.(str(raw.active_stream_id)) ?? null) : null;
+        raw.automatic_turns_held = (await this.deps.runtime.automaticTurnsHeld?.(s.session_id)) ?? false;
+        raw.notices = this.deps.runtime.sessionNotices?.(s.session_id) ?? [];
+        raw.goal = this.deps.runtime.sessionGoal?.(s.session_id) ?? null;
+        const publicRow = redactSessionData(raw, this.deps.redactEnabled());
+        return this.owner ? await this.owner.project(publicRow, msgLimit, msgBefore, loadMessages) : publicRow;
+    }
+    /**
+     * TAL-454: the chat `/branch` copied, while it still loads (archived included). A compression continuation is also a
+     * fork of its parent but not a branch, so it links nowhere.
+     */
+    async branchedFrom(s) {
+        const parentId = s.parent_session_id;
+        if (!parentId || str(s.session_source).trim().toLowerCase() !== 'fork' || s.compression_recovery_source_session_id)
+            return null;
+        let title;
+        try {
+            const parent = (await this.store.get(parentId, { metadataOnly: true, promote: false, cacheOnMiss: false }));
+            if (!this.visibleToActiveProfile(parent.profile))
+                return null;
+            title = parent.title;
+        }
+        catch {
+            // A read-only foreign parent (a cron run) has no sidecar and opens from the active profile's state.db while it
+            // has transcript rows and is not a deleted chat (`claimOrSynthesizeCliSession`'s `was_webui` and `no_foreign_state`).
+            const dbPath = this.stateDbPath(null);
+            const row = stateDbSessionRow(dbPath, parentId);
+            if (!row || (await this.store.wasDeleted(parentId)) || (await this.indexMarksWasWebui(parentId)))
+                return null;
+            if (!stateDbSessionMessages(dbPath, parentId, { stitch: true }).length)
+                return null;
+            title = row.title;
+        }
+        return { session_id: parentId, title: str(redactText(str(title) || 'Untitled', this.deps.redactEnabled())) };
     }
     /**
      * TAL-316: the active run whose journal can replay its output from the start. The detail then leaves that output to the
      * replay; with no active run, no identifiable prompt, or no complete journal, it returns the persisted transcript unchanged.
      */
-    journaledActiveTurn(s) {
+    async journaledActiveTurn(s) {
         const turnId = str(s.active_stream_id).trim();
         const activeTurnToken = buildActiveTurnToken(turnId, s.pending_started_at);
         if (!turnId || !activeTurnToken || this.deps.runtime.journalDegraded(turnId))
             return null;
-        const summary = this.deps.journal?.findRunSummary(turnId);
+        const summary = (await this.deps.journal?.findRunSummary(turnId));
         if (summary?.session_id !== s.session_id || summary.journal_pruned)
             return null;
         return { turnId, startedAt: Number(s.pending_started_at), activeTurnToken };
@@ -601,8 +1092,9 @@ export class SessionService {
         return { turnId, startedAt, activeTurnToken, localCount: s.messages.length, prompt: pendingUserRow(text, s.pending_attachments, startedAt, s.pending_user_source || 'webui', turnId) };
     }
     /** A session without a sidecar, synthesized from state.db for this profile; 404/409 like the detail. */
-    foreignSession(sid) {
-        const meta = this.lookupCliMeta(sid);
+    async foreignSession(sid) {
+        sid = this.resolveSessionId(sid);
+        const meta = (await this.lookupCliMeta(sid));
         const profile = str(meta?.profile) || null;
         const profileAgnostic = str(meta?.source_tag || meta?.raw_source).trim().toLowerCase() === 'claude_code';
         if (!profileAgnostic && !this.visibleToActiveProfile(profile)) {
@@ -610,16 +1102,19 @@ export class SessionService {
                 throw new HttpFailure(409, 'Session belongs to a different profile', { code: 'session_profile_mismatch', session_id: sid, profile });
             throw new HttpFailure(404, 'Session not found');
         }
-        const { session: synth, reason } = this.claimOrSynthesizeCliSession(sid, meta);
+        const { session: synth, reason } = (await this.claimOrSynthesizeCliSession(sid, meta));
         if (!synth || reason === 'was_webui')
             throw new HttpFailure(404, 'Session not found');
         return { synth, meta };
     }
     /** Python `_handle_session_get` without a sidecar: the state.db transcript as a (read-only or claimable) foreign stub. */
-    foreignSessionDetail(sid) {
-        const { synth, meta } = this.foreignSession(sid);
+    foreignMessages(messages, session) {
+        return hydrateAnchorActivityScenes(withToolCallOutcomes(withMarkerKinds(withTurnIds(messages), session), [], null), {});
+    }
+    async foreignSessionDetail(sid, loadMessages, msgLimit, msgBefore) {
+        const { synth, meta } = (await 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(withMarkerKinds(withTurnIds(synth.messages)), [], null), {});
+        const msgs = this.foreignMessages(synth.messages, synth);
         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,
@@ -627,14 +1122,15 @@ 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),
+            assistant_name: this.assistantName(synth), workspace_name: (await this.workspaceNames([synth]))(synth), confirms_deep_truncate: true,
         };
         attachTodoState(sess, msgs);
-        const merged = withSessionWireFlags(meta ? mergeCliSidebarMetadata(sess, meta) : sess, this.deps.runtime.activeStreamIds);
-        return redactSessionData(merged, this.deps.redactEnabled());
+        const merged = withSessionWireFlags(withOwnerLocks([meta ? mergeCliSidebarMetadata(sess, meta) : sess], this.stateDbSources)[0], this.deps.runtime.activeStreamIds);
+        const publicRow = redactSessionData(merged, this.deps.redactEnabled());
+        return this.owner ? await this.owner.project(publicRow, msgLimit, msgBefore, loadMessages) : publicRow;
     }
     /** Clear persisted streaming flags when no live stream backs them (Python `_clear_stale_stream_state`). */
-    clearStaleStreamState(session) {
+    async clearStaleStreamState(session) {
         const streamId = session.active_stream_id;
         if (!streamId)
             return false;
@@ -645,9 +1141,12 @@ export class SessionService {
         const pendingAge = session.pending_started_at ? this.deps.now() - session.pending_started_at : null;
         if (session.hasPendingPrompt && pendingAge !== null && pendingAge < 30)
             return false;
+        // Reading a display-only session must not settle the previous Talaria worker's transcript.
+        if ((await this.isReadOnly(session)))
+            return false;
         let target = session;
         if (session.loadedMetadataOnly) {
-            const full = this.store.load(session.session_id);
+            const full = (await this.store.load(session.session_id));
             if (!full)
                 return false;
             target = full;
@@ -665,7 +1164,7 @@ export class SessionService {
         // 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 events = (await 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];
@@ -674,7 +1173,8 @@ export class SessionService {
         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;
+        const runRows = read.rows.filter((m) => Number(m.timestamp) >= runStart);
+        const ownRows = target.hasPendingPrompt ? runStateDbRows(runRows, 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) {
@@ -684,16 +1184,16 @@ export class SessionService {
                 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 prompt = attachedFilesPrompt(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 }]);
+            target.context_messages = this.unsettledTurnContext({ previousContext, prompt, msgText: pendingText, streamedText: streamed, historyLength: previousContext.length, stateRows: runRows }) ?? dedupeContext([...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 });
+                target.messages.push({ role: 'assistant', content: '**Interrupted:** The reply was interrupted before it could be saved.', _terminal_state: 'interrupted', 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) });
+            this.settleStateDb(target, { turnId, previousContext, agentRows: ownRows, startId: stateDbSeenId(before) ?? (read.idCapable ? 0 : null), read });
         }
         target.active_stream_id = null;
         target.pending_user_message = null;
@@ -701,7 +1201,7 @@ export class SessionService {
         target.pending_started_at = null;
         target.pending_user_source = null;
         try {
-            this.store.save(target, { touchUpdatedAt: false });
+            (await this.store.save(target, { touchUpdatedAt: false }));
         }
         catch {
             return false;
@@ -712,31 +1212,52 @@ export class SessionService {
             session.pending_attachments = [];
             session.pending_started_at = null;
             session.pending_user_source = null;
-            this.store.touch(target);
+            await this.store.touch(target);
         }
         return true;
     }
     // ── list / search ────────────────────────────────────────────────────────
-    list(params) {
+    /** Expand saved aliases in one worker query independently of the bounded native sidebar window. */
+    async persistedAliasMetadata(rows, existing = []) {
+        const profile = this.deps.activeProfile();
+        const represented = new Set(existing.flatMap((row) => [...sessionLineageIds(row)]));
+        const ids = rows.filter((row) => this.deps.profilesMatch(str(row.profile) || null, profile) && !isClaudeCodeSessionId(str(row.session_id)) && !represented.has(str(row.session_id))).map((row) => str(row.session_id));
+        if (!ids.length)
+            return { rows: existing };
+        const extra = await this.deps.cliSessions(profile, { sourceFilter: null, sessionIds: ids });
+        return { rows: [...new Map([...existing, ...extra.rows].map((row) => [str(row.session_id), row])).values()], storage: extra.storage };
+    }
+    async list(params) {
         const activeProfile = this.deps.activeProfile();
+        const webuiRows = (await allSessions(this.store, { sidebarMetadataOnly: true }));
         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 claudeCodeRows = params.showCliSessions && params.showClaudeCodeSessions ? this.claudeCodeRows() : [];
-        const cliRows = cliRead ? [...cliRead.rows, ...claudeCodeRows] : undefined;
+        const cliRead = wantState ? await this.deps.cliSessions(activeProfile, { sourceFilter: params.sourceFilter ?? null }) : undefined;
+        const claudeCodeRows = params.showCliSessions && params.showClaudeCodeSessions ? (await this.claudeCodeRows()) : [];
+        let 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 });
-        return sessionListResponse(payload, this.deps.runtime, this.deps.redactEnabled(), this.deps.now(), this.workspaceNames());
-    }
-    search(q, opts) {
+        let agentStorage = cliRead?.storage;
+        if (cliRows) {
+            const expanded = await this.persistedAliasMetadata(webuiRows, cliRows);
+            cliRows = expanded.rows;
+            if (expanded.storage && (expanded.storage.state === 'corrupt' || agentStorage?.state === 'ok'))
+                agentStorage = expanded.storage;
+        }
+        const lookups = await this.listStateDbLookups(webuiRows, (cliRows ?? []).map((r) => str(r.session_id)));
+        const payload = (await buildSessionListPayload(this.store, { ...params, ...(cliRows ? { cliRows } : {}), ...(truncatedSources ? { truncatedSources } : {}), ...(agentStorage ? { agentStorage } : {}), gatewayIdentity, ...lookups, webuiRows, activeProfile, isolatedProfileMode: this.deps.isolatedProfileMode(), profilesMatch: this.deps.profilesMatch }));
+        return sessionListResponse(payload, this.deps.runtime, this.deps.redactEnabled(), this.deps.now(), await this.workspaceNames([...payload.sessions, ...payload.sidebar_reference_sessions]));
+    }
+    async search(q, opts) {
         const activeProfile = this.deps.activeProfile();
-        let sessions = allSessions(this.store);
+        let sessions = (await allSessions(this.store));
         if (!opts.allProfiles)
             sessions = sessions.filter((r) => this.deps.profilesMatch(str(r.profile) || null, activeProfile));
+        const metadata = await this.persistedAliasMetadata(sessions);
+        sessions = reconcileLocalSessionRows(sessions, metadata.rows, this.deps.profilesMatch);
         sessions = withOwnerLocks(sessions, this.stateDbSources);
         const redact = this.deps.redactEnabled();
-        const workspaceName = this.workspaceNames();
+        const workspaceName = await this.workspaceNames(sessions);
         const redactRow = (item) => {
             withSessionWireFlags(item, this.deps.runtime.activeStreamIds);
             item.workspace_name = workspaceName(item);
@@ -751,17 +1272,16 @@ export class SessionService {
         if (!query)
             return { sessions: sessions.map((s) => redactRow({ ...s })), all_profiles: opts.allProfiles, active_profile: activeProfile };
         const terms = sessionSearchTerms(query);
+        const matches = opts.content ? await this.store.searchMessages(sessions.filter((s) => !sessionSearchMatches(str(s.title), terms)).map((s) => str(s.session_id)), terms, opts.depth) : new Map();
         const results = [];
         for (const s of sessions) {
             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), terms, opts.depth);
+            const hit = matches.get(str(s.session_id));
             if (hit)
-                results.push(redactRow({ ...s, ...hit }));
+                results.push(redactRow({ ...s, ...this.contentMatch(hit.text, terms) }));
         }
         return { sessions: results, query, count: results.length, all_profiles: opts.allProfiles, active_profile: activeProfile };
     }
@@ -770,8 +1290,8 @@ export class SessionService {
      * 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;
+    async sidebarSearch(q, params, opts) {
+        let rows = (await this.list(params)).body.sessions;
         if (opts.projectId === 'none')
             rows = rows.filter((r) => !r.project_id);
         else if (opts.projectId)
@@ -781,46 +1301,35 @@ export class SessionService {
         if (!query)
             return { ...base, sessions: rows };
         const terms = sessionSearchTerms(query);
+        const metadataMatch = (row) => ['workspace', 'workspace_name', 'model', 'model_provider', 'profile', 'source_label'].some((k) => sessionSearchMatches(str(row[k]), terms));
+        const matches = opts.content ? await this.store.searchMessages(rows.filter((row) => !sessionSearchMatches(str(row.title), terms) && !metadataMatch(row)).map((row) => str(row.session_id)), terms, opts.depth) : new Map();
         const results = [];
         for (const row of rows) {
             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) => sessionSearchMatches(str(row[k]), terms)))
+            else if (metadataMatch(row))
                 results.push({ ...row, match_type: 'metadata' });
-            else if (opts.content) {
-                const hit = this.contentMatch(str(row.session_id), terms, opts.depth);
+            else {
+                const hit = matches.get(str(row.session_id));
                 if (hit)
-                    results.push({ ...row, ...hit });
+                    results.push({ ...row, ...this.contentMatch(hit.text, terms) });
             }
         }
         return { ...base, sessions: results, query, count: results.length };
     }
     /** 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 });
-        }
-        catch {
-            return null;
-        }
-        for (const m of depth ? sess.messages.slice(0, depth) : sess.messages) {
-            const c = sessionSearchMessageText(m);
-            if (!sessionSearchMatches(c, terms))
-                continue;
-            const item = { match_type: 'content' };
-            const preview = sessionSearchPreview(c, terms);
-            if (preview)
-                item.match_preview = redactText(preview, this.deps.redactEnabled());
-            return item;
-        }
-        return null;
+    contentMatch(text, terms) {
+        const item = { match_type: 'content' };
+        const preview = sessionSearchPreview(text, terms);
+        if (preview)
+            item.match_preview = redactText(preview, this.deps.redactEnabled());
+        return item;
     }
     // ── status / usage ───────────────────────────────────────────────────────
-    status(sid) {
-        const s = this.get404(sid, { metadataOnly: true });
-        this.clearStaleStreamState(s);
-        const full = this.get404(sid);
+    async status(sid) {
+        const s = (await this.get404(sid, { metadataOnly: true }));
+        await this.clearStaleStreamState(s);
+        const full = (await this.get404(sid));
         const inp = Math.trunc(full.input_tokens) || 0;
         const out = Math.trunc(full.output_tokens) || 0;
         const profile = full.profile || 'default';
@@ -831,37 +1340,37 @@ export class SessionService {
         catch {
             hermesHome = '';
         }
-        const { is_streaming: streaming, active_stream_id: live, read_only: readOnly, active_turn_origin: origin } = this.wireRow(full);
+        const { is_streaming: streaming, active_stream_id: live, read_only: readOnly, read_only_reason: readOnlyReason, active_turn_origin: origin } = (await 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, active_turn_origin: origin, 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, read_only_reason: readOnlyReason,
             input_tokens: inp, output_tokens: out, total_tokens: inp + out, estimated_cost: full.estimated_cost,
         };
     }
-    usage(sid) {
-        const s = this.get404(sid);
+    async usage(sid) {
+        const s = (await this.get404(sid));
         const inp = Math.trunc(s.input_tokens) || 0;
         const out = Math.trunc(s.output_tokens) || 0;
         return { input_tokens: inp, output_tokens: out, total_tokens: inp + out, estimated_cost: s.estimated_cost, model: s.model };
     }
     // ── creation ─────────────────────────────────────────────────────────────
-    resolveNewSessionWorkspace(body, visiblePrevSessionId, profile) {
+    async resolveNewSessionWorkspace(body, visiblePrevSessionId, profile) {
         const candidate = body.workspace;
         if (!candidate)
             return null;
         const value = str(candidate);
         if (body.workspace_inherited_from_prev_session !== true || !visiblePrevSessionId)
-            return this.deps.workspaces.resolveTrusted(value, profile);
+            return (await this.deps.workspaces.resolveTrusted(value, profile));
         let previous;
         try {
-            previous = this.store.get(visiblePrevSessionId, { metadataOnly: true });
+            previous = (await this.store.get(visiblePrevSessionId, { metadataOnly: true }));
         }
         catch {
-            return this.deps.workspaces.resolveTrusted(value, profile);
+            return (await this.deps.workspaces.resolveTrusted(value, profile));
         }
         if (previous.workspace !== value)
-            return this.deps.workspaces.resolveTrusted(value, profile);
-        const [workspace] = this.deps.workspaces.resolveImplicitWithRecovery(value, (p) => this.deps.workspaces.profileDefaultWorkspaceForBoot(p), profile);
+            return (await this.deps.workspaces.resolveTrusted(value, profile));
+        const [workspace] = (await this.deps.workspaces.resolveImplicitWithRecovery(value, async (p) => (await 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. */
@@ -875,25 +1384,25 @@ export class SessionService {
         const names = toolsets.map((t) => t.trim()).filter(Boolean);
         return names.length ? names : null;
     }
-    create(body, opts = {}) {
+    async create(body, opts = {}) {
         // 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))
+        if (prevSessionId && !(await this.sessionIdVisible(prevSessionId)))
             prevSessionId = null;
         // Python: leaving a session for a new one flushes the previous session's memory in the background (W6).
         if (prevSessionId)
-            this.deps.commitSessionMemory?.(prevSessionId);
+            await this.deps.commitSessionMemory?.(prevSessionId);
         let workspace;
         try {
-            workspace = this.resolveNewSessionWorkspace(body, prevSessionId, profile);
+            workspace = (await this.resolveNewSessionWorkspace(body, prevSessionId, profile));
         }
         catch (error) {
             throw new HttpFailure(400, error.message);
         }
         const [model, provider] = this.deps.modelStateFromRequest(body.model, body.model_provider, null);
         const toolsets = this.validateToolsetsShape(body.enabled_toolsets);
-        const s = this.store.newSession({ workspace, model, modelProvider: provider, profile, projectId: typeof body.project_id === 'string' && body.project_id ? body.project_id : null, worktree: opts.worktree ?? null, enabledToolsets: toolsets });
+        const s = (await this.store.newSession({ workspace, model, modelProvider: provider, profile, projectId: typeof body.project_id === 'string' && body.project_id ? body.project_id : null, worktree: opts.worktree ?? null, enabledToolsets: toolsets }));
         if (opts.worktree)
             this.publish('session_new', s.profile, s.session_id);
         return s;
@@ -904,46 +1413,47 @@ export class SessionService {
         const title = nextTitle.trim().slice(0, 80) || 'Untitled';
         let current;
         try {
-            current = this.store.get(sid);
+            current = (await this.store.get(sid));
         }
         catch {
             throw new HttpFailure(404, 'Session not found');
         }
-        if (this.isReadOnly(current))
+        if ((await this.isReadOnly(current)))
             throw new HttpFailure(403, `Session ${sid} is read-only`);
-        await this.store.withLock(sid, () => {
+        await this.withMutationLock(sid, async () => {
             current.title = title;
             markSessionTitleGenerated(current);
-            this.store.save(current, { touchUpdatedAt: false });
+            await this.store.save(current, { touchUpdatedAt: false });
         });
-        await this.deps.syncTitle(current);
+        // An explicit regenerate is user-requested, so state.db takes it over a manual name.
+        await this.deps.syncTitle(current, true);
         this.publish(eventReason, current.profile, current.session_id);
         return current;
     }
     async rename(sid, rawTitle) {
-        const s = this.mutationTarget(sid, 'renamed');
-        await this.store.withLock(sid, () => {
+        const s = (await this.mutationTarget(sid, 'renamed'));
+        await this.withMutationLock(sid, async () => {
             applySessionTitleRename(s, rawTitle);
-            this.store.save(s);
+            await this.store.save(s);
         });
-        await this.deps.syncTitle(s);
+        await this.deps.syncTitle(s, true);
         this.publish('session_rename', s.profile, s.session_id);
-        return { session: this.wireRow(s) };
+        return { session: (await this.wireRow(s)) };
     }
     // The pin quota is counted across sessions, so the count-and-save transaction runs on one process-wide chain;
     // per-session locks alone would let two pins of different sessions both see the last free slot.
     pinChain = Promise.resolve();
     pin(sid, pinRequested) {
-        const run = this.pinChain.then(() => this.pinUnserialized(sid, pinRequested));
+        const run = this.pinChain.then(async () => (await this.pinUnserialized(sid, pinRequested)));
         this.pinChain = run.catch(() => undefined);
         return run;
     }
     async pinUnserialized(sid, pinRequested) {
-        this.rejectSubagent(sid, 'modified');
-        let s = this.get404(sid);
-        s = this.store.ensureFull(sid, s);
+        await this.rejectViewOnly(sid, 'modified');
+        let s = (await this.get404(sid));
+        s = (await this.store.ensureFull(sid, s));
         if (pinRequested && !s.pinned) {
-            const rows = allSessions(this.store);
+            const rows = (await allSessions(this.store));
             const byId = new Map(rows.filter((r) => r.session_id).map((r) => [str(r.session_id), r]));
             byId.set(s.session_id, s.compact());
             const targetLineage = lineageRootId(s.compact(), byId);
@@ -953,38 +1463,38 @@ export class SessionService {
             if (pinnedLineages.size >= limit)
                 throw new HttpFailure(400, `Up to ${limit} sessions can be pinned. Unpin one before pinning another.`);
         }
-        await this.store.withLock(sid, () => {
+        await this.withMutationLock(sid, async () => {
             s.pinned = pinRequested;
-            this.store.save(s);
-        });
+            await this.store.save(s);
+        }, { allowReadOnly: true });
         this.publish('session_pin', s.profile, s.session_id);
-        return { ok: true, session: this.wireRow(s) };
+        return { ok: true, session: (await this.wireRow(s)) };
     }
     async archive(sid, archived) {
-        this.rejectSubagent(sid, 'archived');
-        let s = this.get404(sid);
-        s = this.store.ensureFull(sid, s);
-        await this.store.withLock(sid, () => {
+        await this.rejectViewOnly(sid, 'archived');
+        let s = (await this.get404(sid));
+        s = (await this.store.ensureFull(sid, s));
+        await this.withMutationLock(sid, async () => {
             s.archived = archived;
             if (archived)
                 s.pinned = false;
-            this.store.save(s, { touchUpdatedAt: false });
-        });
+            await this.store.save(s, { touchUpdatedAt: false });
+        }, { allowReadOnly: true });
         this.publish('session_archive', s.profile, s.session_id);
-        return { ok: true, session: this.wireRow(s), ...worktreeRetainedPayload(s) };
+        return { ok: true, session: (await this.wireRow(s)), ...worktreeRetainedPayload(s) };
     }
     async move(sid, targetProjectId) {
-        const s = this.mutationTarget(sid, 'moved');
+        const s = (await this.mutationTarget(sid, 'moved'));
         if (targetProjectId) {
             const sessionProfile = s.profile || this.deps.activeProfile();
-            const target = this.deps.projects.load().find((p) => p.project_id === targetProjectId);
+            const target = (await this.deps.projects.load()).find((p) => p.project_id === targetProjectId);
             if (!target || !this.deps.profilesMatch(target.profile ?? null, sessionProfile))
                 throw new HttpFailure(404, 'Project not found');
         }
         try {
-            await this.store.withLock(sid, () => {
+            await this.withMutationLock(sid, async () => {
                 s.project_id = targetProjectId;
-                this.store.save(s);
+                await this.store.save(s);
             }, { timeoutMs: 5000 });
         }
         catch (error) {
@@ -993,67 +1503,108 @@ export class SessionService {
             throw error;
         }
         this.publish('session_move', s.profile, s.session_id);
-        return { ok: true, session: this.wireRow(s) };
-    }
-    async update(sid, body) {
-        const s = this.mutationTarget(sid, 'updated');
-        const oldWs = s.workspace;
-        const oldModel = s.model;
-        const oldProvider = s.model_provider;
-        let newWs;
+        return { ok: true, session: (await this.wireRow(s)) };
+    }
+    modelConfirmationKey = randomUUID();
+    async confirmModelSwitch(s, model, provider, token, retry = false) {
+        const profile = s.profile ?? this.deps.activeProfile();
+        const home = this.deps.profileHome(profile);
+        const context = contextUsage(s).context_used_tokens;
+        const messages = this.modelContext(s);
+        const before = JSON.stringify([s.model, s.model_provider, context, s.context_length, messages]);
+        let decision;
         try {
-            newWs = this.deps.workspaces.resolveTrusted(typeof body.workspace === 'string' ? body.workspace : s.workspace, s.profile);
+            const sidecar = this.deps.sidecar?.();
+            if (!sidecar)
+                throw new Error('Agent sidecar is unavailable');
+            decision = await sidecar.call('models.selection_warnings', { profile_home: home, session_id: s.session_id, model, provider, current_model: s.model, current_provider: s.model_provider, context_tokens: context, messages });
         }
         catch (error) {
-            throw new HttpFailure(400, error.message);
+            throw new HttpFailure(503, `Cannot check model selection warnings: ${error.message}`);
         }
-        await this.store.withLock(sid, async () => {
+        if (before !== JSON.stringify([s.model, s.model_provider, contextUsage(s).context_used_tokens, s.context_length, this.modelContext(s)])) {
+            if (retry)
+                throw new HttpFailure(503, 'The session changed while checking model warnings. Try the selection again.');
+            return this.confirmModelSwitch(s, model, provider, null, true);
+        }
+        if (!decision.warnings.length)
+            return;
+        const signature = JSON.stringify([profile, home, s.session_id, s.model, s.model_provider, model, provider, context, s.context_length, messages, decision]);
+        const confirmToken = createHmac('sha256', this.modelConfirmationKey).update(signature).digest('hex');
+        if (token !== confirmToken)
+            throw new HttpFailure(409, decision.warnings.map((w) => w.message).join('\n\n'), { type: 'model_confirmation_required', warnings: decision.warnings, confirm_token: confirmToken });
+    }
+    async update(sid, body) {
+        let s = (await this.mutationTarget(sid, 'updated'));
+        let oldWs = s.workspace;
+        let newWs = oldWs;
+        await this.withMutationLock(sid, async () => {
+            s = await this.mutationTarget(sid, 'updated');
+            oldWs = s.workspace;
+            try {
+                newWs = await this.deps.workspaces.resolveTrusted(typeof body.workspace === 'string' ? body.workspace : s.workspace, s.profile);
+            }
+            catch (error) {
+                throw new HttpFailure(400, error.message);
+            }
+            const oldModel = s.model;
+            const oldProvider = s.model_provider;
+            const hasModel = 'model' in body || 'model_provider' in body;
+            const [model, provider] = hasModel ? this.deps.modelStateFromRequest('model' in body ? body.model : s.model, 'model_provider' in body ? body.model_provider : undefined, s.model_provider) : [s.model, s.model_provider];
+            const nextModel = model ?? s.model;
+            const changed = hasModel && (str(oldModel) !== str(nextModel) || str(oldProvider) !== str(provider));
+            const contextLength = changed ? (this.deps.resolveContextLength ? await this.deps.resolveContextLength(nextModel, provider, s.profile) : this.deps.contextLengthFor(nextModel, provider)) : s.context_length;
+            if (changed)
+                await this.confirmModelSwitch(s, nextModel ?? '', provider, body.confirm_token);
+            this.assertWritable(s);
             s.workspace = newWs;
-            if ('model' in body || 'model_provider' in body) {
-                const [model, provider] = this.deps.modelStateFromRequest('model' in body ? body.model : s.model, 'model_provider' in body ? body.model_provider : undefined, s.model_provider);
-                if (model !== null)
-                    s.model = model;
+            if (hasModel) {
+                s.model = nextModel;
                 s.model_provider = provider;
-                if (str(oldModel) !== str(s.model) || str(oldProvider) !== str(s.model_provider)) {
-                    s.context_length = this.deps.resolveContextLength ? await this.deps.resolveContextLength(s.model, s.model_provider, s.profile) : this.deps.contextLengthFor(s.model, s.model_provider);
-                    s.threshold_tokens = 0;
-                    s.last_prompt_tokens = 0;
-                    this.deps.runtime.evictAgent(sid);
+                if (changed) {
+                    s.context_length = contextLength;
+                    forgetContextFigures(s);
+                    await this.deps.runtime.evictAgent(sid);
                 }
             }
-            this.store.save(s);
+            await this.store.save(s);
         });
         if (str(oldWs) !== str(newWs))
             this.deps.runtime.closeTerminal(sid);
-        this.deps.workspaces.setLastWorkspace(newWs, s.profile);
-        return { session: this.publicSession(s) };
+        await this.deps.workspaces.setLastWorkspace(newWs, s.profile);
+        return { session: (await this.publicSession(s)) };
     }
     async setToolsets(sid, toolsets) {
-        this.rejectSubagent(sid, 'modified');
+        await this.rejectViewOnly(sid, 'modified');
         const cleaned = this.validateToolsetsShape(toolsets);
-        const s = this.mutationTarget(sid, 'modified');
-        await this.store.withLock(sid, () => {
+        const s = (await this.mutationTarget(sid, 'modified'));
+        await this.withMutationLock(sid, async () => {
             s.enabled_toolsets = cleaned;
-            this.store.save(s);
+            await this.store.save(s);
         });
         return { ok: true, enabled_toolsets: s.enabled_toolsets };
     }
     /** Python `/api/personality/set` persistence: the name only; the prompt is resolved by the caller. */
     async setPersonality(sid, name) {
-        this.rejectSubagent(sid, 'modified');
-        const s = this.mutationTarget(sid, 'modified');
-        await this.store.withLock(sid, () => {
+        await this.rejectViewOnly(sid, 'modified');
+        const s = (await this.mutationTarget(sid, 'modified'));
+        await this.withMutationLock(sid, async () => {
             s.personality = name;
-            this.store.save(s);
+            await this.store.save(s);
         });
         return typeof s.personality === 'string' ? s.personality : null;
     }
     // ── transcript mutations ─────────────────────────────────────────────────
-    async truncate(sid, keepRaw) {
-        this.rejectSubagent(sid, 'modified');
+    /**
+     * TAL-929: under a `hold`, a cut that discards more than one user turn changes nothing and answers with its counts,
+     * unless `confirmToken` is the token of the rows it would remove now: a transcript that changed since asks again.
+     * Without one (a released App, which asked on the device) the cut proceeds as before.
+     */
+    async truncate(sid, keepRaw, hold = null) {
+        await this.rejectViewOnly(sid, 'modified');
         if (keepRaw === null || keepRaw === undefined)
             throw new HttpFailure(400, 'Missing required field(s): keep_count');
-        const s = this.mutationTarget(sid, 'modified');
+        const s = (await this.mutationTarget(sid, 'modified'));
         // Python `int(body["keep_count"])`: a float truncates, a non-integer string is rejected.
         let keep;
         if (typeof keepRaw === 'number')
@@ -1066,26 +1617,61 @@ export class SessionService {
             throw new HttpFailure(400, 'keep_count must be an integer');
         if (keep < 0)
             throw new HttpFailure(400, 'keep_count must be non-negative');
-        await this.store.withLock(sid, () => {
+        const refused = await this.withMutationLock(sid, async () => {
+            // One state.db read decides and marks the boundary, so a row committed meanwhile is neither counted nor hidden.
+            const read = this.stateDbRead(s);
+            if (hold) {
+                // A failed read cannot say whether a CLI continuation would go too: fail closed. The Agent keeps a state.db for every
+                // profile it has run in, so a missing one is never evidence of a session without state.db rows.
+                if (!read.ok)
+                    throw new HttpFailure(503, read.reason ?? 'The session history could not be read. Please try again in a moment.');
+                const held = (await this.heldCut(s, keep, read.rows));
+                if (held && held.confirm_token !== hold.confirmToken)
+                    return held;
+            }
+            // A cut inside the state.db continuation keeps the continuation's rows before it: the boundary below hides every
+            // row this read saw, so those rows join the stored transcript and model history first.
+            if (keep > s.messages.length) {
+                if (s.context_messages.length)
+                    s.context_messages = this.modelContext(s, read.rows);
+                s.messages = this.mergedTranscript(s, s.messages, read.rows);
+            }
             truncateSessionAtKeep(s, keep);
-            this.markStateDbSeen(s, undefined, { boundary: true });
-            this.store.save(s);
+            this.markStateDbSeen(s, read, { boundary: true });
+            await this.store.save(s);
+            return null;
         });
-        this.deps.runtime.evictAgent(sid);
-        return { ok: true, session: this.publicSession(s) };
+        if (refused)
+            return refused;
+        await this.deps.runtime.evictAgent(sid);
+        return { ok: true, session: (await this.publicSession(s)) };
+    }
+    /**
+     * TAL-929: the confirmation a cut at `keep` needs, or null for one that removes at most one user turn. Counted on the rows
+     * the detail shows, state.db continuation included, since `keep` indexes them: the user turns the cut removes, and the
+     * messages after the row it starts at.
+     */
+    async heldCut(s, keep, stateRows) {
+        const transcript = this.mergedTranscript(s, s.messages, stateRows);
+        const cut = ((await this.publicSession(s, true, transcript)).messages ?? []).map((m, i) => ({ m, i })).filter(({ m, i }) => i >= keep && m._display === 'row');
+        const userTurns = cut.filter(({ m }) => m.role === 'user').length;
+        if (userTurns <= 1)
+            return null;
+        const token = createHash('sha256').update(JSON.stringify(transcript.slice(keep))).digest('hex').slice(0, 32);
+        return { ok: false, confirm_required: true, discard_user_turns: userTurns, discard_messages: cut.filter(({ i }) => i > keep).length, confirm_token: token };
     }
     // ── 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) {
+    async startCompression(sid, focusRaw, opts = {}) {
         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 { s } = (await 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.
@@ -1098,8 +1684,8 @@ export class SessionService {
             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 job = { session_id: sid, focus_topic: focusTopic, status: 'running', started_at: now, updated_at: now, turns: new Set(), automatic: opts.automatic === true, done: Promise.resolve() };
+        job.done = this.compressSession(job).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}`);
@@ -1108,22 +1694,257 @@ export class SessionService {
         this.compressionJobs.set(job);
         return job;
     }
+    /**
+     * TAL-1005: compact the session in its joinable compression job before the next turn reads its history. A running job
+     * is always joined; a new one starts when the session is `due` (`compactionDue`, read from the store when omitted).
+     * `turn` is the waiting turn's stream: the job leaves its rows alone. `onWait` runs once a job is being waited on; an abort of `signal` (the turn's Stop) ends the wait but not the
+     * job. True when the job installed a compressed context. Never throws: a failed job leaves the Agent's own preflight.
+     */
+    async ensureCompacted(sid, opts = {}) {
+        const { turn, signal } = opts;
+        if (turn)
+            this.compactionWaiters.add(turn);
+        try {
+            let job = this.compressionJobs.get(sid);
+            if (job?.status !== 'running')
+                job = (opts.due ?? (await this.storedCompactionDue(sid))) ? await this.startCompression(sid, null, { automatic: true }) : undefined;
+            if (!job || signal?.aborted)
+                return false;
+            if (turn)
+                job.turns.add(turn);
+            await opts.onWait?.();
+            const aborted = new Promise((resolve) => { signal?.addEventListener('abort', () => { resolve(); }, { once: true }); });
+            await Promise.race([job.done, aborted]);
+            return !signal?.aborted && job.status === 'done';
+        }
+        catch (error) {
+            this.deps.log(`[webui] compaction before the next turn of ${sid} did not run: ${error.message}`);
+            return false;
+        }
+        finally {
+            if (turn)
+                this.compactionWaiters.delete(turn);
+        }
+    }
+    /**
+     * TAL-1005: measure the model context again when it holds a post-compression estimate the rows after it may have
+     * outgrown (a waiting turn's prompt, a stopped or failed turn's work). Skipped while a turn owns the session, which
+     * settles its own figures, or once the estimate changed meanwhile. True when it stored a new estimate.
+     */
+    async remeasureContext(sid) {
+        const sidecar = this.deps.sidecar?.();
+        let s;
+        try {
+            s = (await this.store.get(sid));
+        }
+        catch {
+            return false;
+        }
+        const before = s.post_compression_context_tokens_estimate;
+        if (before === null || s.active_stream_id || !sidecar)
+            return false;
+        let tokens;
+        try {
+            tokens = (await sidecar.call('models.estimate_tokens', { messages: this.modelContext(s) })).tokens;
+        }
+        catch {
+            return false;
+        }
+        return this.store.withLock(sid, async () => {
+            let live;
+            try {
+                live = (await this.store.get(sid));
+            }
+            catch {
+                return false;
+            }
+            if (live.active_stream_id || live.post_compression_context_tokens_estimate !== before || (await this.isReadOnly(live)))
+                return false;
+            live.post_compression_context_tokens_estimate = Math.max(1, tokens);
+            await this.store.save(live, { touchUpdatedAt: false });
+            return true;
+        });
+    }
+    async storedCompactionDue(sid) {
+        try {
+            return this.compactionDue((await this.store.get(sid, { metadataOnly: true })));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Whether the session's context (the post-compression estimate, else the last prompt) reached the next turn's threshold. */
+    compactionDue(s) {
+        const positive = (v) => { const n = Math.trunc(Number(v ?? 0)); return Number.isFinite(n) && n > 0 ? n : null; };
+        const used = positive(s.post_compression_context_tokens_estimate) ?? positive(s.last_prompt_tokens);
+        const threshold = positive(s.next_turn_threshold_tokens) ?? positive(s.threshold_tokens);
+        return used !== null && threshold !== null && used >= threshold;
+    }
     /** 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)
+     * repeat compression builds on the previous summary instead of re-reading the whole display transcript. `context` is
+     * that history unsanitized and `stateRows` the state.db read it came from. */
+    async compressionTarget(sid) {
+        await this.rejectViewOnly(sid, 'compressed');
+        const s = (await this.mutationTarget(sid, 'compressed'));
+        const stateRows = this.stateDbRows(s);
+        const context = this.compressionContext(s, stateRows);
+        return { s, history: sanitizeMessagesForApi(context), context, stateRows };
+    }
+    /**
+     * The loaded session's own compression guards: no running turn and enough model history. TAL-1005: a turn waiting on
+     * the compression has not read its history yet, so it does not block; the context leaves out its rows, as it does.
+     */
+    compressionContext(s, stateRows) {
+        const turn = s.active_stream_id;
+        if (turn && !this.compactionWaiters.has(turn))
             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)
+        const context = this.modelContext(s, stateRows).filter((m) => !turn || m._turn_id !== turn);
+        if (sanitizeMessagesForApi(context).length < 4)
             throw new HttpFailure(400, 'Not enough conversation to compress (need at least 4 messages).');
-        return { s, history };
+        return context;
+    }
+    /** TAL-614: whether a manual compression would start now: `compressionTarget`'s gates, with `readOnly` the wire flag. */
+    canCompress(s, readOnly, stateRows) {
+        if (readOnly || isClaudeCodeSessionId(s.session_id))
+            return false;
+        try {
+            this.compressionContext(s, stateRows);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof HttpFailure)
+                return false;
+            throw error;
+        }
+    }
+    /** TAL-258: the session's WebUI record (absent for a CLI or gateway session) and the profile whose state.db holds its rows. */
+    async handoffTarget(sid) {
+        sid = sid.trim();
+        let local = null;
+        try {
+            local = (await this.store.get(sid));
+        }
+        catch { /* a foreign session without a WebUI record */ }
+        const profile = local?.profile ?? this.deps.activeProfile();
+        return { local, profile, dbPath: this.stateDbPath(profile) };
+    }
+    /** Python `_handle_conversation_rounds` (TAL-258): the session's rounds and whether the handoff dock is due. */
+    async conversationRounds(sid, since) {
+        const rounds = countConversationRounds((await this.handoffTarget(sid)).dbPath, sid, since);
+        return { ok: true, rounds, threshold: CONVERSATION_ROUND_THRESHOLD, should_show: rounds >= CONVERSATION_ROUND_THRESHOLD };
+    }
+    /**
+     * Python `_handle_handoff_summary` (TAL-258): the session's main model summarizes its last 50 state.db messages after
+     * `since`, and the summary is appended as a display-only `handoff_summary` tool row. A failed or cut-off answer falls
+     * back to a deterministic local summary rather than an error.
+     */
+    async handoffSummary(sid, since) {
+        sid = (await this.rejectViewOnly(sid, 'summarized'));
+        const { local, profile, dbPath } = (await this.handoffTarget(sid));
+        const rounds = countConversationRounds(dbPath, sid, since);
+        if (rounds < CONVERSATION_ROUND_THRESHOLD)
+            throw new HttpFailure(400, 'Not enough conversation rounds to generate a summary.');
+        // A running turn settles the transcript it started from, which would drop a card appended meanwhile.
+        if (local?.active_stream_id)
+            throw new HttpFailure(409, 'Session is still streaming; wait for the current turn to finish.');
+        const all = stateDbSessionMessages(dbPath, sid, { stitch: true });
+        const messages = (since === null ? all : all.filter((m) => { const ts = stateDbTimestampSeconds(m.timestamp); return ts !== null && ts > since; })).slice(-50);
+        if (messages.length < 2)
+            throw new HttpFailure(400, 'Not enough messages to summarize.');
+        const sidecar = this.deps.sidecar?.() ?? null;
+        await ensureAgentRuntimeCurrent(sidecar);
+        const meta = local ? null : (await this.lookupCliMeta(sid));
+        const generated = await this.generateHandoffSummary(sidecar, profile, local, meta, messages);
+        const pick = (row, ...keys) => { for (const key of keys) {
+            const v = str(row?.[key]).trim();
+            if (v)
+                return v;
+        } return ''; };
+        // Python `get_cli_sessions` never listed WebUI's own state.db rows, so they name no channel.
+        const cliRow = meta ?? (await this.lookupCliMeta(sid));
+        const channel = pick(local, 'source_label', 'raw_source', 'source_tag', 'session_source') || (str(cliRow?.raw_source || cliRow?.source).trim().toLowerCase() === 'webui' ? '' : pick(cliRow, 'source_label', 'raw_source', 'source_tag', 'source')) || null;
+        await this.persistHandoffMarker(sid, profile, handoffMarker(sid, generated.summary, channel, rounds, generated.fallback, this.deps.now()));
+        return { ok: true, summary: generated.summary, message_count: messages.length, rounds, fallback: generated.fallback, ...(generated.warning ? { warning: generated.warning } : {}) };
+    }
+    /** The main model's summary at 700 tokens, once more at 1400 when it was cut off, else the local fallback. */
+    async generateHandoffSummary(sidecar, profile, local, meta, messages) {
+        const fallback = (warning) => ({ summary: fallbackHandoffSummary(messages), fallback: true, ...(warning ? { warning: `Summary generation used local fallback: ${warning}` } : {}) });
+        if (!sidecar)
+            return fallback('the Agent sidecar is not running');
+        const [model, provider] = local ? this.deps.modelStateFromRequest(local.model, local.model_provider, local.model_provider) : [str(meta?.model).trim() || null, null];
+        const prompt = [{ role: 'system', content: HANDOFF_SYSTEM_PROMPT }, { role: 'user', content: `Conversation transcript:\n${handoffTranscript(messages)}` }];
+        const ask = (maxTokens) => sidecar.call('aux.complete', { profile_home: this.deps.profileHome(profile), task: 'handoff_summary', messages: prompt, model: model ?? '', provider, max_tokens: maxTokens, temperature: 0.2 }, { timeoutMs: 60_000 });
+        try {
+            let result = await ask(700);
+            if (completionIncomplete(result))
+                result = await ask(1400);
+            return completionIncomplete(result) ? fallback() : { summary: result.text, fallback: false };
+        }
+        catch (error) {
+            if (error instanceof SidecarError && error.condition === 'agent_runtime_stale')
+                throw staleRuntimeFailure(error);
+            // No credential is not a failure: the predecessor answered with the local summary and no warning.
+            if (error instanceof SidecarError && error.condition === 'credential_missing')
+                return fallback();
+            return fallback(sanitizePaths(error));
+        }
+    }
+    /**
+     * Python `_persist_handoff_summary`: a messaging session gets the marker in state.db and its WebUI record; any other
+     * session in its WebUI record, or in state.db when it has none. Each store skips a marker its tail already holds, and
+     * the session lock keeps two summaries from both passing that check. A card neither store saved answers 503.
+     */
+    async persistHandoffMarker(sid, profile, marker) {
+        const card = messageHandoffPayload(marker);
+        const toStateDb = async () => {
+            await this.rejectViewOnly(sid, 'summarized');
+            if (sameHandoff(handoffPayload(stateDbTailToolContent(this.stateDbPath(profile), sid)), card))
+                return true;
+            const sidecar = this.deps.sidecar?.();
+            if (!sidecar)
+                return false;
+            try {
+                return (await sidecar.call('state_db.append_message', { profile_home: this.deps.profileHome(profile), session_id: sid, role: 'tool', content: str(marker.content), tool_name: 'handoff_summary', timestamp: Number(marker.timestamp) })).ok;
+            }
+            catch {
+                return false;
+            }
+        };
+        await this.withMutationLock(sid, async () => {
+            let live = null;
+            try {
+                live = (await this.store.get(sid));
+            }
+            catch { /* no WebUI record */ }
+            // A turn that started while the summary was generated would drop the card when it settles.
+            if (live?.active_stream_id)
+                throw new HttpFailure(409, 'Session is still streaming; wait for the current turn to finish.');
+            const toLocal = async () => {
+                await this.rejectViewOnly(sid, 'summarized');
+                if (!live)
+                    return false;
+                if (sameHandoff(messageHandoffPayload(live.messages.at(-1)), card))
+                    return true;
+                live.messages.push(marker);
+                await this.store.save(live);
+                return true;
+            };
+            const messaging = (await this.isMessagingSession(sid));
+            const saved = messaging ? [await toStateDb(), (await toLocal())].some(Boolean) : (await toLocal()) || await toStateDb();
+            // The caller may switch away on success, so a card saved nowhere is an error, not a summary.
+            if (!saved)
+                throw new HttpFailure(503, 'The handoff summary could not be saved; please retry.');
+        }, { allowReadOnly: true });
+    }
+    /** The same live presentation for session detail and journal snapshot recovery. */
+    currentRunStatus(sid, streamId) {
+        const job = this.compressionJobs.get(sid);
+        return job?.status === 'running' ? { phase: 'compressing' } : streamId ? (this.deps.runtime.runStatus?.(streamId) ?? null) : null;
     }
     /** The session's compression job; a deleted session's finished result is dropped rather than served. */
-    compressionJob(sid) {
+    async compressionJob(sid) {
         try {
-            this.store.get(sid, { metadataOnly: true });
+            (await this.store.get(sid, { metadataOnly: true }));
         }
         catch {
             this.compressionJobs.delete(sid);
@@ -1133,18 +1954,22 @@ export class SessionService {
     }
     /**
      * 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
+     * session lock refuse a result the session moved past (another stream, or a 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.
+     * The guards run again first: a stream may have started while the caller awaited the runtime check. TAL-1005: rows
+     * the job's waiting turns added meanwhile (a prompt, a Stop) stay after the compressed context.
      */
-    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);
+    async compressSession(job) {
+        const { session_id: sid, focus_topic: focusTopic } = job;
+        const { s, history, context, stateRows: seenRows } = (await this.compressionTarget(sid));
+        const ownRows = (m) => !s.active_stream_id || m._turn_id !== s.active_stream_id;
+        // The display transcript and the model context must both still start where the compression found them, followed
+        // only by the waiting turns' rows; the context is the exact history sent, so a state.db row that lands after this
+        // read fails the commit instead of being dropped.
+        // A turn still waiting to join (it started its own start meanwhile) joins this job, so it counts as one of its turns.
+        const waited = (id) => job.turns.has(str(id)) || this.compactionWaiters.has(str(id));
+        const sameRows = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+        const turnTail = (rows, base) => (sameRows(rows.slice(0, base.length), base) && rows.slice(base.length).every((m) => waited(m._turn_id)) ? rows.slice(base.length) : null);
         const sidecar = this.deps.sidecar?.();
         if (!sidecar)
             throw new HttpFailure(400, 'Compression failed: the Agent sidecar is not running');
@@ -1168,44 +1993,51 @@ export class SessionService {
             throw new HttpFailure(result.status === 'lock_skipped' ? 409 : 400, result.message ?? 'Nothing to compress yet.');
         const summary = result.summary ?? {};
         let committed = false;
+        let keptTurnRows = false;
         try {
-            const current = await this.store.withLock(sid, () => {
+            const current = await this.withMutationLock(sid, async () => {
                 let live;
                 try {
-                    live = this.store.get(sid);
+                    live = (await this.store.get(sid));
                 }
                 catch {
                     throw new HttpFailure(404, 'Session not found');
                 }
-                if (streamState(live) !== streamBefore)
+                const turn = live.active_stream_id;
+                if (turn && !waited(turn))
                     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 read = this.stateDbRead(live);
                 const stateRows = read.rows;
-                if (transcriptKey(live, sanitizeMessagesForApi(this.modelContext(live, stateRows))) !== historyKey)
+                const tail = turnTail(this.modelContext(live, stateRows).filter((m) => !turn || m._turn_id !== turn), context);
+                if (!tail || !turnTail(live.messages, s.messages))
                     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 seen = [...s.messages, ...s.context_messages, ...seenRows].filter(ownRows).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;
+                live.context_messages = [...compressed, ...copyJson(tail)];
+                keptTurnRows = tail.length > 0;
+                if (!turn) {
+                    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);
+                // The anchor is the newest row the compression covered: never a waiting turn's own.
                 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));
+                const anchor = visible.findLast((m) => !waited(m._turn_id));
+                live.compression_anchor_visible_idx = anchor ? visible.lastIndexOf(anchor) : null;
+                live.compression_anchor_message_key = anchorMessageKey(anchor);
                 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.
@@ -1215,15 +2047,22 @@ export class SessionService {
                 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);
+                // An automatic job is maintenance, not activity: it leaves the session's place in the list alone.
+                await this.store.save(live, { touchUpdatedAt: !job.automatic });
                 // A backup from before the compression would restore the uncompressed context.
                 try {
-                    rmSync(`${this.store.pathFor(sid)}.bak`, { force: true });
+                    await this.store.shrinkBackup.discard(sid);
                 }
                 catch { /* ignore */ }
                 return live;
             });
             committed = true;
+            // The estimate covers the compressed rows only; a stopped turn's kept prompt is measured with them (a waiting turn
+            // settles its own figures instead).
+            if (keptTurnRows)
+                await this.remeasureContext(sid);
+            // Open chats refetch the session for its new context figures; the list order stays (no recency change).
+            this.publish('session_compress', current.profile, sid);
             // 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 {
@@ -1232,31 +2071,57 @@ export class SessionService {
             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 };
+            return { ok: true, session: (await 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) {
+                const readOnly = committed ? (await this.readOnlyReason(s)) : null;
+                if (readOnly)
+                    committed = false;
                 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}`);
                 }
+                if (readOnly)
+                    throw new HttpFailure(403, readOnly);
             }
         }
     }
+    /** Clear and delete share the profile-scoped, best-effort Agent session boundary. */
+    async finalizeSession(sid, profile, reason) {
+        const sidecar = this.deps.sidecar?.();
+        if (!sidecar || this.deps.profileDeleting?.(profile))
+            return [];
+        const release = this.deps.profileActivity?.(profile);
+        try {
+            return (await sidecar.call('chat.finalize_session', {
+                session_id: sid, profile_home: this.deps.profileHome(profile ?? this.deps.activeProfile()), reason,
+            }, { timeoutMs: 12_000 })).messages;
+        }
+        catch (error) {
+            this.deps.log(`[webui] session finalize (${reason}) failed: ${error.message}`);
+            return [];
+        }
+        finally {
+            release?.();
+        }
+    }
     async clear(sid) {
-        this.rejectSubagent(sid, 'modified');
-        const s = this.mutationTarget(sid, 'modified');
-        await this.store.withLock(sid, () => {
+        await this.rejectViewOnly(sid, 'modified');
+        const s = (await this.mutationTarget(sid, 'modified'));
+        await this.withMutationLock(sid, async () => {
+            const messages = await this.finalizeSession(sid, s.profile, 'clear');
             const hadMessages = s.messages.length > 0;
             truncateSessionAtKeep(s, 0);
+            s.messages = messages.map((content) => ({ role: 'local_notice', content, _notice_kind: 'session_finalize', timestamp: this.deps.now() }));
             s.tool_calls = [];
             if (s.parent_session_id) {
                 let parentIsSnapshot = false;
                 try {
-                    parentIsSnapshot = this.store.get(s.parent_session_id, { metadataOnly: true }).pre_compression_snapshot;
+                    parentIsSnapshot = (await this.store.get(s.parent_session_id, { metadataOnly: true })).pre_compression_snapshot;
                 }
                 catch {
                     parentIsSnapshot = false;
@@ -1275,21 +2140,21 @@ export class SessionService {
             s.clear_generation = hadMessages ? randomUUID().replace(/-/g, '') : null;
             applySessionTitleRename(s, 'Untitled');
             this.markStateDbSeen(s, undefined, { boundary: true });
-            this.store.save(s);
+            await this.store.save(s);
             if (hadMessages) {
                 try {
-                    rmSync(`${this.store.pathFor(sid)}.bak`, { force: true });
+                    await this.store.shrinkBackup.discard(sid);
                 }
                 catch { /* ignore */ }
             }
         });
-        this.deps.runtime.evictAgent(sid, true);
-        return { ok: true, session: this.wireRow(s) };
+        await this.deps.runtime.evictAgent(sid, true);
+        return { ok: true, session: (await this.wireRow(s)) };
     }
     async retry(sid) {
-        this.rejectSubagent(sid, 'modified');
-        return this.store.withLock(sid, () => {
-            const s = this.mutationTarget(sid, 'modified');
+        await this.rejectViewOnly(sid, 'modified');
+        return this.withMutationLock(sid, async () => {
+            const s = (await this.mutationTarget(sid, 'modified'));
             const history = s.messages;
             const lastUser = findLastUserIndex(history);
             if (lastUser === null)
@@ -1306,14 +2171,14 @@ export class SessionService {
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
             this.markStateDbSeen(s, undefined, { boundary: true });
-            this.store.save(s);
+            await this.store.save(s);
             return { ok: true, last_user_text: lastUserText, last_user_prompt: lastUserPrompt, last_user_attachments: lastUserAttachments, removed_count: removed };
         });
     }
     async undo(sid) {
-        this.rejectSubagent(sid, 'modified');
-        return this.store.withLock(sid, () => {
-            const s = this.mutationTarget(sid, 'modified');
+        await this.rejectViewOnly(sid, 'modified');
+        return this.withMutationLock(sid, async () => {
+            const s = (await this.mutationTarget(sid, 'modified'));
             const history = s.messages;
             const lastUser = findLastUserIndex(history);
             if (lastUser === null)
@@ -1322,14 +2187,14 @@ export class SessionService {
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
             this.markStateDbSeen(s, undefined, { boundary: true });
-            this.store.save(s);
+            await this.store.save(s);
             const preview = removedText.length > 40 ? `${removedText.slice(0, 40)}...` : removedText;
             return { ok: true, removed_count: removed, removed_preview: preview };
         });
     }
-    duplicate(sid) {
-        this.rejectSubagent(sid, 'duplicated');
-        const session = this.store.load(sid);
+    async duplicate(sid) {
+        await this.rejectViewOnly(sid, 'duplicated');
+        const session = (await this.store.load(sid));
         if (!session)
             throw new HttpFailure(404, 'Session not found');
         const now = this.deps.now();
@@ -1337,7 +2202,7 @@ export class SessionService {
         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,
+            messages: withMirrorSources(copyJson(session.messages), session), 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,
             ...watermark, context_messages: copyJson(session.context_messages),
@@ -1345,16 +2210,15 @@ export class SessionService {
             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,
         }, { workspace: session.workspace, model: session.model });
-        this.store.touch(copied);
-        this.store.save(copied);
+        await this.store.touch(copied);
+        await this.store.save(copied);
         this.publish('session_duplicate', copied.profile, copied.session_id);
-        return { session: this.publicSession(copied) };
+        return { session: (await this.publicSession(copied)) };
     }
-    branch(sid, body) {
-        if (this.isSubagentViewOnly(sid))
-            throw new HttpFailure(400, 'Subagent sessions are view-only and cannot be branched from WebUI');
-        const source = this.get404(sid);
-        if (this.isReadOnly(source)) {
+    async branch(sid, body) {
+        await this.rejectViewOnly(sid, 'branched');
+        const source = (await this.get404(sid));
+        if ((await this.isReadOnly(source))) {
             if (str(source.source_tag || source.raw_source).trim().toLowerCase() !== 'cron')
                 throw new HttpFailure(403, 'Read-only sessions cannot be branched from WebUI');
             source.branchSourceReadonly = true;
@@ -1370,7 +2234,7 @@ export class SessionService {
         const customTitle = body.title ? str(body.title).trim().slice(0, 80) || null : null;
         if (!source.branchSourceReadonly) {
             try {
-                this.store.save(source);
+                (await this.store.save(source));
             }
             catch { /* ignore */ }
         }
@@ -1385,25 +2249,106 @@ export class SessionService {
         const sourceContext = stateRows.length ? this.mergedTranscript(source, source.context_messages.length ? source.context_messages : source.messages) : source.context_messages;
         const forkedContext = copyJson(truncateContextForDisplayKeep(sourceContext, sourceMessages, forkKeep));
         const branch = new Session({
-            workspace: source.workspace, model: source.model, model_provider: source.model_provider, profile: source.profile, title, messages: forked, project_id: source.project_id,
+            workspace: source.workspace, model: source.model, model_provider: source.model_provider, profile: source.profile, title, messages: withMirrorSources(forked, source), project_id: source.project_id,
             personality: source.personality, enabled_toolsets: source.enabled_toolsets, context_length: source.context_length, threshold_tokens: source.threshold_tokens,
             context_messages: forkedContext, gateway_routing: copyJson(source.gateway_routing), context_engine: source.context_engine, context_engine_state: copyJson(source.context_engine_state),
             parent_session_id: source.session_id, session_source: 'fork',
         }, { workspace: source.workspace, model: source.model });
-        this.store.touch(branch);
+        await this.store.touch(branch);
         if (forked.length) {
-            this.store.save(branch);
+            await this.store.save(branch);
             this.publish('session_branch', branch.profile, branch.session_id);
         }
         return { session_id: branch.session_id, title, parent_session_id: source.session_id };
     }
+    /** Python `read_session_lineage_report` on the active profile's state.db. */
+    lineageReport(sid) {
+        return stateDbLineageReport(this.stateDbPath(null), sid);
+    }
+    /** TAL-259: recovery reads the active profile's state.db, and a recovered sidecar joins that profile. */
+    async recoveryDeps() {
+        return { store: this.store, stateDbPath: this.stateDbPath(null), profile: this.deps.activeProfile(), stampingSince: await this.deps.recoveryStampingSince(), isReadOnly: (sid, profile) => Boolean(withOwnerLocks([{ session_id: sid, profile }], this.stateDbSources)[0]?.read_only), log: this.deps.log };
+    }
+    async recoveryAudit() {
+        return (await auditSessionRecovery(await this.recoveryDeps()));
+    }
+    async recoveryRepairSafe() {
+        return repairSafeSessionRecovery(await this.recoveryDeps());
+    }
+    /**
+     * Python `_handle_session_compression_recovery_start`: open a compression-exhausted session's focused continuation, an
+     * empty fork keeping its workspace, model, profile, toolsets and worktree. A retry opens the oldest continuation
+     * already started from it in the same profile; the source's lock makes concurrent starts converge on one child.
+     */
+    async compressionRecoveryStart(sid) {
+        if ((await this.isSubagentViewOnly(sid)))
+            throw new HttpFailure(400, 'Subagent sessions are view-only and cannot start compression recovery from WebUI');
+        const action = COMPRESSION_RECOVERY_ACTION_START_FOCUSED;
+        let created = false;
+        const child = await this.withMutationLock(sid, async () => {
+            // Validated under the lock: a delete that won it leaves no source to fork.
+            const source = (await this.store.get(sid));
+            if (!this.visibleToActiveProfile(source.profile))
+                throw new HttpFailure(404, 'Session not found');
+            if (!compressionRecoveryPayload(source))
+                throw new HttpFailure(409, 'Session does not have a compression recovery action.');
+            const existing = (await this.compressionRecoveryChild(sid, action, source.profile));
+            if (existing)
+                return existing;
+            const base = (source.title || 'Untitled').trim() || 'Untitled';
+            const fresh = new Session({
+                title: base.endsWith(' (focused continuation)') ? base : `${base} (focused continuation)`, workspace: source.workspace, model: source.model, model_provider: source.model_provider,
+                project_id: source.project_id, profile: source.profile, session_source: 'fork', personality: source.personality, enabled_toolsets: copyJson(source.enabled_toolsets),
+                context_length: source.context_length, threshold_tokens: source.threshold_tokens, gateway_routing: copyJson(source.gateway_routing), gateway_routing_history: copyJson(source.gateway_routing_history),
+                parent_session_id: source.session_id, worktree_path: source.worktree_path, worktree_branch: source.worktree_branch, worktree_repo_root: source.worktree_repo_root, worktree_created_at: source.worktree_created_at,
+                compression_recovery_source_session_id: sid, compression_recovery_action: action,
+                // An empty model-facing transcript: the focused follow-up must not replay the exhausted context.
+                messages: [], context_messages: [], composer_draft: { text: '', files: [] },
+            }, { workspace: source.workspace, model: source.model });
+            try {
+                await this.store.save(fresh);
+            }
+            catch (error) {
+                throw new HttpFailure(500, `Failed to start compression recovery: ${sanitizePaths(error)}`);
+            }
+            await this.store.touch(fresh);
+            created = true;
+            return fresh;
+        }, { allowReadOnly: true });
+        if (created)
+            this.publish('session_compression_recovery', child.profile, child.session_id);
+        return {
+            ok: true, session: (await this.publicSession(child)), source_session_id: sid, recommended_recovery_action: action,
+            message: created ? 'Started a focused continuation. Describe the next narrow task to continue.' : 'Opened the existing focused continuation for this exhausted session.',
+        };
+    }
+    /** Python `find_compression_recovery_session`: the oldest same-profile continuation started from `sid`, cached or persisted. */
+    async compressionRecoveryChild(sid, action, profile) {
+        const matches = (s) => s.compression_recovery_source_session_id === sid && s.compression_recovery_action === action && this.deps.profilesMatch(s.profile, profile);
+        const found = new Map();
+        for (const s of this.store.sessions.values())
+            if (matches(s))
+                found.set(s.session_id, s);
+        for (const id of (await this.store.persistedIds())) {
+            if (found.has(id) || this.store.sessions.has(id))
+                continue;
+            try {
+                const meta = (await this.store.get(id, { metadataOnly: true, promote: false, cacheOnMiss: false }));
+                if (matches(meta))
+                    found.set(id, meta);
+            }
+            catch { /* unreadable: not a match */ }
+        }
+        const [oldest] = [...found.values()].sort((a, b) => (a.created_at || 0) - (b.created_at || 0) || (a.updated_at || 0) - (b.updated_at || 0) || (a.session_id < b.session_id ? -1 : 1));
+        return oldest ? (await this.store.get(oldest.session_id)) : null;
+    }
     /** 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) {
+    async 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();
+            const candidate = str((await this.store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false })).active_stream_id).trim();
             if (candidate && this.deps.runtime.activeStreamIds.has(candidate))
                 return candidate;
         }
@@ -1415,112 +2360,141 @@ export class SessionService {
             throw new HttpFailure(400, 'session_id is required');
         if (!isSafeSessionId(sid))
             throw new HttpFailure(400, 'Invalid session_id');
+        await this.rejectViewOnly(sid, 'deleted');
         // Python: a read-only import (persisted sidecar flag, sidebar metadata, or a foreign state.db owner such as a
-        // Claude Code session) is never deleted — that would erase the owner's authoritative transcript.
-        if (this.isReadOnlyImport(sid))
+        // Claude Code session) is never deleted — that would erase the owner's authoritative transcript. An orphan has none.
+        const orphaned = (await this.isOrphanedImport(sid));
+        if (!orphaned && (await this.isReadOnlyImport(sid)))
             throw new HttpFailure(400, 'Read-only imported sessions cannot be deleted from WebUI');
-        if (this.isSubagentViewOnly(sid))
+        if ((await this.isSubagentViewOnly(sid)))
             throw new HttpFailure(400, 'Subagent sessions are view-only and cannot be deleted from WebUI');
-        const retained = (() => { try {
-            return worktreeRetainedPayload(this.store.get(sid, { metadataOnly: true }));
+        const retained = (await (async () => { try {
+            return worktreeRetainedPayload((await this.store.get(sid, { metadataOnly: true })));
         }
         catch {
             return {};
-        } })();
+        } })());
         let eventProfile = null;
-        let hadSidecar = true;
         try {
-            eventProfile = this.store.get(sid, { metadataOnly: true }).profile;
+            eventProfile = (await 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 {
-            if (isMessagingSessionRecord(this.store.get(sid, { metadataOnly: true }).compact()))
-                return true;
-        }
-        catch { /* absent */ } const meta = this.lookupCliMeta(sid); return meta !== null && isMessagingSessionRecord(meta); })();
-        if (this.activeRunBlocking(sid))
-            throw new HttpFailure(409, 'Session has an active run; stop it before deleting');
+        const isMessaging = (await this.isMessagingSession(sid));
+        const knownIds = !isMessaging && !orphaned ? stateDbCompressionLineage(this.stateDbPath(eventProfile), sid) : [sid];
+        const assertIdle = async () => { for (const id of knownIds)
+            if (await this.activeRunBlocking(id))
+                throw new HttpFailure(409, 'Session has an active run; stop it before deleting'); };
+        await assertIdle();
+        let stateDbCleanupFailed = false;
+        let removedIds = [sid];
         try {
-            await this.store.withLock(sid, () => {
-                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 {
-                    this.deps.shares.revoke(this.store.get(sid, { metadataOnly: true }));
+            await this.withMutationLock(sid, async () => {
+                await assertIdle();
+                // TAL-792: state.db goes first, so another Agent process running or compressing the session refuses the delete
+                // before anything of Talaria's is removed. Python: the Agent/CLI transcript goes too (else a claimable CLI row
+                // resurfaces in the sidebar), but a messaging channel's memory is never erased from the WebUI.
+                if (!isMessaging && !orphaned) {
+                    const result = await this.deleteStateDbRows(eventProfile, sid);
+                    stateDbCleanupFailed = !result.ok;
+                    removedIds = [...new Set([sid, ...(result.deleted_ids ?? (result.ok ? knownIds : []))])];
                 }
-                catch (error) {
-                    if (!(error instanceof SessionNotFound))
-                        throw error;
+                if (removedIds.some((id) => !isSafeSessionId(id)))
+                    throw new HttpFailure(503, 'Session cleanup could not finish because the Agent returned invalid session IDs.');
+                removedIds = (await filterAsync(removedIds, async (id) => {
+                    try {
+                        return this.deps.profilesMatch((await this.store.get(id, { metadataOnly: true })).profile, eventProfile ?? this.deps.activeProfile());
+                    }
+                    catch {
+                        return true;
+                    }
+                }));
+                for (const id of removedIds) {
+                    // Revoke before removing each persisted alias; UI cleanup follows the Agent's committed target set.
+                    try {
+                        const session = (await this.store.get(id, { metadataOnly: true }));
+                        if (!Object.keys(retained).length)
+                            Object.assign(retained, worktreeRetainedPayload(session));
+                        await this.deps.shares.revoke(session);
+                        await this.deps.clearRelayCompletions?.(id, session.profile);
+                    }
+                    catch (error) {
+                        if (!(error instanceof SessionNotFound))
+                            throw error;
+                    }
+                    const finalize = id === sid && !(await this.store.wasDeleted(id));
+                    if (!(await this.store.delete(id)))
+                        throw new HttpFailure(500, 'Failed to delete session data');
+                    if (finalize)
+                        await this.finalizeSession(sid, eventProfile, 'delete');
                 }
-                if (!this.store.deleteFiles(sid))
-                    throw new HttpFailure(500, 'Failed to delete session data');
-            }, { timeoutMs: 5000 });
+            }, { timeoutMs: 5000, allowReadOnly: orphaned });
         }
         catch (error) {
             if (error instanceof SessionBusy)
                 throw new HttpFailure(503, 'Session busy, try again');
             throw error;
         }
-        this.deps.runtime.evictAgent(sid, true);
-        try {
-            rmSync(this.deps.attachmentDir(sid), { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-        // Python `delete_run_journal` (#3802): a deleted session leaves no replayable run journal behind.
-        try {
-            this.deps.journal?.deleteSession(sid);
-        }
-        catch { /* ignore */ }
-        this.deps.runtime.closeTerminal(sid);
-        // Python: the Agent/CLI transcript in state.db goes too (else a claimable CLI row resurfaces in the sidebar), but a
-        // messaging channel's memory is never erased from the WebUI; the actual outcome is reported.
-        let stateDbCleanupFailed = false;
-        if (!isMessaging) {
-            // 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;
-                }
+        for (const id of removedIds) {
+            await this.deps.runtime.evictAgent(id, true);
+            try {
+                rmSync(this.deps.attachmentDir(id), { recursive: true, force: true });
             }
+            catch { /* ignore */ }
+            // Python `delete_run_journal` (#3802): a deleted session leaves no replayable run journal behind.
+            try {
+                (await this.deps.journal?.deleteSession(id));
+            }
+            catch { /* ignore */ }
+            this.deps.runtime.closeTerminal(id);
         }
         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) {
+    /** The committed Agent deletion targets and cleanup outcome; throws 409 `refused` while an Agent process holds a row. */
+    async deleteStateDbRows(profile, sid) {
+        // TAL-529: the compression continuations go too; the Agent's delete keeps and detaches them otherwise. TAL-792: the
+        // sidecar resolves them inside its delete transaction, so a guard on any of them refuses before anything is removed.
+        let result;
+        try {
+            result = await this.deps.runtime.deleteCliSession(profile, sid);
+        }
+        catch {
+            return { ok: false };
+        }
+        if (result.refused) {
+            const message = result.refused === 'runtime_history_unsupported'
+                ? 'This Agent cannot retire the session\'s retained runtime history. Use an Agent that supports retiring this history, or explicitly restore a pre-upgrade backup before deleting it.'
+                : 'In use by another Agent process. Try again later.';
+            throw new HttpFailure(409, message, { refused: result.refused });
+        }
+        return result;
+    }
+    async cleanup(zeroOnly) {
         let cleaned = 0;
         const removed = new Set();
-        for (const s of this.store.scanAll()) {
+        for (const s of (await this.store.scanAll())) {
             const shouldDelete = zeroOnly ? s.messages.length === 0 : s.title === 'Untitled' && s.messages.length === 0;
-            if (!shouldDelete)
+            if (!shouldDelete || (await this.isReadOnly(s)))
                 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);
+                (await this.deps.shares.revoke(s));
             }
             catch {
                 continue;
             }
             this.store.sessions.delete(s.session_id);
-            rmSync(this.store.pathFor(s.session_id), { force: true });
+            await this.store.delete(s.session_id, { tombstone: false });
             cleaned += 1;
             removed.add(s.session_id);
         }
-        this.store.invalidatePersistedIds();
         let rewroteIndex = false;
         try {
-            const rows = this.store.readIndexEntries();
-            const live = this.store.persistedIds();
+            const rows = (await this.store.readIndexEntries());
+            const live = (await this.store.persistedIds());
             const survivors = rows.filter((entry) => {
                 const id = str(entry.session_id);
                 if (!id || live.has(id) || this.store.sessions.has(id))
@@ -1531,20 +2505,20 @@ export class SessionService {
                 return false;
             });
             if (survivors.length < rows.length) {
-                this.store.writeIndex();
+                await this.store.writeIndex();
                 rewroteIndex = true;
             }
         }
         catch { /* corrupt index is rebuilt below */ }
         if (removed.size && !rewroteIndex) {
             try {
-                this.store.writeIndex();
+                (await this.store.writeIndex());
             }
             catch { /* ignore */ }
         }
         return { ok: true, cleaned };
     }
-    import(body) {
+    async import(body) {
         const messages = stripPublicInternalFields(body.messages, { messageRecords: true });
         if (!Array.isArray(messages))
             throw new HttpFailure(400, 'JSON must contain a "messages" array');
@@ -1553,48 +2527,48 @@ export class SessionService {
             throw new HttpFailure(400, 'JSON "tool_calls" must be an array');
         let workspace;
         try {
-            workspace = this.deps.workspaces.resolveTrusted(typeof body.workspace === 'string' ? body.workspace : null);
+            workspace = (await this.deps.workspaces.resolveTrusted(typeof body.workspace === 'string' ? body.workspace : null));
         }
         catch (error) {
             throw new HttpFailure(400, error.message);
         }
-        const defaults = this.store.deps.defaults(this.deps.activeProfile());
+        const defaults = (await this.store.deps.defaults(this.deps.activeProfile()));
         const s = new Session({ title: typeof body.title === 'string' ? body.title : 'Imported session', workspace, model: typeof body.model === 'string' ? body.model : defaults.model, messages: messages, tool_calls: stripPublicInternalFields(rawToolCalls), profile: this.deps.activeProfile() }, defaults);
         s.pinned = Boolean(body.pinned);
-        this.store.touch(s);
-        this.store.save(s);
+        await this.store.touch(s);
+        await this.store.save(s);
         this.publish('session_import');
-        return { ok: true, session: this.publicSession(s) };
+        return { ok: true, session: (await this.publicSession(s)) };
     }
     // ── drafts ───────────────────────────────────────────────────────────────
-    readDraft(sid) {
+    async readDraft(sid) {
         if (!sid)
             throw new HttpFailure(400, 'session_id is required');
-        let hasSidecar;
         try {
-            hasSidecar = this.deps.drafts.exists(sid);
+            this.deps.drafts.validate(sid);
         }
         catch {
             throw new HttpFailure(400, 'Invalid session_id');
         }
+        const hasSidecar = await this.deps.drafts.exists(sid);
         if (hasSidecar) {
             const cached = this.store.sessions.get(sid);
-            if (!cached && !existsSessionFile(this.store, sid))
+            if (!cached && !(await existsSessionFile(this.store, sid)))
                 throw new HttpFailure(404, 'Session not found');
-            const [draft, version] = this.deps.drafts.readState(sid);
+            const [draft, version] = (await this.deps.drafts.readState(sid));
             if (cached)
                 cached.composer_draft = draft;
             return { draft, draft_version: version };
         }
-        const s = this.get404(sid, { metadataOnly: true });
-        const [draft, version] = this.deps.drafts.readState(sid, s.composer_draft);
+        const s = (await this.get404(sid, { metadataOnly: true }));
+        const [draft, version] = (await this.deps.drafts.readState(sid, s.composer_draft));
         return { draft, draft_version: version };
     }
     async writeDraft(body) {
         const sid = str(body.session_id);
         if (!sid)
             throw new HttpFailure(400, 'Missing required field(s): session_id');
-        if (this.isSubagentViewOnly(sid))
+        if ((await this.isSubagentViewOnly(sid)))
             throw new HttpFailure(400, 'Subagent sessions are view-only and cannot store a draft from WebUI');
         let text = body.text;
         let files = body.files;
@@ -1607,7 +2581,7 @@ export class SessionService {
         if (Array.isArray(files) && files.length > 50)
             files = files.slice(0, 50);
         try {
-            this.deps.drafts.path(sid);
+            this.deps.drafts.validate(sid);
         }
         catch {
             throw new HttpFailure(400, 'Invalid session_id');
@@ -1624,18 +2598,18 @@ export class SessionService {
             if (BigInt(draftVersion) > maxVersion)
                 throw new HttpFailure(400, 'draft_version is too far in the future');
         }
-        return this.store.withLock(sid, () => {
+        return this.store.withLock(sid, async () => {
             let s = this.store.sessions.get(sid) ?? null;
             if (s && s.session_id !== sid)
                 s = null;
-            const sessionExists = existsSessionFile(this.store, sid);
+            const sessionExists = (await existsSessionFile(this.store, sid));
             if (!s) {
                 if (!sessionExists)
                     throw new HttpFailure(404, 'Session not found');
-                if (!this.deps.drafts.exists(sid))
-                    s = this.get404(sid, { metadataOnly: true });
+                if (!(await this.deps.drafts.exists(sid)))
+                    s = (await this.get404(sid, { metadataOnly: true }));
             }
-            const [currentDraft, currentVersion] = this.deps.drafts.readState(sid, s?.composer_draft);
+            const [currentDraft, currentVersion] = (await this.deps.drafts.readState(sid, s?.composer_draft));
             const next = { ...currentDraft };
             if (text !== null && text !== undefined)
                 next.text = text;
@@ -1658,10 +2632,10 @@ export class SessionService {
                     throw new HttpFailure(404, 'Session not found');
                 if (!sessionExists && s) {
                     s.composer_draft = next;
-                    this.store.save(s, { touchUpdatedAt: false });
+                    await this.store.save(s, { touchUpdatedAt: false });
                 }
                 try {
-                    saved = this.deps.drafts.write(sid, next, draftVersion);
+                    saved = (await this.deps.drafts.write(sid, next, draftVersion));
                 }
                 catch (error) {
                     if (error instanceof DraftVersionConflict)
@@ -1686,7 +2660,7 @@ export class SessionService {
             throw new HttpFailure(400, 'Missing required field(s): scene');
         let s;
         try {
-            s = this.getForMutation(sid);
+            s = (await this.getForMutation(sid));
         }
         catch (error) {
             if (error instanceof SessionNotFound)
@@ -1697,7 +2671,7 @@ export class SessionService {
         }
         if (!this.visibleToActiveProfile(s.profile))
             throw new HttpFailure(404, 'Session not found');
-        return this.store.withLock(sid, () => {
+        return this.withMutationLock(sid, async () => {
             let placement;
             try {
                 placement = storeAnchorScene(s, body, this.deps.now());
@@ -1707,16 +2681,16 @@ export class SessionService {
             }
             if (!placement)
                 throw new HttpFailure(404, 'Assistant message not found');
-            this.store.save(s, { touchUpdatedAt: false, skipIndex: true });
+            await this.store.save(s, { touchUpdatedAt: false, skipIndex: true });
             return { ok: true, ...placement };
         });
     }
     /** The session and the full transcript its detail is built from; a state.db-only session gives its synthesized one. */
-    fullTranscript(sid) {
+    async fullTranscript(sid) {
         try {
-            let session = this.store.get(sid);
+            let session = (await this.store.get(sid));
             if (session.loadedMetadataOnly)
-                session = this.store.load(sid) ?? session;
+                session = (await this.store.load(sid)) ?? session;
             if (!this.visibleToActiveProfile(session.profile))
                 throw new HttpFailure(404, 'Session not found');
             return { session, transcript: this.mergedTranscript(session), stored: true };
@@ -1724,17 +2698,17 @@ export class SessionService {
         catch (error) {
             if (error instanceof HttpFailure)
                 throw error;
-            const session = this.foreignSession(sid).synth;
+            const session = (await this.foreignSession(sid)).synth;
             return { session, transcript: session.messages, stored: false };
         }
     }
-    readAnchorScene(query) {
+    async 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 { session, transcript, stored } = (await 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');
@@ -1743,26 +2717,26 @@ export class SessionService {
         const redacted = redactValue(result, 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 };
+        return { ...redacted, rows: stored ? withSceneRowMedia(rows, (await 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) {
+    async 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);
+        const full = fullToolResult((await 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) {
+    async createShare(sid) {
         this.rejectClaudeCode(sid, 'shared');
-        let s = this.get404(sid);
+        let s = (await this.get404(sid));
         if (!this.visibleToActiveProfile(s.profile))
             throw new HttpFailure(404, 'Session not found');
-        s = this.store.ensureFull(sid, s);
+        s = (await this.store.ensureFull(sid, s));
         let snapshot;
         try {
             snapshot = buildShareSnapshot(s, s.messages, { hermesHome: this.deps.hermesHome, attachmentRoot: this.deps.attachmentDir('').replace(/\/[^/]*$/, ''), home: this.deps.home });
@@ -1770,31 +2744,31 @@ export class SessionService {
         catch (error) {
             throw new HttpFailure(400, error.message);
         }
-        const meta = this.deps.shares.createOrRefresh(s, snapshot);
+        const meta = (await this.deps.shares.createOrRefresh(s, snapshot));
         s.share_token = meta.share_token;
         s.share_created_at = meta.share_created_at;
-        this.store.save(s, { touchUpdatedAt: false });
+        await this.store.save(s, { touchUpdatedAt: false });
         this.publish('session_share_create', s.profile, sid);
         return {
             ok: true,
             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),
+            session: (await this.publicSession(s)),
         };
     }
-    revokeShare(sid) {
-        let s = this.get404(sid);
+    async revokeShare(sid) {
+        let s = (await this.get404(sid));
         if (!this.visibleToActiveProfile(s.profile))
             throw new HttpFailure(404, 'Session not found');
-        s = this.store.ensureFull(sid, s);
-        this.deps.shares.revoke(s);
+        s = (await this.store.ensureFull(sid, s));
+        await this.deps.shares.revoke(s);
         s.share_token = null;
         s.share_created_at = null;
-        this.store.save(s, { touchUpdatedAt: false });
+        await this.store.save(s, { touchUpdatedAt: false });
         this.publish('session_share_revoke', s.profile, sid);
-        return { ok: true, session: this.publicSession(s) };
+        return { ok: true, session: (await this.publicSession(s)) };
     }
-    loadShare(token) {
-        const share = this.deps.shares.load(token);
+    async loadShare(token) {
+        const share = (await this.deps.shares.load(token));
         if (!share)
             throw new HttpFailure(404, 'Shared conversation not found');
         return { share };
@@ -1805,15 +2779,16 @@ export class SessionService {
             throw new HttpFailure(400, 'Missing session_id');
         return { yolo_enabled: this.deps.yolo.isEnabled(sid) };
     }
-    setYolo(sid, enabled) {
+    async setYolo(sid, enabled) {
         if (!sid)
             throw new HttpFailure(400, 'Missing required field(s): session_id');
+        await this.assertWritable(sid);
         this.deps.yolo.set(sid, enabled);
         return { ok: true, yolo_enabled: this.deps.yolo.isEnabled(sid) };
     }
 }
-function existsSessionFile(store, sid) {
-    return store.persistedIds().has(sid);
+async function existsSessionFile(store, sid) {
+    return (await store.persistedIds()).has(sid);
 }
 import { createHash } from 'node:crypto';
 function hashRevision(signature) {
@@ -1857,13 +2832,24 @@ function runStateDbRows(rows, prompt) {
 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`. */
+/** `rows` minus one occurrence of each base row, retaining its numeric provenance on the Agent's history copy. */
 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; });
+    for (const m of base) {
+        const key = settledIdentity(m);
+        const entry = left.get(key) ?? { rows: [], at: 0 };
+        entry.rows.push(m);
+        left.set(key, entry);
+    }
+    return rows.filter((m) => {
+        const entry = left.get(settledIdentity(m));
+        if (!entry || entry.at === entry.rows.length)
+            return true;
+        const original = entry.rows[entry.at++];
+        if (!('_state_db_generation' in m) && '_state_db_generation' in original)
+            m._state_db_generation = original._state_db_generation;
+        return false;
+    });
 }
 /**
  * TAL-493: what the state.db marker was recorded under: the boundary fields every boundary writer sets (an older release