@maudecode/talaria-web 1.17.2 → 1.19.0

package/dist/sessions/list.js

@@ -10,54 +10,12 @@ import { createHash } from 'node:crypto';
 import { redactText } from '../redact.js';
 import { CONTEXT_USAGE_FIELDS, Session, contextUsage, sharePath, stripSidebarHeavyMetadata } from './session.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
-import { isCliSessionRow as isStateDbCliRow, isCliSessionRowVisible, normalizeAgentSessionSource } from './state-db.js';
+import { AGENT_STORAGE_OK, CANONICAL_READ_ONLY_REASON, OWNERSHIP_UNAVAILABLE_REASON, isCliSessionRow as isStateDbCliRow, isCliSessionRowVisible, normalizeAgentSessionSource } from './state-db.js';
 import { MESSAGING_SOURCES, sourceKind } from './source-kind.js';
-import { SessionRowSchema } from '@maudecode/talaria-web-contracts';
+import {} from '@maudecode/talaria-web-contracts';
 const num = (v) => { const n = Number(v ?? 0); return Number.isFinite(n) && n > 0 ? n : 0; };
-const malformedFiles = new WeakMap();
-/** Read-only projection; never let a corrupt identity acquire a generated ID. */
-export function sanitizeSessionRow(value, store, file) {
-    const row = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-    file ??= `${str(row.session_id)}.json`;
-    const mismatchedFile = file.endsWith('.json') && file !== '_index.json' && row.session_id !== file.slice(0, -5);
-    if (!SessionRowSchema.shape.session_id.safeParse(row.session_id).success || mismatchedFile) {
-        const logged = malformedFiles.get(store) ?? new Set();
-        if (!logged.has(file)) {
-            store.deps.log(`[webui] WARNING: skipping session row with invalid session_id in ${JSON.stringify(file)}`);
-            logged.add(file);
-            malformedFiles.set(store, logged);
-        }
-        return null;
-    }
-    const result = { ...row, title: row.title ?? '' };
-    for (const [key, schema] of Object.entries(SessionRowSchema.shape)) {
-        const value = result[key];
-        if (value === undefined || schema.safeParse(value).success)
-            continue;
-        const coerced = typeof value === 'string' && value.trim() !== ''
-            ? value.trim() === 'true' ? true : value.trim() === 'false' ? false : Number(value)
-            : typeof value === 'number' || typeof value === 'boolean' ? String(value) : undefined;
-        const boolean = value === 0 || value === 1 ? value === 1 : coerced === 0 || coerced === 1 ? coerced === 1 : undefined;
-        if (coerced !== undefined && schema.safeParse(coerced).success)
-            result[key] = coerced;
-        else if (boolean !== undefined && schema.safeParse(boolean).success)
-            result[key] = boolean;
-        else if (key === 'title')
-            result[key] = '';
-        // Invalid persisted permissions must not turn a locked session into an editable one.
-        else if (key === 'read_only')
-            result[key] = true;
-        else
-            Reflect.deleteProperty(result, key);
-    }
-    // These persisted flags affect list filtering before the wire flags are computed.
-    for (const key of ['pre_compression_snapshot', 'default_hidden', 'has_pending_user_message']) {
-        if (result[key] === 'true' || result[key] === 'false')
-            result[key] = result[key] === 'true';
-    }
-    return result;
-}
-/** TAL-306: the row's `sort_ts`, the time it sorts and date-buckets by on every client. */
+import { sanitizeSessionRow } from './storage/row.js';
+export { sanitizeSessionRow } from './storage/row.js';
 export function sessionSortTimestamp(row) {
     return num(row.last_message_at) || num(row.updated_at) || num(row.created_at);
 }
@@ -205,7 +163,7 @@ function isEmptyUntitledDraft(row) {
     return str(row.title || 'Untitled') === 'Untitled' && Math.trunc(Number(row.message_count ?? 0)) === 0 && !row.active_stream_id && !row.has_pending_user_message && !row.worktree_path;
 }
 /** Python `all_sessions` without the state.db lineage overlay. */
