@maudecode/talaria-web 1.19.0 → 1.20.0

package/dist/sessions/service.js

@@ -1,3 +1,4 @@
+import { unavailableContextDetail } from '@maudecode/talaria-web-contracts';
 import { filterAsync } from '../util.js';
 import { statSignature } from '../fs/stat.js';
 import { SessionPrefixIndex } from './prefix-index.js';
@@ -8,16 +9,16 @@ import { buildActiveTurnToken, copyJson, redactSessionData, redactValue, stripPu
 import { DraftVersionConflict, normalizeDraftVersion } from './drafts.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 { contextUsage, COMPRESSION_RECOVERY_ACTION_START_FOCUSED, compressionRecoveryPayload, forgetContextFigures, isSafeSessionId, lastMessageTimestamp, Session, sharePath, stripAttachedFilesMarker, titleFrom } from './session.js';
+import { contextUsage, COMPRESSION_RECOVERY_ACTION_START_FOCUSED, compressionRecoveryPayload, forgetContextFigures, isSafeSessionId, lastMessageTimestamp, Session, sharePath, stripAttachedFilesMarker, titleFrom, WORKTREE_RETAINED_KEY } 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 { 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 { stateDbWebDiagnosticIdsAsync, agentSessionRowsExistingAsync, CANONICAL_READ_ONLY_REASON, OWNERSHIP_UNAVAILABLE_REASON, CONVERSATION_ROUND_THRESHOLD, emptyLineageReport, stateDbSessionReadAsync, stateDbSessionSourcesAsync, stateDbTimestampSeconds, withStateDbListingReads } 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 { 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 { agentSteerText, ApiMessageSummary, appendStateDbIdentityRows, attachedFilesPrompt, attachmentObjects, checkpointTurnStart, dedupeContext, isContextCompressionMarker, journalOutputRows, looksLikeCurrentUserTurn, stoppedTurnContext, mergeSessionMessagesAppendOnly, messageIdentity, pendingUserRow, reasoningFieldsText, sanitizeMessagesForApi, withDataUseRequirements, 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';
@@ -42,11 +43,16 @@ export class HttpFailure extends Error {
 }
 /**
  * Python `_agent_runtime_barrier_response`: a stale local Agent checkout is refused with a typed 409 before the caller
- * mutates anything. Any other failure of the check is not a verdict and lets the caller proceed.
+ * mutates anything. An unavailable connection is refused before dispatch; other check failures are not a verdict
+ * and let the caller proceed.
  */
 export async function ensureAgentRuntimeCurrent(sidecar) {
     if (!sidecar)
         return;
+    // Runtime RPCs bypass the client's ready gate and can queue behind an unfinished handshake.
+    if (chatReadiness(sidecar).condition === 'sidecar_unavailable') {
+        throw new HttpFailure(503, 'The Agent sidecar is not ready; retry once it finishes starting.', { condition: 'sidecar_unavailable' });
+    }
     try {
         await sidecar.call('runtime.ensure_current', {});
     }
@@ -57,6 +63,8 @@ export async function ensureAgentRuntimeCurrent(sidecar) {
 }
 /** 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-1254: how soon a worktree lock the sidecar could not confirm is tried again. */
+export const WORKTREE_RETAIN_RETRY_MS = 60_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
@@ -92,6 +100,8 @@ export class SessionService {
     compressionJobs;
     /** TAL-1005: the turns now waiting on their session's compression job before they read its history. */
     compactionWaiters = new Set();
+    worktreeRetainRetry = null;
+    worktreesUnconfirmed = 0;
     constructor(deps) {
         this.deps = deps;
         this.compressionJobs = new CompressionJobs();
@@ -121,7 +131,7 @@ export class SessionService {
             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). */
+    /** Split qualified ids and opportunistically repair against fresh evidence; missing discovery never delays a turn. */
     turnModel(s, body = {}) {
         const requestedModel = str(body.model) || s.model;
         const requestedProvider = 'model_provider' in body ? body.model_provider : s.model_provider;
@@ -190,87 +200,104 @@ export class SessionService {
         return this.visibleToActiveProfile(session.profile);
     }
     localTargets = null;
-    /** One receipt-backed physical target for every operation on a local conversation alias. */
-    resolveSessionId(sid) {
+    /** One receipt-backed physical target for every operation on a local conversation alias, read on the state.db worker. */
+    async resolveSessionId(sid) {
         try {
             const path = this.stateDbPath(null);
-            const key = JSON.stringify([statSignature(path), statSignature(`${path}-wal`), path]);
+            const stamp = () => JSON.stringify([statSignature(path), statSignature(`${path}-wal`), path]);
+            const key = stamp();
             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);
-                } });
+            const { target, read } = await stateDbSessionReadAsync({ target: sid, read: false }, 'stateDbLocalTargetRead', path, sid);
+            // A failed or changing read cannot seed a routing cache.
+            const targets = this.localTargets;
+            if (read && targets.key === key && stamp() === key) {
+                if (targets.ids.size >= 500)
+                    targets.ids.clear();
+                targets.ids.set(sid, target);
+            }
+            return target;
         }
         catch {
             return sid;
         }
     }
     /** Python `_lookup_cli_session_metadata(...).get('read_only')` plus the persisted sidecar flag and a not-claimable foreign owner. */
-    async isReadOnlyImport(sid) {
+    async isReadOnlyImport(sid, reads = this.sessionGateReads(sid)) {
         try {
             const s = (await this.store.get(sid, { metadataOnly: true }));
-            if ((await this.isReadOnly(s)))
+            if (await this.loadedReadOnlyReason(s, undefined, reads))
                 return true;
         }
         catch {
             // No sidecar: a foreign state.db transcript whose owner refuses claiming is read-only too.
-            const { session, reason } = (await this.claimOrSynthesizeCliSession(sid));
+            const { session, reason } = (await this.claimOrSynthesizeCliSession(sid, undefined, reads));
             if (session && reason === 'not_claimable')
                 return true;
         }
-        const meta = (await this.lookupCliMeta(sid));
+        const meta = await reads.meta();
         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. */
-    async isSubagentViewOnly(sid) {
+    async isSubagentViewOnly(sid, reads = this.sessionGateReads(sid)) {
+        let profile = this.deps.activeProfile();
         try {
             const s = (await this.store.get(sid, { metadataOnly: true, cacheOnMiss: false, promote: false }));
+            profile = s.profile || 'default';
             if (str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() === 'subagent')
                 return true;
         }
         catch { /* no sidecar */ }
-        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, profile = this.deps.activeProfile()) => {
+        // Admission needs authority, not the sidebar's visibility, message counts or enrichment.
+        const owners = await reads.owners(profile);
+        if (!owners)
+            throw new HttpFailure(403, OWNERSHIP_UNAVAILABLE_REASON);
+        const owner = owners.get(sid);
+        return str(typeof owner === 'object' ? owner.source : owner).trim().toLowerCase() === 'subagent';
+    }
+    /** TAL-358: batched `sessions.source` owners from the active profile's state.db, read on the state.db worker (TAL-923). */
+    stateDbSources = async (ids, profile = this.deps.activeProfile()) => {
         try {
-            return stateDbSessionSources(this.stateDbPath(profile), ids);
+            return await stateDbSessionSourcesAsync(this.stateDbPath(profile), ids);
         }
         catch {
             return null;
         }
     };
+    /** The owners of `byProfile`'s ids, read up front, as the synchronous lookup `withOwnerLocks` takes. */
+    async ownerSources(byProfile, read = this.stateDbSources) {
+        const owners = new Map(await Promise.all([...byProfile].map(async ([profile, ids]) => [profile, ids.size ? await read([...ids], profile) : new Map()])));
+        return (_ids, profile = this.deps.activeProfile()) => owners.get(profile) ?? null;
+    }
+    /** `withOwnerLocks` with the owners read on the state.db worker, so a gate or payload never opens state.db on this thread. */
+    async ownerLocked(rows, read) {
+        return withOwnerLocks(rows, await this.ownerSources(ownerLockCandidates(rows), read));
+    }
     /**
      * 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) {
+    async orphanedImports(rows, existing, owners, reads) {
         const candidates = (await this.orphanCandidates(rows));
         if (!candidates.length)
             return new Set();
-        existing ??= agentSessionRowsExisting(this.stateDbPath(null), candidates);
+        existing ??= await (reads ? reads.existing() : agentSessionRowsExistingAsync(this.stateDbPath(null), candidates));
         if (owners === undefined)
-            owners = this.stateDbSources(candidates);
+            owners = await (reads ? reads.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) {
+    async isOrphanedImport(sid, reads = this.sessionGateReads(sid)) {
         try {
-            return (await this.orphanedImports([(await this.store.get(sid, { metadataOnly: true })).compact()])).size > 0;
+            return (await this.orphanedImports([(await this.store.get(sid, { metadataOnly: true })).compact()], undefined, undefined, reads)).size > 0;
         }
         catch {
             return false;
@@ -288,14 +315,14 @@ export class SessionService {
         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 owners = await this.ownerSources(byProfile);
         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,
+            stateDbSources: owners,
             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));
+                const orphans = (await this.orphanedImports(current.filter((r) => checked.has(str(r.session_id))), existing, owners([], activeProfile)));
                 for (const sid of orphans)
                     (await this.store.delete(sid));
                 return orphans;
@@ -303,7 +330,7 @@ export class SessionService {
         };
     }
     /** The persisted flag folded with the state.db owner lock (TAL-358): the one read-only rule for mutation gates and the wire. */
-    async readOnlyReason(s, profile) {
+    async readOnlyReason(s, profile, reads) {
         if (typeof s === 'string') {
             try {
                 s = await this.store.get(s, { metadataOnly: true, cacheOnMiss: false, promote: false });
@@ -313,22 +340,25 @@ export class SessionService {
                     return OWNERSHIP_UNAVAILABLE_REASON;
             }
         }
-        return this.loadedReadOnlyReason(s, profile);
+        return await this.loadedReadOnlyReason(s, profile, reads);
     }
-    loadedReadOnlyReason(s, profile) {
+    async loadedReadOnlyReason(s, profile, reads) {
         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];
+        const row = (await this.ownerLocked([raw], reads ? (_ids, ownerProfile) => reads.owners(ownerProfile) : undefined))[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));
+    /**
+     * The final owner check before a protected sidecar dispatch or write: callers dispatch as soon as it resolves. The
+     * owner is the Agent's, which can change at any moment, so reading it on the state.db worker (TAL-923) widens no
+     * window Web could close; the session lock, where one is held, still serializes Web's own writes.
+     */
+    async assertWritable(session, profile, reads) {
+        const reason = await this.readOnlyReason(session, profile, reads);
+        if (reason)
+            throw new HttpFailure(403, reason);
     }
     /** Controls can exist without a local session file; use the same id the sidecar will address. */
     async idForMutation(sid) {
@@ -350,16 +380,16 @@ export class SessionService {
         }, opts);
     }
     /** Full session for mutation, refusing read-only imports (Python `_get_or_materialize_session`). */
-    async getForMutation(sid) {
-        let s = (await this.get404(sid));
+    async getForMutation(sid, reads) {
+        let s = (await this.get404(sid, {}, reads));
         s = (await this.store.ensureFull(sid, s));
-        this.assertWritable(s);
+        await this.assertWritable(s, undefined, reads?.sid === s.session_id ? reads : undefined);
         if (str(s.source_tag || s.raw_source).trim().toLowerCase() === 'subagent')
             throw new HttpFailure(403, 'Read-only subagent child session');
         return s;
     }
-    async get404(sid, opts = {}) {
-        sid = this.resolveSessionId(sid);
+    async get404(sid, opts = {}, reads) {
+        sid = await this.resolveSessionId(sid);
         try {
             return (await this.store.get(sid, opts));
         }
@@ -367,7 +397,7 @@ export class SessionService {
             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 = (await this.claimOrSynthesizeCliSession(sid));
+                const synth = (await this.claimOrSynthesizeCliSession(sid, undefined, reads));
                 if (synth.session && synth.reason === 'materialized') {
                     await this.store.save(synth.session);
                     await this.store.touch(synth.session);
@@ -382,18 +412,33 @@ export class SessionService {
         }
     }
     /** The Agent's state.db rows for this session (empty for subagent views, which never merge). */
-    stateDbRows(s) {
-        return this.stateDbRead(s).rows;
+    async stateDbRows(s) {
+        return (await this.stateDbRead(s)).rows;
     }
-    /** `stateDbRows` and whether the read succeeded on a state.db whose messages carry ids (TAL-493). */
+    /**
+     * `stateDbRows` and whether the read succeeded on a state.db whose messages carry ids (TAL-493). TAL-1162: read on the
+     * state.db worker; a worker failure is a failed read.
+     */
     stateDbRead(s) {
-        if (str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() === 'subagent')
-            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 });
+        if (isSubagentView(s))
+            return Promise.resolve(failedStateDbRead());
+        return stateDbSessionReadAsync(failedStateDbRead(), 'stateDbSessionRead', this.stateDbPath(s.profile), s.session_id, { stitch: false, lineage: stateDbReadLineage(s) });
+    }
+    /** `stateDbRead`'s projection of the rows past `afterId` alone (the detail's page tail), on the state.db worker. */
+    stateDbTailRead(s, afterId, unidentified) {
+        return stateDbSessionReadAsync(failedStateDbRead(), 'stateDbSessionTailRead', this.stateDbPath(s.profile), s.session_id, afterId, { lineage: stateDbReadLineage(s), unidentified });
+    }
+    /** The one read a turn's settlement builds its context from and settles with (`stateDbSettlementRead`). */
+    settlementRead(s) {
+        const unchanged = { ...failedStateDbRead(), lineage: s.state_db_lineage ?? [s.session_id], rotated: null };
+        if (isSubagentView(s))
+            return Promise.resolve(unchanged);
+        return stateDbSessionReadAsync(unchanged, 'stateDbSettlementRead', this.stateDbPath(s.profile), s.session_id, s.state_db_lineage);
     }
-    /** Preserve existing transcript provenance before a turn adds Agent rows from its starting database read. */
+    /**
+     * Preserve existing transcript provenance before a turn adds Agent rows from its starting database read. The stamp
+     * lands before this returns; the read follows.
+     */
     beginStateDbTurn(s) {
         stampStateDbGeneration([...s.messages, ...s.context_messages], markedStateDbGeneration(s));
         return this.stateDbRead(s);
@@ -406,7 +451,7 @@ export class SessionService {
      * rows (a WebUI conversation continued from the CLI shows the CLI turns). This is the coordinate space `GET
      * /api/session` exposes, so branching and the next model history slice/extend the same list.
      */
-    mergedTranscript(s, local = s.messages, stateRows = this.stateDbRows(s)) {
+    mergedTranscript(s, local, stateRows) {
         if (!stateRows.length)
             return local;
         return mergeSessionMessagesAppendOnly(local, stateRows, { truncationWatermark: s.truncation_watermark, compressedWatermark: s.truncation_watermark_compressed, stateDbSeenId: currentStateDbSeenId(s, stateRows), stateDbGeneration: markedStateDbGeneration(s) });
@@ -416,7 +461,7 @@ export class SessionService {
      * so the merge never replays a covered row and appends every row committed after the read. Call it after the boundary
      * fields are set: the marker holds only while they and the row it names stay as recorded.
      */
-    markStateDbSeen(s, read = this.stateDbRead(s), opts = {}) {
+    markStateDbSeen(s, read, opts = {}) {
         // Freeze numeric provenance before replacing the marker, including after a database replacement.
         const priorGeneration = markedStateDbGeneration(s);
         if (priorGeneration !== null)
@@ -445,7 +490,7 @@ 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 = turn.read ?? this.stateDbRead(s);
+        const read = turn.read;
         const agentAdded = withoutRows(turn.agentRows ?? [], turn.previousContext);
         const contextAdded = withoutRows(s.context_messages, turn.previousContext);
         if (typeof turn.startGeneration === 'string') {
@@ -511,10 +556,10 @@ export class SessionService {
         // The read follows the new lineage from here, and everything it holds now is covered.
         // ponytail: a CLI row committed to the continuation before this settlement is covered with them; telling them apart
         // needs the Agent to mark the rows it writes at rotation.
-        const lineage = stateDbCompressionLineage(this.stateDbPath(s.profile), s.session_id);
+        const lineage = read.lineage;
         if (JSON.stringify(lineage) !== JSON.stringify(s.state_db_lineage ?? [s.session_id])) {
             s.state_db_lineage = lineage.length > 1 ? lineage : null;
-            this.markStateDbSeen(s);
+            this.markStateDbSeen(s, read.rotated ?? failedStateDbRead());
         }
     }
     /**
@@ -548,35 +593,70 @@ export class SessionService {
      */
     modelContext(s, stateRows) {
         const local = s.context_messages.length ? s.context_messages : s.messages.filter((m) => !m._error && !m._partial);
-        return local.some((m) => isContextCompressionMarker(m)) ? local : this.mergedTranscript(s, local, stateRows ?? this.stateDbRows(s));
+        return local.some((m) => isContextCompressionMarker(m)) ? local : this.mergedTranscript(s, local, stateRows);
+    }
+    /** `modelContext` over a state.db read taken now. */
+    async readModelContext(s) {
+        return this.modelContext(s, await this.stateDbRows(s));
     }
     /**
      * TAL-518: the model context a `/btw` clone inherits: the chat's history plus its running turn's prompt, which
      * deferred save keeps out of `messages` and `context_messages` until settlement.
      */
-    sideQuestionContext(s) {
-        const context = structuredClone(this.modelContext(s));
+    async sideQuestionContext(s) {
+        const context = structuredClone(await this.readModelContext(s));
         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) {
+    async isMessagingSession(sid, reads = this.sessionGateReads(sid)) {
         try {
             if (isMessagingSessionRecord((await this.store.get(sid, { metadataOnly: true })).compact()))
                 return true;
         }
         catch { /* absent */ }
-        const meta = (await this.lookupCliMeta(sid));
+        const meta = await reads.meta();
         return meta !== null && isMessagingSessionRecord(meta);
     }
-    /** Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile. */
+    sessionGateReads(sid) {
+        const profile = this.deps.activeProfile();
+        const dbPath = this.stateDbPath(profile);
+        const owners = new Map();
+        let row;
+        let meta;
+        let transcript;
+        let context;
+        let existing;
+        return {
+            sid,
+            owners: (ownerProfile = profile) => {
+                let pending = owners.get(ownerProfile);
+                if (!pending) {
+                    pending = this.stateDbSources([sid], ownerProfile);
+                    owners.set(ownerProfile, pending);
+                }
+                return pending;
+            },
+            row: () => row ??= stateDbSessionReadAsync(null, 'stateDbSessionRow', dbPath, sid),
+            meta: () => meta ??= this.lookupCliMeta(sid),
+            messages: (stitch) => stitch
+                ? transcript ??= isClaudeCodeSessionId(sid) ? Promise.resolve(this.deps.claudeCode?.messages(sid) ?? []) : stateDbSessionReadAsync([], 'stateDbSessionMessages', dbPath, sid, { stitch: true })
+                : context ??= stateDbSessionReadAsync([], 'stateDbSessionMessages', dbPath, sid, { stitch: false }),
+            existing: () => existing ??= agentSessionRowsExistingAsync(dbPath, [sid]),
+        };
+    }
+    /**
+     * Python `_lookup_cli_session_metadata`: the sidebar row for a state.db session in the active profile, else its plain
+     * row (a segment its chain's row does not name). Both are read by id: the sidebar listing would scan every session to
+     * rank its window (TAL-923).
+     */
     async lookupCliMeta(sid) {
         try {
             if (isClaudeCodeSessionId(sid))
                 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;
+            return (await this.deps.cliSessions(profile, { sourceFilter: null, sessionIds: [sid], sidebarRows: true })).rows.find((r) => str(r.session_id) === sid)
+                ?? (await this.deps.cliSessions(profile, { sourceFilter: null, sessionIds: [sid] })).rows[0] ?? null;
         }
         catch {
             return null;
@@ -611,22 +691,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.
      */
-    async claimOrSynthesizeCliSession(sid, metaIn) {
+    async claimOrSynthesizeCliSession(sid, metaIn, reads) {
         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);
+        sid = await this.resolveSessionId(sid);
+        if (reads?.sid !== sid)
+            reads = this.sessionGateReads(sid);
+        const [row, owners] = await Promise.all([reads.row(), reads.owners()]);
         const stateDbSource = str(row?.source).trim().toLowerCase();
         const subagentChild = stateDbSource === 'subagent';
-        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 });
-        const meta = { ...(metaIn ?? (await this.lookupCliMeta(sid)) ?? {}) };
-        if (!msgs.length && !(meta._lineage_root_id && meta._lineage_tip_id))
+        const msgs = await reads.messages(true);
+        const meta = { ...(metaIn ?? (await reads.meta()) ?? {}) };
+        // An owner receipt proves a session before its first turn (a fresh diagnostic chat, TAL-1040); a bare row does not.
+        if (!msgs.length && !(meta._lineage_root_id && meta._lineage_tip_id) && !canonical)
             return { session: null, reason: 'no_foreign_state' };
         if (row) {
             if (!meta.source_tag && stateDbSource)
@@ -648,7 +729,7 @@ export class SessionService {
         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 context = Array.isArray(meta._lineage_ids) ? await reads.messages(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,
@@ -663,9 +744,9 @@ export class SessionService {
         }, defaults);
         return { session, reason: claimable ? 'materialized' : 'not_claimable' };
     }
-    async mutationTarget(sid, verb) {
+    async mutationTarget(sid, verb, reads) {
         try {
-            return (await this.getForMutation(sid));
+            return (await this.getForMutation(sid, reads));
         }
         catch (error) {
             if (error instanceof SessionNotFound)
@@ -683,19 +764,21 @@ export class SessionService {
         if (isClaudeCodeSessionId(sid))
             throw new HttpFailure(400, `Claude Code sessions are view-only and cannot be ${verb} from WebUI`);
     }
-    async rejectViewOnly(sid, verb) {
+    async rejectViewOnly(sid, verb, reads) {
         sid = sid.trim();
+        if (reads?.sid !== sid)
+            reads = this.sessionGateReads(sid);
         this.rejectClaudeCode(sid, verb);
         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 owners = await reads.owners(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)))
+        if ((await this.isSubagentViewOnly(sid, reads)))
             throw new HttpFailure(400, `Subagent sessions are view-only and cannot be ${verb} from WebUI`);
         return sid;
     }
@@ -717,9 +800,13 @@ export class SessionService {
         }
         return redactSessionData(payload, this.deps.redactEnabled());
     }
+    /** Opaque read identity, including context changes that do not alter display message counts. */
+    contextDetailKey(s) {
+        return createHash('sha256').update(JSON.stringify([s.session_id, s.profile, s.model, s.model_provider, s.workspace, s.updated_at, s.messages.length, s.context_messages, s.post_compression_context_tokens_estimate, s.active_stream_id])).digest('hex');
+    }
     /** `compact()` with the wire streaming/read-only flags (TAL-312), for replies that return the session row. */
     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);
+        return withSessionWireFlags((await this.ownerLocked([{ ...s.compact({ contextLengthFor: this.deps.contextLengthFor, modelOptionFor: this.deps.modelOptionFor }), context_detail_key: this.contextDetailKey(s), assistant_name: this.assistantName(s), workspace_name: (await this.workspaceNames([s]))(s) }]))[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).
@@ -765,7 +852,7 @@ export class SessionService {
     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) {
+    async limitedDetail(s, index, limit, before, pending, journaled, retried = false) {
         let prefixEnd = s.messages.length;
         const turnId = pending?.turnId ?? journaled?.turnId;
         if (turnId)
@@ -797,8 +884,18 @@ export class SessionService {
             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] });
+            // TAL-1162: the transcript reads run on the state.db worker. A session that changed meanwhile no longer matches this
+            // index or the lifecycle snapshots: null asks the caller to take them again, and a second change is answered as
+            // read, uncached.
+            const [localRows, localCount, updatedAt, seenId] = [s.messages, s.messages.length, s.updated_at, s.state_db_seen_id];
+            const changed = () => s.messages !== localRows || s.messages.length !== localCount || s.updated_at !== updatedAt || s.state_db_seen_id !== seenId;
+            if (typeof seenId === 'number' && !isSubagentView(s)) {
+                const read = await this.stateDbTailRead(s, seenId, [...index.unidentified, ...context.unidentified]);
+                if (changed()) {
+                    if (!retried)
+                        return null;
+                    cacheable = false;
+                }
                 if (!read.ok)
                     cacheable = false;
                 const markerRows = read.anchor ? [read.anchor, ...read.rows] : read.rows;
@@ -808,14 +905,19 @@ export class SessionService {
                     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);
+                        appended = appendStateDbIdentityRows(read.rows, seenId, index.identities[mode], index.unidentified[mode], index.generation, includeUids);
                         stateRows = read.rows;
-                        effectiveSeenId = s.state_db_seen_id;
+                        effectiveSeenId = seenId;
                     }
                 }
             }
             if (appended === null) {
-                stateRows = this.stateDbRows(s);
+                stateRows = await this.stateDbRows(s);
+                if (changed()) {
+                    if (!retried)
+                        return null;
+                    cacheable = false;
+                }
                 effectiveSeenId = currentStateDbSeenId(s, stateRows);
                 appended = this.mergedTranscript(s, s.messages, stateRows).slice(s.messages.length);
             }
@@ -827,12 +929,12 @@ export class SessionService {
             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 sources = async (ids, profile) => {
                 const ownerKey = JSON.stringify([ids, profile]);
                 const existing = owners.get(ownerKey);
                 if (existing)
                     return existing;
-                const result = this.stateDbSources(ids, profile);
+                const result = await this.stateDbSources(ids, profile);
                 if (result)
                     owners.set(ownerKey, result);
                 return result;
@@ -923,7 +1025,7 @@ export class SessionService {
     async detail(sid, query) {
         if (!sid)
             throw new HttpFailure(400, 'session_id is required');
-        sid = this.resolveSessionId(sid);
+        sid = await this.resolveSessionId(sid);
         const loadMessages = (query.messages ?? '1') !== '0';
         const msgLimit = parseMsgLimit(query.msg_limit ?? null);
         const msgBeforeRaw = query.msg_before;
@@ -942,11 +1044,28 @@ export class SessionService {
             throw new HttpFailure(404, 'Session not found');
         }
         await this.clearStaleStreamState(s);
-        const journaled = loadMessages ? (await this.journaledActiveTurn(s)) : null;
-        const pending = loadMessages ? this.pendingTurn(s) : null;
-        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) : [];
+        return this.detailPayload(s, loadMessages, msgLimit, msgBefore, revisionBefore);
+    }
+    /** Project an already settled session without reloading it or running endpoint recovery/profile gates. */
+    async windowedDetail(s, limit) {
+        return this.detailPayload(s, true, limit, null, await this.loadRevision(s));
+    }
+    async detailPayload(s, loadMessages, msgLimit, msgBefore, revisionBefore) {
+        // TAL-1162: the full transcript read runs on the state.db worker before the lifecycle snapshots are taken, so they
+        // describe the session the payload is built from.
+        const stateRows = loadMessages && msgLimit === null ? await this.stateDbRows(s) : [];
+        let journaled = loadMessages ? (await this.journaledActiveTurn(s)) : null;
+        let pending = loadMessages ? this.pendingTurn(s) : null;
+        let prefix = loadMessages && msgLimit !== null ? this.prefixIndex(s, revisionBefore) : null;
+        let limited = prefix && msgLimit !== null ? (await this.limitedDetail(s, prefix, msgLimit, msgBefore, pending, journaled)) : null;
+        if (prefix && msgLimit !== null && !limited) {
+            // The session changed during the page's transcript read: every snapshot is taken again, once.
+            revisionBefore = await this.loadRevision(s);
+            journaled = await this.journaledActiveTurn(s);
+            pending = this.pendingTurn(s);
+            prefix = this.prefixIndex(s, revisionBefore);
+            limited = await this.limitedDetail(s, prefix, msgLimit, msgBefore, pending, journaled, true);
+        }
         let transcript = loadMessages && !limited ? this.mergedTranscript(s, s.messages, stateRows) : [];
         if (pending && !limited)
             transcript = withPendingUserTurn(transcript, pending);
@@ -982,6 +1101,8 @@ export class SessionService {
         let toolCalls = loadMessages ? s.tool_calls : [];
         if (windowed)
             toolCalls = prefix ? prefix.toolCalls(offset, truncated.length, true) : toolCallsForMessageWindow(toolCalls, offset, truncated.length);
+        if (loadMessages && s.active_stream_id && msgBefore === null)
+            toolCalls = [...toolCalls, ...(this.deps.runtime.liveToolProgress?.(s.active_stream_id) ?? [])];
         const mergedCount = summaryCount ?? all.length;
         let mergedLast = summaryLast ?? 0;
         if (summaryLast === null && all.length) {
@@ -1019,7 +1140,7 @@ export class SessionService {
         raw._msg_limit_max = MAX_MSG_LIMIT;
         const revisionAfter = (await this.loadRevision(s));
         raw._load_revision = revisionBefore !== null && revisionBefore === revisionAfter ? hashRevision(revisionBefore) : `unstable-${randomUUID().replace(/-/g, '')}`;
-        Object.assign(raw, withOwnerLocks([raw], limited?.sources ?? this.stateDbSources)[0]);
+        Object.assign(raw, (await this.ownerLocked([raw], limited?.sources))[0]);
         raw.assistant_name = this.assistantName(s);
         raw.workspace_name = (await this.workspaceNames([s]))(s);
         raw.branched_from = (await this.branchedFrom(s));
@@ -1058,10 +1179,10 @@ export class SessionService {
             // 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);
+            const row = await stateDbSessionReadAsync(null, 'stateDbSessionRow', dbPath, parentId);
             if (!row || (await this.store.wasDeleted(parentId)) || (await this.indexMarksWasWebui(parentId)))
                 return null;
-            if (!stateDbSessionMessages(dbPath, parentId, { stitch: true }).length)
+            if (!(await stateDbSessionReadAsync(false, 'stateDbSessionHasMessages', dbPath, parentId)))
                 return null;
             title = row.title;
         }
@@ -1093,7 +1214,7 @@ export class SessionService {
     }
     /** A session without a sidecar, synthesized from state.db for this profile; 404/409 like the detail. */
     async foreignSession(sid) {
-        sid = this.resolveSessionId(sid);
+        sid = await 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';
@@ -1125,7 +1246,7 @@ export class SessionService {
             assistant_name: this.assistantName(synth), workspace_name: (await this.workspaceNames([synth]))(synth), confirms_deep_truncate: true,
         };
         attachTodoState(sess, msgs);
-        const merged = withSessionWireFlags(withOwnerLocks([meta ? mergeCliSidebarMetadata(sess, meta) : sess], this.stateDbSources)[0], this.deps.runtime.activeStreamIds);
+        const merged = withSessionWireFlags((await this.ownerLocked([meta ? mergeCliSidebarMetadata(sess, meta) : sess]))[0], this.deps.runtime.activeStreamIds);
         const publicRow = redactSessionData(merged, this.deps.redactEnabled());
         return this.owner ? await this.owner.project(publicRow, msgLimit, msgBefore, loadMessages) : publicRow;
     }
@@ -1170,7 +1291,7 @@ export class SessionService {
         const attachments = [...target.pending_attachments];
         // The run's starting read died with its worker: the state.db rows from before it started stand in for it. Its own
         // rows open with its prompt and run to the next prompt; anything else another client wrote meanwhile stays.
-        const read = this.stateDbRead(target);
+        const read = await this.settlementRead(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 runRows = read.rows.filter((m) => Number(m.timestamp) >= runStart);
@@ -1235,17 +1356,25 @@ export class SessionService {
         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;
+        let agentStorage = cliRead?.storage;
+        // TAL-1040: diagnostic chats Web started are Web chats, read even when external Agent sessions are hidden.
+        const webDiagnosticIds = new Set(params.sourceFilter ? [] : await stateDbWebDiagnosticIdsAsync(join(this.deps.profileHome(activeProfile), 'state.db')));
+        const unread = [...webDiagnosticIds].filter((id) => !cliRows?.some((row) => sessionLineageIds(row).has(id)));
+        if (unread.length) {
+            const extra = await this.deps.cliSessions(activeProfile, { sourceFilter: null, sessionIds: unread, keepEmpty: true });
+            cliRows = [...(cliRows ?? []), ...extra.rows];
+            agentStorage ??= extra.storage;
+        }
         const gatewayIdentity = loadGatewaySessionIdentityMap(join(this.deps.profileHome(activeProfile), 'sessions', 'sessions.json'));
         const truncatedSources = cliRead?.truncated;
-        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 }));
+        const lookups = await withStateDbListingReads(() => 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, webDiagnosticIds, 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) {
@@ -1255,7 +1384,7 @@ export class SessionService {
             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);
+        sessions = await this.ownerLocked(sessions);
         const redact = this.deps.redactEnabled();
         const workspaceName = await this.workspaceNames(sessions);
         const redactRow = (item) => {
@@ -1347,6 +1476,29 @@ export class SessionService {
             input_tokens: inp, output_tokens: out, total_tokens: inp + out, estimated_cost: full.estimated_cost,
         };
     }
+    async contextDetail(sid, expectedKey) {
+        if (await this.owner?.isOwned(sid))
+            return this.owner.contextDetail(sid, expectedKey);
+        const session = await this.get404(sid);
+        const profile = this.deps.activeProfile();
+        if (session.profile && session.profile !== profile || await this.loadedReadOnlyReason(session))
+            return unavailableContextDetail();
+        const sidecar = this.deps.sidecar?.();
+        if (!sidecar)
+            return unavailableContextDetail();
+        // The read owns no cache. Compression and model/workspace replacement invalidate its response.
+        const marks = (current = session) => this.contextDetailKey(current);
+        const before = marks();
+        if (before !== expectedKey)
+            return unavailableContextDetail('changed');
+        try {
+            const detail = await sidecar.call('chat.context_detail', { session_id: sid, profile_home: this.deps.profileHome(profile), model: session.model, model_provider: session.model_provider, workspace: session.workspace });
+            return this.deps.activeProfile() === profile && before === marks(await this.get404(sid)) ? detail : unavailableContextDetail('changed');
+        }
+        catch {
+            return unavailableContextDetail();
+        }
+    }
     async usage(sid) {
         const s = (await this.get404(sid));
         const inp = Math.trunc(s.input_tokens) || 0;
@@ -1407,6 +1559,36 @@ export class SessionService {
             this.publish('session_new', s.profile, s.session_id);
         return s;
     }
+    /**
+     * TAL-1040: an `ignore_config` / `safe` chat starts through the active profile's Agent owner, which freezes the mode before
+     * any Agent import. That owner reads no profile default, so the launch route is explicit: the requested model, else this
+     * profile's default as a normal chat starts, with that provider's configured endpoint.
+     */
+    async createDiagnostic(body, mode) {
+        const profile = (typeof body.profile === 'string' && body.profile) || this.deps.activeProfile();
+        if (profile !== this.deps.activeProfile())
+            throw new HttpFailure(400, 'A diagnostic chat starts in the active profile');
+        if (!this.owner)
+            throw new HttpFailure(409, 'The Agent cannot start a chat in this mode', { code: 'execution_mode_unavailable', reason: 'gateway_unavailable' });
+        const defaults = await this.store.deps.defaults(profile);
+        let workspace;
+        try {
+            workspace = await this.resolveNewSessionWorkspace(body, null, profile);
+        }
+        catch (error) {
+            throw new HttpFailure(400, error.message);
+        }
+        const [requested, requestedProvider] = this.deps.modelStateFromRequest(body.model, body.model_provider, null);
+        const model = requested ?? defaults.model;
+        const provider = requested ? requestedProvider : requestedProvider ?? defaults.modelProvider ?? null;
+        if (!model)
+            throw new HttpFailure(400, 'Choose a model before starting a diagnostic chat');
+        const toolsets = this.validateToolsetsShape(body.enabled_toolsets);
+        const route = provider ? this.deps.profileLaunchRoute?.(profile, provider) ?? { provider, baseUrl: null } : null;
+        const sid = await this.owner.create(profile, typeof body.request_id === 'string' ? body.request_id : null, { execution_mode: mode, cwd: workspace ?? defaults.workspace, model,
+            ...(route ? { provider: route.provider } : {}), ...(route?.baseUrl ? { base_url: route.baseUrl } : {}), ...(toolsets ? { toolsets } : {}) });
+        return this.detail(sid, {});
+    }
     // ── simple metadata mutations ────────────────────────────────────────────
     /** Python `_persist_generated_session_title`: title + generated/manual flags under the session lock, then insights sync. */
     async persistGeneratedTitle(sid, nextTitle, eventReason) {
@@ -1431,7 +1613,8 @@ export class SessionService {
         return current;
     }
     async rename(sid, rawTitle) {
-        const s = (await this.mutationTarget(sid, 'renamed'));
+        const reads = this.sessionGateReads(sid);
+        const s = (await this.mutationTarget(sid, 'renamed', reads));
         await this.withMutationLock(sid, async () => {
             applySessionTitleRename(s, rawTitle);
             await this.store.save(s);
@@ -1449,8 +1632,9 @@ export class SessionService {
         return run;
     }
     async pinUnserialized(sid, pinRequested) {
-        await this.rejectViewOnly(sid, 'modified');
-        let s = (await this.get404(sid));
+        const reads = this.sessionGateReads(sid);
+        await this.rejectViewOnly(sid, 'modified', reads);
+        let s = (await this.get404(sid, {}, reads));
         s = (await this.store.ensureFull(sid, s));
         if (pinRequested && !s.pinned) {
             const rows = (await allSessions(this.store));
@@ -1470,16 +1654,143 @@ export class SessionService {
         this.publish('session_pin', s.profile, s.session_id);
         return { ok: true, session: (await this.wireRow(s)) };
     }
+    /**
+     * TAL-1254: relock the worktrees of every unarchived worktree chat (or just `only`) for the running sidecar, so the
+     * Agent's worktree sweep reads them as live, and flag each one git no longer has as retained. Runs before a
+     * (re)started sidecar reports ready and when a chat is unarchived. The Agent's sweep runs outside Talaria, so a lock
+     * the sidecar could not confirm is retried until git takes it; meanwhile that tree keeps its flag.
+     */
+    async retainWorktrees(call, only) {
+        const { rows, unread } = only ? { rows: [only.compact()], unread: 0 } : await this.worktreeSessionRows();
+        const targets = rows.filter((row) => !row.archived && typeof row.worktree_path === 'string' && row.worktree_path && typeof row.session_id === 'string');
+        if (!targets.length) {
+            if (unread)
+                this.retryWorktreeRetention();
+            return;
+        }
+        let results;
+        try {
+            ({ results } = await call('worktree.retain', { paths: [...new Set(targets.map((row) => String(row.worktree_path)))] }));
+        }
+        catch (error) {
+            this.retryWorktreeRetention();
+            throw error;
+        }
+        const unconfirmed = targets.filter((row) => !results[String(row.worktree_path)]).length + unread;
+        if (!only && unconfirmed !== this.worktreesUnconfirmed)
+            this.deps.log(`[webui] ${String(unconfirmed)} worktree lock(s) not yet held by the sidecar${unconfirmed ? '; retrying' : ''}`);
+        if (!only)
+            this.worktreesUnconfirmed = unconfirmed;
+        if (unconfirmed)
+            this.retryWorktreeRetention();
+        for (const row of targets) {
+            const state = results[String(row.worktree_path)];
+            const sid = String(row.session_id);
+            if (!state)
+                continue;
+            try {
+                // `extra` follows the transcript in the file, past what a metadata-only read sees.
+                if (row._unread)
+                    continue;
+                const s = await this.store.ensureFull(sid, await this.store.get(sid, { metadataOnly: true }));
+                if ((state === 'missing') === (s.extra[WORKTREE_RETAINED_KEY] === true))
+                    continue;
+                await this.withMutationLock(sid, async () => {
+                    s.extra = Object.fromEntries(Object.entries(s.extra).filter(([key]) => key !== WORKTREE_RETAINED_KEY));
+                    if (state === 'missing')
+                        s.extra[WORKTREE_RETAINED_KEY] = true;
+                    await this.store.save(s, { touchUpdatedAt: false });
+                }, { allowReadOnly: true });
+                this.publish('session_worktree', s.profile, sid);
+            }
+            catch (error) {
+                if (error instanceof SessionNotFound)
+                    continue;
+                this.deps.log(`[webui] could not record the worktree state of ${sid}: ${error.message}`);
+                this.retryWorktreeRetention();
+            }
+        }
+    }
+    /**
+     * Every persisted worktree chat, read from its own file: the index only narrows the files to read, since a crash
+     * between a save and its index update can leave a session out of the index or with a stale `archived`. A file that
+     * cannot be read now, or a session directory that cannot be listed, falls back to the index rows (`_unread`, so their
+     * flags are left alone) and counts in `unread`, which keeps retention retrying until every file has been read.
+     */
+    async worktreeSessionRows() {
+        let indexed;
+        try {
+            indexed = new Map((await this.store.readIndexEntries()).map((row) => [str(row.session_id), row]));
+        }
+        catch {
+            indexed = new Map();
+        }
+        let persisted;
+        try {
+            persisted = await this.store.persistedIds({ strict: true });
+        }
+        catch {
+            // The session directory cannot be listed now: retain what the index names and retry until it can.
+            const rows = [...indexed.values()].filter((row) => row.worktree_path).map((row) => ({ ...row, archived: false, _unread: true }));
+            return { rows, unread: Math.max(1, rows.length) };
+        }
+        const candidates = [...persisted].filter((sid) => !indexed.has(sid) || indexed.get(sid)?.worktree_path);
+        let unread = 0;
+        const rows = await Promise.all(candidates.map(async (sid) => {
+            try {
+                return (await this.store.get(sid, { metadataOnly: true })).compact();
+            }
+            catch (error) {
+                if (error instanceof SessionNotFound)
+                    return null;
+                unread += 1;
+                const row = indexed.get(sid);
+                return row?.worktree_path ? { ...row, archived: false, _unread: true } : null;
+            }
+        }));
+        return { rows: rows.filter((row) => row !== null), unread };
+    }
+    /** One pending retry at a time; a sidecar that is not ready by then retains everything in its next ready gate instead. */
+    retryWorktreeRetention() {
+        if (this.worktreeRetainRetry)
+            return;
+        this.worktreeRetainRetry = setTimeout(() => {
+            this.worktreeRetainRetry = null;
+            const sidecar = this.deps.sidecar?.();
+            if (sidecar?.status !== 'ready')
+                return;
+            this.retainWorktrees((method, params, opts) => sidecar.call(method, params, opts)).catch((error) => { this.deps.log(`[webui] worktree lock retry failed: ${String(error)}`); });
+        }, WORKTREE_RETAIN_RETRY_MS);
+        this.worktreeRetainRetry.unref();
+    }
     async archive(sid, archived) {
-        await this.rejectViewOnly(sid, 'archived');
-        let s = (await this.get404(sid));
+        const reads = this.sessionGateReads(sid);
+        await this.rejectViewOnly(sid, 'archived', reads);
+        let s = (await this.get404(sid, {}, reads));
         s = (await this.store.ensureFull(sid, s));
         await this.withMutationLock(sid, async () => {
+            s = await this.store.ensureFull(sid, await this.store.get(sid));
+            const previous = { archived: s.archived, pinned: s.pinned };
+            const wasArchived = (await this.store.loadMetadataOnly(sid))?.archived ?? false;
             s.archived = archived;
             if (archived)
                 s.pinned = false;
-            await this.store.save(s, { touchUpdatedAt: false });
+            try {
+                await this.store.save(s, { touchUpdatedAt: false });
+                const saved = await this.store.loadMetadataOnly(sid);
+                if (saved?.archived !== archived || saved.pinned !== s.pinned)
+                    throw new HttpFailure(409, 'Archive was not saved; reload the chat and retry');
+            }
+            catch (error) {
+                Object.assign(s, previous);
+                throw error;
+            }
+            if (archived && !wasArchived)
+                await this.finalizeSession(sid, s.profile, 'archive', stateDbReadLineage(s) ?? undefined);
         }, { allowReadOnly: true });
+        const sidecar = this.deps.sidecar?.();
+        if (!archived && sidecar)
+            await this.retainWorktrees((method, params, opts) => sidecar.call(method, params, opts), s).catch(() => undefined);
         this.publish('session_archive', s.profile, s.session_id);
         return { ok: true, session: (await this.wireRow(s)), ...worktreeRetainedPayload(s) };
     }
@@ -1507,10 +1818,11 @@ export class SessionService {
     }
     modelConfirmationKey = randomUUID();
     async confirmModelSwitch(s, model, provider, token, retry = false) {
+        const stateRows = await this.stateDbRows(s);
         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 messages = this.modelContext(s, stateRows);
         const before = JSON.stringify([s.model, s.model_provider, context, s.context_length, messages]);
         let decision;
         try {
@@ -1522,7 +1834,8 @@ export class SessionService {
         catch (error) {
             throw new HttpFailure(503, `Cannot check model selection warnings: ${error.message}`);
         }
-        if (before !== JSON.stringify([s.model, s.model_provider, contextUsage(s).context_used_tokens, s.context_length, this.modelContext(s)])) {
+        const stateRowsAfter = await this.stateDbRows(s);
+        if (before !== JSON.stringify([s.model, s.model_provider, contextUsage(s).context_used_tokens, s.context_length, this.modelContext(s, stateRowsAfter)])) {
             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);
@@ -1556,7 +1869,7 @@ export class SessionService {
             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);
+            await this.assertWritable(s);
             s.workspace = newWs;
             if (hasModel) {
                 s.model = nextModel;
@@ -1564,9 +1877,10 @@ export class SessionService {
                 if (changed) {
                     s.context_length = contextLength;
                     forgetContextFigures(s);
-                    await this.deps.runtime.evictAgent(sid);
                 }
             }
+            if (changed || oldWs !== newWs)
+                await this.deps.runtime.evictAgent(sid);
             await this.store.save(s);
         });
         if (str(oldWs) !== str(newWs))
@@ -1619,7 +1933,7 @@ export class SessionService {
             throw new HttpFailure(400, 'keep_count must be non-negative');
         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);
+            const read = await 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.
@@ -1745,7 +2059,7 @@ export class SessionService {
             return false;
         let tokens;
         try {
-            tokens = (await sidecar.call('models.estimate_tokens', { messages: this.modelContext(s) })).tokens;
+            tokens = (await sidecar.call('models.estimate_tokens', { messages: await this.readModelContext(s) })).tokens;
         }
         catch {
             return false;
@@ -1786,7 +2100,7 @@ export class SessionService {
     async compressionTarget(sid) {
         await this.rejectViewOnly(sid, 'compressed');
         const s = (await this.mutationTarget(sid, 'compressed'));
-        const stateRows = this.stateDbRows(s);
+        const stateRows = await this.stateDbRows(s);
         const context = this.compressionContext(s, stateRows);
         return { s, history: sanitizeMessagesForApi(context), context, stateRows };
     }
@@ -1830,7 +2144,7 @@ export class SessionService {
     }
     /** 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);
+        const rounds = await stateDbSessionReadAsync(0, 'countConversationRounds', (await this.handoffTarget(sid)).dbPath, sid, since);
         return { ok: true, rounds, threshold: CONVERSATION_ROUND_THRESHOLD, should_show: rounds >= CONVERSATION_ROUND_THRESHOLD };
     }
     /**
@@ -1839,40 +2153,41 @@ export class SessionService {
      * back to a deterministic local summary rather than an error.
      */
     async handoffSummary(sid, since) {
-        sid = (await this.rejectViewOnly(sid, 'summarized'));
+        const reads = this.sessionGateReads(sid.trim());
+        sid = (await this.rejectViewOnly(sid, 'summarized', reads));
         const { local, profile, dbPath } = (await this.handoffTarget(sid));
-        const rounds = countConversationRounds(dbPath, sid, since);
+        const rounds = await stateDbSessionReadAsync(0, '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 all = await stateDbSessionReadAsync([], '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 meta = local ? null : (await reads.meta());
+        const generated = await this.generateHandoffSummary(sidecar, profile, local, meta, messages, [...all, ...(local?.messages ?? []), ...(local?.context_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 cliRow = meta ?? (await reads.meta());
         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) {
+    async generateHandoffSummary(sidecar, profile, local, meta, messages, source) {
         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 prompt = withDataUseRequirements([{ role: 'system', content: HANDOFF_SYSTEM_PROMPT }, { role: 'user', content: `Conversation transcript:\n${handoffTranscript(messages)}` }], source);
         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);
@@ -1898,7 +2213,7 @@ export class SessionService {
         const card = messageHandoffPayload(marker);
         const toStateDb = async () => {
             await this.rejectViewOnly(sid, 'summarized');
-            if (sameHandoff(handoffPayload(stateDbTailToolContent(this.stateDbPath(profile), sid)), card))
+            if (sameHandoff(handoffPayload(await stateDbSessionReadAsync(null, 'stateDbTailToolContent', this.stateDbPath(profile), sid)), card))
                 return true;
             const sidecar = this.deps.sidecar?.();
             if (!sidecar)
@@ -2003,11 +2318,11 @@ export class SessionService {
                 catch {
                     throw new HttpFailure(404, 'Session not found');
                 }
+                // One state.db read serves the check, the kept display rows, and the boundary; every gate below decides after it.
+                const read = await this.stateDbRead(live);
                 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;
                 const tail = turnTail(this.modelContext(live, stateRows).filter((m) => !turn || m._turn_id !== turn), context);
                 if (!tail || !turnTail(live.messages, s.messages))
@@ -2090,8 +2405,8 @@ export class SessionService {
             }
         }
     }
-    /** Clear and delete share the profile-scoped, best-effort Agent session boundary. */
-    async finalizeSession(sid, profile, reason) {
+    /** Profile-scoped, best-effort lifecycle delivery; archive only notifies plugins. */
+    async finalizeSession(sid, profile, reason, lineage) {
         const sidecar = this.deps.sidecar?.();
         if (!sidecar || this.deps.profileDeleting?.(profile))
             return [];
@@ -2099,10 +2414,11 @@ export class SessionService {
         try {
             return (await sidecar.call('chat.finalize_session', {
                 session_id: sid, profile_home: this.deps.profileHome(profile ?? this.deps.activeProfile()), reason,
+                ...(lineage ? { lineage } : {}),
             }, { timeoutMs: 12_000 })).messages;
         }
-        catch (error) {
-            this.deps.log(`[webui] session finalize (${reason}) failed: ${error.message}`);
+        catch {
+            this.deps.log(`[webui] session lifecycle (${reason}) failed`);
             return [];
         }
         finally {
@@ -2114,6 +2430,8 @@ export class SessionService {
         const s = (await this.mutationTarget(sid, 'modified'));
         await this.withMutationLock(sid, async () => {
             const messages = await this.finalizeSession(sid, s.profile, 'clear');
+            // The boundary covers every row this read saw, the session's finalization rows included.
+            const read = await this.stateDbRead(s);
             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() }));
@@ -2139,7 +2457,7 @@ export class SessionService {
             s.pending_user_source = null;
             s.clear_generation = hadMessages ? randomUUID().replace(/-/g, '') : null;
             applySessionTitleRename(s, 'Untitled');
-            this.markStateDbSeen(s, undefined, { boundary: true });
+            this.markStateDbSeen(s, read, { boundary: true });
             await this.store.save(s);
             if (hadMessages) {
                 try {
@@ -2155,6 +2473,7 @@ export class SessionService {
         await this.rejectViewOnly(sid, 'modified');
         return this.withMutationLock(sid, async () => {
             const s = (await this.mutationTarget(sid, 'modified'));
+            const read = await this.stateDbRead(s);
             const history = s.messages;
             const lastUser = findLastUserIndex(history);
             if (lastUser === null)
@@ -2170,7 +2489,7 @@ export class SessionService {
                 return { error: 'The last message has nothing to resend.' };
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
-            this.markStateDbSeen(s, undefined, { boundary: true });
+            this.markStateDbSeen(s, read, { boundary: true });
             await this.store.save(s);
             return { ok: true, last_user_text: lastUserText, last_user_prompt: lastUserPrompt, last_user_attachments: lastUserAttachments, removed_count: removed };
         });
@@ -2179,6 +2498,7 @@ export class SessionService {
         await this.rejectViewOnly(sid, 'modified');
         return this.withMutationLock(sid, async () => {
             const s = (await this.mutationTarget(sid, 'modified'));
+            const read = await this.stateDbRead(s);
             const history = s.messages;
             const lastUser = findLastUserIndex(history);
             if (lastUser === null)
@@ -2186,7 +2506,7 @@ export class SessionService {
             const removedText = extractText(history[lastUser]?.content);
             const removed = history.length - lastUser;
             shrinkTo(s, lastUser);
-            this.markStateDbSeen(s, undefined, { boundary: true });
+            this.markStateDbSeen(s, read, { boundary: true });
             await this.store.save(s);
             const preview = removedText.length > 40 ? `${removedText.slice(0, 40)}...` : removedText;
             return { ok: true, removed_count: removed, removed_preview: preview };
@@ -2239,14 +2559,14 @@ export class SessionService {
             catch { /* ignore */ }
         }
         // Python: `keep_count` indexes the merged display transcript, never the raw sidecar array.
-        const sourceMessages = this.mergedTranscript(source);
+        const stateRows = await this.stateDbRows(source);
+        const sourceMessages = this.mergedTranscript(source, source.messages, stateRows);
         const forked = keepCount !== null ? sourceMessages.slice(0, keepCount) : [...sourceMessages];
         const title = customTitle ?? `${source.title || 'Untitled'} (fork)`;
         const forkKeep = keepCount ?? sourceMessages.length;
         // The branch's model context must carry the retained state.db rows too: the new id has no state.db rows of its
         // own, and the runner prefers a non-empty context over the displayed messages.
-        const stateRows = this.stateDbRows(source);
-        const sourceContext = stateRows.length ? this.mergedTranscript(source, source.context_messages.length ? source.context_messages : source.messages) : source.context_messages;
+        const sourceContext = stateRows.length ? this.mergedTranscript(source, source.context_messages.length ? source.context_messages : source.messages, stateRows) : 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: withMirrorSources(forked, source), project_id: source.project_id,
@@ -2263,11 +2583,11 @@ export class SessionService {
     }
     /** Python `read_session_lineage_report` on the active profile's state.db. */
     lineageReport(sid) {
-        return stateDbLineageReport(this.stateDbPath(null), sid);
+        return stateDbSessionReadAsync(emptyLineageReport(sid.trim()), '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 };
+        return { store: this.store, stateDbPath: this.stateDbPath(null), profile: this.deps.activeProfile(), stampingSince: await this.deps.recoveryStampingSince(), isReadOnly: async (sid, profile) => Boolean((await this.ownerLocked([{ session_id: sid, profile }]))[0]?.read_only), log: this.deps.log };
     }
     async recoveryAudit() {
         return (await auditSessionRecovery(await this.recoveryDeps()));
@@ -2301,6 +2621,7 @@ export class SessionService {
                 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,
+                ...(source.extra[WORKTREE_RETAINED_KEY] === true ? { [WORKTREE_RETAINED_KEY]: true } : {}),
                 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: [] },
@@ -2360,13 +2681,14 @@ 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');
+        const reads = this.sessionGateReads(sid);
+        await this.rejectViewOnly(sid, 'deleted', reads);
         // 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. An orphan has none.
-        const orphaned = (await this.isOrphanedImport(sid));
-        if (!orphaned && (await this.isReadOnlyImport(sid)))
+        const orphaned = (await this.isOrphanedImport(sid, reads));
+        if (!orphaned && (await this.isReadOnlyImport(sid, reads)))
             throw new HttpFailure(400, 'Read-only imported sessions cannot be deleted from WebUI');
-        if ((await this.isSubagentViewOnly(sid)))
+        if ((await this.isSubagentViewOnly(sid, reads)))
             throw new HttpFailure(400, 'Subagent sessions are view-only and cannot be deleted from WebUI');
         const retained = (await (async () => { try {
             return worktreeRetainedPayload((await this.store.get(sid, { metadataOnly: true })));
@@ -2382,8 +2704,8 @@ export class SessionService {
             eventProfile = null;
         }
         // Python `_is_messaging_session_id`: decided before the JSON is gone, from WebUI metadata or the Agent's row.
-        const isMessaging = (await this.isMessagingSession(sid));
-        const knownIds = !isMessaging && !orphaned ? stateDbCompressionLineage(this.stateDbPath(eventProfile), sid) : [sid];
+        const isMessaging = (await this.isMessagingSession(sid, reads));
+        const knownIds = !isMessaging && !orphaned ? await stateDbSessionReadAsync([sid], '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'); };
@@ -2693,7 +3015,7 @@ export class SessionService {
                 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 };
+            return { session, transcript: this.mergedTranscript(session, session.messages, await this.stateDbRows(session)), stored: true };
         }
         catch (error) {
             if (error instanceof HttpFailure)
@@ -2819,6 +3141,18 @@ function findLastUserIndex(history) {
 export function sanitizePaths(error) {
     return str(error?.message ?? error).replace(/(?:(?:\/[a-zA-Z0-9_.-]+)+|(?:[A-Z]:\\[^\s]+))/g, '<path>');
 }
+/** A failed state.db read says nothing (TAL-493). */
+function failedStateDbRead() {
+    return { rows: [], idCapable: false, ok: false, reason: null, generation: null };
+}
+/** TAL-529: after a compression rotation the Agent writes to the continuation, so a read follows the recorded lineage. */
+function stateDbReadLineage(s) {
+    return s.state_db_lineage?.[0] === s.session_id ? s.state_db_lineage : null;
+}
+/** A delegated child's view, which never merges state.db rows. */
+function isSubagentView(s) {
+    return str(s.source_tag || s.raw_source || s.session_source).trim().toLowerCase() === 'subagent';
+}
 /** TAL-536: a dead run's own state.db rows: from its prompt to the next prompt (tool results and applied steers stay in it). */
 function runStateDbRows(rows, prompt) {
     const at = rows.findIndex((m) => looksLikeCurrentUserTurn(m, prompt));