-export function allSessions(store, opts = {}) {
+export async function allSessions(store, opts = {}) {
     const activeStreamIds = store.deps.activeStreamIds();
     const finish = (result) => {
         result = result.flatMap((row) => { const clean = sanitizeSessionRow(row, store); return clean ? [clean] : []; });
@@ -228,43 +186,43 @@ export function allSessions(store, opts = {}) {
         }
         return rows.sort(compareSessionRows);
     };
-    const indexExists = (() => { try {
-        return Boolean(store.readIndexEntries());
+    const indexExists = (await (async () => { try {
+        return Boolean((await store.readIndexEntries()));
     }
     catch {
         return false;
-    } })();
+    } })());
     if (!indexExists) {
         try {
-            store.writeIndex();
+            (await store.writeIndex());
         }
         catch { /* fall through to the scan */ }
     }
     try {
-        let index = store.readIndexEntries().flatMap((row) => {
-            const clean = sanitizeSessionRow(row, store, '_index.json');
+        let index = (await store.readIndexEntries()).flatMap((row) => {
+            const clean = sanitizeSessionRow(row, store, 'index');
             return clean ? [clean] : [];
         });
         const inMemory = new Set(store.sessions.keys());
-        const persisted = store.persistedIds();
-        if (!index.length && store.hasPersistedSessionFiles())
+        const persisted = (await store.persistedIds());
+        if (!index.length && (await store.hasPersistedSessionFiles()))
             throw new Error('empty session index while session files exist');
         index = index.filter((r) => inMemory.has(str(r.session_id)) || persisted.has(str(r.session_id)));
-        if (!index.length && store.hasPersistedSessionFiles())
+        if (!index.length && (await store.hasPersistedSessionFiles()))
             throw new Error('session index has no live rows while session files exist');
         const backfilled = [];
-        index = index.map((r) => {
+        index = await Promise.all(index.map(async (r) => {
             if ('last_message_at' in r)
                 return r;
-            const full = store.load(str(r.session_id));
+            const full = (await store.load(str(r.session_id)));
             if (!full)
                 return r;
             backfilled.push(full);
             return full.compact({ sidebarMetadataOnly: opts.sidebarMetadataOnly ?? false });
-        });
+        }));
         if (backfilled.length) {
             try {
-                store.writeIndex(backfilled);
+                (await store.writeIndex(backfilled));
             }
             catch { /* ignore */ }
         }
@@ -276,7 +234,7 @@ export function allSessions(store, opts = {}) {
         const missing = [...persisted].filter((sid) => !indexMap.has(sid)).sort();
         const recovered = [];
         for (const sid of missing) {
-            const sidecar = store.loadMetadataOnly(sid);
+            const sidecar = (await store.loadMetadataOnly(sid));
             if (!sidecar)
                 continue;
             indexMap.set(sidecar.session_id, sidecar.compact({ includeRuntime: true, activeStreamIds, sidebarMetadataOnly: opts.sidebarMetadataOnly ?? false }));
@@ -284,12 +242,12 @@ export function allSessions(store, opts = {}) {
         }
         if (recovered.length) {
             try {
-                store.writeIndex(recovered);
+                (await store.writeIndex(recovered));
             }
             catch { /* ignore */ }
         }
-        const indexCounts = store.indexMessageCounts(index);
-        const refreshed = refreshIndexRowsFromSidecarMetadata(store, [...indexMap.values()], indexCounts, activeStreamIds);
+        const indexCounts = (await store.indexMessageCounts(index));
+        const refreshed = (await refreshIndexRowsFromSidecarMetadata(store, [...indexMap.values()], indexCounts, activeStreamIds));
         let result = refreshed.filter((r) => r.session_id);
         result = result.filter((r) => !isEmptyUntitledDraft(r));
         return finish(result);
@@ -297,7 +255,7 @@ export function allSessions(store, opts = {}) {
     catch {
         /* fall back to the full scan */
     }
-    const out = store.scanAll();
+    const out = (await store.scanAll());
     for (const s of store.sessions.values())
         if (!out.some((x) => x.session_id === s.session_id))
             out.push(s);
@@ -306,22 +264,14 @@ export function allSessions(store, opts = {}) {
         .map((s) => s.compact({ includeRuntime: true, activeStreamIds, sidebarMetadataOnly: opts.sidebarMetadataOnly ?? false }));
     return finish(rows);
 }
-function sidecarMtimeAfterIndexTimestamp(store, row) {
+async function sidecarMtimeAfterIndexTimestamp(store, row) {
     const sid = str(row.session_id);
     if (!sid)
         return false;
-    try {
-        const mtime = statSyncMtime(store.pathFor(sid));
-        return mtime > sessionSortTimestamp(row) + 0.001;
-    }
-    catch {
-        return false;
-    }
-}
-function statSyncMtime(path) {
-    return statSync(path).mtimeMs / 1000;
+    // A backend revision is opaque; refresh legacy rows whenever persisted data exists.
+    return await store.revision(sid) !== null;
 }
-function rowMayNeedSidecarRefresh(store, row, staleSnapshotIds) {
+async function rowMayNeedSidecarRefresh(store, row, staleSnapshotIds) {
     if (hasLiveState(row))
         return true;
     const sid = str(row.session_id);
@@ -332,15 +282,15 @@ function rowMayNeedSidecarRefresh(store, row, staleSnapshotIds) {
             return true;
         const lineageShaped = Boolean(row.parent_session_id || row._lineage_root_id || row._compression_segment_count);
         const needsMtime = Boolean(sid) && (looksLikeStaleZeroMessageRow(row) || (lineageShaped && (row.user_message_count === null || row.user_message_count === undefined)));
-        return needsMtime && sidecarMtimeAfterIndexTimestamp(store, row);
+        return needsMtime && await sidecarMtimeAfterIndexTimestamp(store, row);
     }
-    if (sid && looksLikeStaleZeroMessageRow(row) && str(row.session_source).trim().toLowerCase() !== 'fork' && sidecarMtimeAfterIndexTimestamp(store, row))
+    if (sid && looksLikeStaleZeroMessageRow(row) && str(row.session_source).trim().toLowerCase() !== 'fork' && await sidecarMtimeAfterIndexTimestamp(store, row))
         return true;
     if (row.message_count === null || row.message_count === undefined || row.last_message_at === null || row.last_message_at === undefined)
         return true;
     return Boolean(sid) && staleSnapshotIds.has(sid);
 }
-function staleSnapshotRefreshIds(store, rows) {
+async function staleSnapshotRefreshIds(store, rows) {
     const byId = new Map(rows.filter((r) => r.session_id).map((r) => [str(r.session_id), r]));
     const groups = new Map();
     for (const row of rows) {
@@ -364,23 +314,23 @@ function staleSnapshotRefreshIds(store, rows) {
                 continue;
             if (snapshot.user_message_count !== null && snapshot.user_message_count !== undefined && Math.trunc(Number(snapshot.message_count ?? 0)) > 0 && snapshot.last_message_at !== null && snapshot.last_message_at !== undefined)
                 continue;
-            if (sidecarMtimeAfterIndexTimestamp(store, snapshot))
+            if (await sidecarMtimeAfterIndexTimestamp(store, snapshot))
                 ids.add(sid);
         }
     }
     return ids;
 }
 const REFRESH_KEYS = ['message_count', 'updated_at', 'last_message_at', 'title', 'workspace', 'model', 'model_provider', 'created_at', 'pinned', 'archived', 'project_id', 'profile', 'pre_compression_snapshot', 'parent_session_id', 'source_tag', 'raw_source', 'session_source', 'source_label', 'active_stream_id', 'has_pending_user_message', 'pending_user_message', 'pending_started_at'];
-function refreshIndexRowsFromSidecarMetadata(store, rows, indexCounts, activeStreamIds) {
-    const stale = staleSnapshotRefreshIds(store, rows);
+async function refreshIndexRowsFromSidecarMetadata(store, rows, indexCounts, activeStreamIds) {
+    const stale = await staleSnapshotRefreshIds(store, rows);
     const out = [];
     for (const row of rows) {
         const sid = str(row.session_id);
-        if (!rowMayNeedSidecarRefresh(store, row, stale) || !sid) {
+        if (!await rowMayNeedSidecarRefresh(store, row, stale) || !sid) {
             out.push(row);
             continue;
         }
-        const sidecar = store.loadMetadataOnly(sid, { indexMessageCounts: indexCounts });
+        const sidecar = (await store.loadMetadataOnly(sid, { indexMessageCounts: indexCounts }));
         if (!sidecar) {
             out.push(row);
             continue;
@@ -407,7 +357,7 @@ export const SIDEBAR_SESSION_RESPONSE_FIELDS = new Set([
     'is_cli_session', 'is_messaging_session', 'is_streaming', 'cron_running', 'active_stream_id', 'has_pending_user_message', 'pending_started_at', 'default_hidden',
     'worktree_path', 'worktree_branch', 'parent_session_id', 'parent_title', 'parent_source', 'relationship_type', 'pre_compression_snapshot', '_lineage_root_id',
     '_lineage_tip_id', '_compression_segment_count', '_lineage_collapsed_count', '_parent_lineage_root_id', '_parent_lineage_tip_id', '_cross_surface_child_session',
-    'match_type', 'match_preview', 'read_only', 'can_branch', 'can_pin', 'can_archive', 'can_delete', 'can_duplicate', 'gateway_routing', 'share_url',
+    'match_type', 'match_preview', 'read_only', 'read_only_reason', 'can_branch', 'can_pin', 'can_archive', 'can_delete', 'can_duplicate', 'gateway_routing', 'share_url',
 ]);
 export function isCliSessionRow(row) {
     const lower = (v) => str(v).trim().toLowerCase();
@@ -503,15 +453,20 @@ export function isMessagingSessionRecord(row) {
         return true;
     return isKnownMessagingSource(first(row.raw_source, row.source_tag, row.source, row.source_label));
 }
-/** Python `_is_claimable_cli_source`: a denylist of foreign families that own their sessions. */
+/**
+ * Python `_is_claimable_cli_source`: a denylist of foreign families that own their sessions. A `kanban` state.db owner
+ * (`stateDbSessionSources` folds in the lineage's `created_source`) refuses whatever the row's tag says (TAL-793).
+ */
 export function isClaimableCliSource(meta, stateDbSource) {
-    if (meta.read_only)
+    if (typeof stateDbSource === 'object' || meta.read_only)
+        return false;
+    if (stateDbSource.trim().toLowerCase() === 'kanban')
         return false;
     const sessionSource = str(meta.session_source).trim().toLowerCase();
     if (['messaging', 'external_agent'].includes(sessionSource))
         return false;
     const tag = str(meta.source_tag || meta.raw_source).trim().toLowerCase();
-    const refused = new Set(['claude_code', 'cron', 'external_agent', 'gateway', 'messaging', 'subagent', 'unknown']);
+    const refused = new Set(['claude_code', 'cron', 'external_agent', 'gateway', 'kanban', 'messaging', 'subagent', 'unknown']);
     if (tag && refused.has(tag))
         return false;
     if (isMessagingSessionRecord(meta))
@@ -523,22 +478,33 @@ export function isClaimableCliSource(meta, stateDbSource) {
 /**
  * TAL-358: marks read-only each WebUI sidecar row whose active-profile state.db owner (`sessions.source`) refuses
  * claiming, as a sidecar-less row from that owner is. A sidecar persisted as WebUI- or fork-born stays WebUI-owned
- * whatever state.db mirrors for its id. `stateDbSources` reads every candidate's owner in one batch, not per row; an
+ * for legacy source tags, but cannot override a canonical receipt or ledger. Owners are batched per profile; an
  * unreadable state.db (null) locks every candidate, since an unknown owner is not a released one.
  */
 export function withOwnerLocks(rows, stateDbSources) {
-    const webuiOwned = (r) => ['source_tag', 'raw_source', 'session_source'].some((k) => ['webui', 'fork'].includes(str(r[k]).trim().toLowerCase()));
-    const candidates = rows.filter((r) => !r.read_only && !webuiOwned(r)).map((r) => str(r.session_id));
-    if (!candidates.length)
-        return rows;
-    const owners = stateDbSources(candidates);
-    const locked = new Set(candidates.filter((sid) => {
-        if (!owners)
-            return true;
-        const source = str(owners.get(sid)).trim().toLowerCase();
-        return Boolean(source) && !isClaimableCliSource({ source_tag: source, ...normalizeAgentSessionSource(source) }, source);
-    }));
-    return locked.size ? rows.map((r) => (locked.has(str(r.session_id)) ? { ...r, read_only: true } : r)) : rows;
+    const byProfile = ownerLockCandidates(rows);
+    const ownersByProfile = new Map([...byProfile].map(([profile, ids]) => [profile, stateDbSources([...ids], profile)]));
+    return rows.map((r) => {
+        const owners = ownersByProfile.get(str(r.profile) || 'default');
+        const owner = owners?.get(str(r.session_id).trim());
+        if (typeof owner === 'object')
+            return { ...r, ...(owner.source ? { ...normalizeAgentSessionSource(owner.source), source_tag: owner.source } : {}), read_only: true, read_only_reason: owner.reason ?? CANONICAL_READ_ONLY_REASON };
+        const webui = ['source_tag', 'raw_source', 'session_source'].some((k) => ['webui', 'fork'].includes(str(r[k]).trim().toLowerCase()));
+        if (!owners || (!webui && owner && !isClaimableCliSource({ source_tag: owner, ...normalizeAgentSessionSource(owner) }, owner)))
+            return { ...r, read_only: true, ...(!owners ? { read_only_reason: OWNERSHIP_UNAVAILABLE_REASON } : {}) };
+        return r;
+    });
+}
+/** Every sidecar is checked in its own profile, including cached WebUI/fork tags. */
+export function ownerLockCandidates(rows) {
+    const byProfile = new Map();
+    for (const row of rows) {
+        const profile = str(row.profile) || 'default';
+        const ids = byProfile.get(profile) ?? new Set();
+        ids.add(str(row.session_id).trim());
+        byProfile.set(profile, ids);
+    }
+    return byProfile;
 }
 /** Python `_session_is_subagent_view_only` on a row: a delegated child by any source marker. */
 export function isSubagentRow(row) {
@@ -573,15 +539,16 @@ export function withSessionWireFlags(row, activeStreamIds) {
     else
         r.read_only = Boolean(r.read_only);
     // The branch gate (`SessionService.branch`): never a subagent child, and a read-only source only when it is a cron run.
-    r.can_branch = !subagent && (!r.read_only || str(r.source_tag || r.raw_source).trim().toLowerCase() === 'cron');
+    const ownerReadOnly = r.read_only && Boolean(r.read_only_reason);
+    r.can_branch = !ownerReadOnly && !subagent && (!r.read_only || str(r.source_tag || r.raw_source).trim().toLowerCase() === 'cron');
     // Pin and archive refuse only subagent children; duplicate also needs the WebUI sidecar it copies, so a sidecar-less
     // foreign row arrives with `can_duplicate: false`. Rename, move and delete follow `read_only` (the mutation gate).
     // A Claude Code import is a live view Web never stores (TAL-551), so it cannot be pinned or archived either.
-    const stored = !subagent && kind !== 'claude_code';
+    const stored = !ownerReadOnly && !subagent && kind !== 'claude_code';
     r.can_pin = stored;
     r.can_archive = stored;
     r.can_delete = !r.read_only;
-    r.can_duplicate = !subagent && r.can_duplicate !== false;
+    r.can_duplicate = !ownerReadOnly && !subagent && r.can_duplicate !== false;
     r.sort_ts = sessionSortTimestamp(r);
     return row;
 }
@@ -614,13 +581,53 @@ export function mergeCliSidebarMetadata(ui, meta) {
 function sessionSourceIsWebui(row) {
     return ['source_tag', 'raw_source', 'session_source', 'source'].some((k) => str(row[k]).trim().toLowerCase() === 'webui');
 }
-function sessionLineageIds(row) {
+export function sessionLineageIds(row) {
     const ids = new Set();
     for (const key of ['session_id', '_lineage_root_id', '_lineage_tip_id'])
         if (row[key])
             ids.add(str(row[key]));
+    if (Array.isArray(row._lineage_ids))
+        for (const id of row._lineage_ids)
+            if (typeof id === 'string')
+                ids.add(id);
     return ids;
 }
+/** The newest saved physical member owns UI metadata; listing and materialization use this same selection. */
+export function latestLineageSidecar(ids, profile, lookup, profilesMatch) {
+    for (let i = ids.length - 1; i >= 0; i -= 1) {
+        const row = lookup(ids[i]);
+        if (row && profilesMatch(str(row.profile) || null, profile))
+            return row;
+    }
+    return undefined;
+}
+/** Receipt members are aliases of the current target. Keep UI metadata, never an old member's transcript counts. */
+export function reconcileLocalSessionRows(rows, cli, profilesMatch) {
+    const byId = new Map(rows.map((row) => [str(row.session_id), row]));
+    const members = new Map();
+    const chosen = new Map();
+    for (const meta of cli) {
+        if (!Array.isArray(meta._lineage_ids))
+            continue;
+        const ids = meta._lineage_ids.filter((id) => typeof id === 'string');
+        for (const id of ids)
+            members.set(id, meta);
+        const row = latestLineageSidecar(ids, str(meta.profile) || null, (id) => byId.get(id), profilesMatch);
+        if (row)
+            chosen.set(str(meta.session_id), { row, meta });
+    }
+    const other = rows.filter((row) => { const meta = members.get(str(row.session_id)); return !meta || !profilesMatch(str(row.profile) || null, str(meta.profile) || null); });
+    for (const [target, { row, meta }] of chosen) {
+        const merged = mergeCliSidebarMetadata(row, meta);
+        if (str(row.session_id) !== target) {
+            merged.message_count = meta.message_count ?? 0;
+            merged.user_message_count = meta.user_message_count ?? 0;
+            merged.last_message_at = meta.last_message_at ?? meta.updated_at;
+        }
+        other.push({ ...merged, session_id: target });
+    }
+    return other;
+}
 /** Python `_dedupe_cli_sidebar_sessions_for_api`: additive state rows, keeping project-hidden background rows addressable. */
 export function dedupeCliSidebarSessions(cli, represented, opts) {
     const sf = str(opts.sourceFilter).trim().toLowerCase();
@@ -711,7 +718,11 @@ export function capRecentCliSessions(rows, cap = CLI_VISIBLE_SESSION_CAP) {
         return true; seen += 1; return seen <= cap; });
 }
 function sessionHasServerVisibleMessages(row) {
-    if (sidebarMessageCount(row) > 0)
+    // A validated local reset keeps its empty current target discoverable under the existing lineage identity.
+    if (row._lineage_root_id && row._lineage_tip_id)
+        return true;
+    // A worktree chat owns a directory on disk from creation; its row is where the user removes it (TAL-605).
+    if (sidebarMessageCount(row) > 0 || row.worktree_path)
         return true;
     const attention = row.attention;
     if (attention && typeof attention === 'object' && attention.kind && num(attention.count) > 0)
@@ -744,15 +755,19 @@ function hiddenArchivedReferences(visible, archived) {
     }
     return references;
 }
-/** Python `_build_session_list_cache_payload`; the orphaned-sidecar prune (#3238/#4985) is not applied. */
-export function buildSessionListPayload(store, params) {
-    let webuiSessions = allSessions(store, { sidebarMetadataOnly: true }).map((r) => ({ ...r, is_cli_session: isCliSessionRow(r) }));
+/** Python `_build_session_list_cache_payload`; of its orphaned-sidecar prunes only the imported one (#3238) applies. */
+export async function buildSessionListPayload(store, params) {
+    let webuiSessions = (params.webuiRows ?? (await allSessions(store, { sidebarMetadataOnly: true }))).map((r) => ({ ...r, is_cli_session: isCliSessionRow(r) }));
+    const orphans = await params.pruneOrphanedImports?.(webuiSessions);
+    if (orphans?.size)
+        webuiSessions = webuiSessions.filter((r) => !orphans.has(str(r.session_id)));
     // Before the state.db overlay below replaces the sidecar's own source fields, which the WebUI-born exception reads.
     if (params.stateDbSources)
         webuiSessions = withOwnerLocks(webuiSessions, params.stateDbSources);
     let dedupedCli = [];
     if (params.cliRows) {
         const cliRows = params.cliRows.flatMap((r) => { const clean = sanitizeSessionRow(r, store, 'state.db'); return clean ? [clean] : []; });
+        webuiSessions = reconcileLocalSessionRows(webuiSessions, cliRows, params.profilesMatch);
         const cliById = new Map(cliRows.map((r) => [str(r.session_id), r]));
         webuiSessions = webuiSessions.map((s) => {
             const meta = cliById.get(str(s.session_id));
@@ -778,9 +793,11 @@ export function buildSessionListPayload(store, params) {
         for (const s of webuiSessions)
             for (const id of sessionLineageIds(s))
                 represented.add(id);
-        dedupedCli = dedupeCliSidebarSessions(cliRows, represented, { showCli: params.showCliSessions, showCron: params.showCronSessions, showWebhook: params.showWebhookSessions, showKanban: params.showKanbanSessions, sourceFilter: params.sourceFilter ?? null, requestVisibilityOverrides: params.requestVisibilityOverrides })
-            // A sidecar-less foreign row whose owner refuses claiming is read-only, as its detail and mutations are.
-            .map((r) => ({ ...r, read_only: !isClaimableCliSource(r, str(r.source)), can_duplicate: false }));
+        dedupedCli = dedupeCliSidebarSessions(cliRows, represented, { showCli: params.showCliSessions, showCron: params.showCronSessions, showWebhook: params.showWebhookSessions, showKanban: params.showKanbanSessions, sourceFilter: params.sourceFilter ?? null, requestVisibilityOverrides: params.requestVisibilityOverrides });
+        const owners = params.stateDbSources ? params.stateDbSources(dedupedCli.map((r) => str(r.session_id))) : new Map();
+        // A sidecar-less foreign row whose owner refuses claiming is read-only, as its detail and mutations are; an
+        // unreadable owner read (null) locks every row, as it locks sidecars.
+        dedupedCli = withOwnerLocks(dedupedCli.map((r) => ({ ...r, read_only: !owners || !isClaimableCliSource(r, owners.get(str(r.session_id)) || str(r.source)), can_duplicate: false })), () => owners);
     }
     else {
         webuiSessions = webuiSessions.filter((r) => !isCliSessionForSettings(r));
@@ -799,8 +816,12 @@ export function buildSessionListPayload(store, params) {
         otherProfileCount = params.isolatedProfileMode ? 0 : merged.length - scoped.length;
     }
     const identity = params.gatewayIdentity ?? new Map();
-    const isPreCompressionSnapshotId = (sid) => { if (!/^[a-z0-9_]+$/.test(sid))
-        return false; return Boolean(store.loadMetadataOnly(sid)?.pre_compression_snapshot); };
+    const snapshots = new Set();
+    for (const parent of new Set(scoped.map((row) => str(row.parent_session_id)))) {
+        if (/^[a-z0-9_]+$/.test(parent) && (await store.loadMetadataOnly(parent))?.pre_compression_snapshot)
+            snapshots.add(parent);
+    }
+    const isPreCompressionSnapshotId = (sid) => snapshots.has(sid);
     const dedupeOpts = { showPrevious: params.showPreviousMessagingSessions, identity, isPreCompressionSnapshotId };
     let archivedScoped = keepLatestMessagingSessionPerSource([...scoped], dedupeOpts);
     let visibleScoped = keepLatestMessagingSessionPerSource(scoped.filter((r) => !r.archived), dedupeOpts);
@@ -845,6 +866,7 @@ export function buildSessionListPayload(store, params) {
         scheduled_sessions_truncated: params.showCronSessions && truncated.has('cron'),
         webhook_session_count: visibleFiltered.filter((r) => sourceKind(r) === 'webhook').length,
         webhook_sessions_truncated: params.showWebhookSessions && truncated.has('webhook'),
+        agent_storage: params.agentStorage ?? AGENT_STORAGE_OK,
         include_archived: params.includeArchived,
         archived_limit: params.archivedLimit,
         archived_offset: params.archivedOffset,
@@ -944,6 +966,7 @@ export function sessionListResponse(payload, overlay, redactEnabled, now, worksp
         scheduled_sessions_truncated: payload.scheduled_sessions_truncated,
         webhook_session_count: payload.webhook_session_count,
         webhook_sessions_truncated: payload.webhook_sessions_truncated,
+        agent_storage: payload.agent_storage,
     };
     if (payload.archived_limit !== null) {
         body.archived_limit = Math.trunc(payload.archived_limit) || 0;
@@ -954,20 +977,7 @@ export function sessionListResponse(payload, overlay, redactEnabled, now, worksp
     return { body, etag };
 }
 // ── search ────────────────────────────────────────────────────────────────
-export function sessionSearchMessageText(message) {
-    const content = message && typeof message === 'object' ? message.content : '';
-    if (Array.isArray(content))
-        return content.filter((p) => Boolean(p) && typeof p === 'object' && p.type === 'text').map((p) => str(p.text)).join(' ');
-    return str(content);
-}
-/** TAL-453: a query's distinct whitespace-separated terms, lowercased; a row matches when one field holds them all. */
-export function sessionSearchTerms(query) {
-    return [...new Set(query.toLowerCase().split(/\s+/).filter(Boolean))];
-}
-export function sessionSearchMatches(text, terms) {
-    const lower = text.toLowerCase();
-    return terms.length > 0 && terms.every((term) => lower.includes(term));
-}
+export { sessionSearchMessageText, sessionSearchTerms, sessionSearchMatches } from './storage/search-text.js';
 /** An excerpt of `text` centred on the earliest occurrence of any of `terms`. */
 export function sessionSearchPreview(text, terms, maxLen = 124) {
     const normalized = text.replace(/\s+/g, ' ').trim();