fraim-hub 2.0.318 → 2.0.320

package/dist/src/ai-hub/atomic-json-file.js

@@ -14,8 +14,8 @@ const path_1 = __importDefault(require("path"));
 // same write-temp-then-rename dance, and the same Windows-specific retry around it. Keeping two
 // copies meant a future fix to the retry behaviour would land in one and silently not the other,
 // which is exactly the drift the store's #820 durability work exists to prevent.
-const RENAME_ATTEMPTS = process.platform === 'win32' ? 250 : 25;
-const RENAME_RETRY_DELAY_MS = process.platform === 'win32' ? 20 : 10;
+const RENAME_ATTEMPTS = 25;
+const RENAME_RETRY_DELAY_MS = 10;
 let tempSeq = 0;
 /**
  * Rename, retrying the Windows contention codes.
@@ -66,25 +66,7 @@ function writeFileAtomic(filePath, data, encoding) {
         fs_1.default.writeFileSync(tempPath, data);
     }
     try {
-        const fd = fs_1.default.openSync(tempPath, 'r+');
-        try {
-            fs_1.default.fsyncSync(fd);
-        }
-        finally {
-            fs_1.default.closeSync(fd);
-        }
         renameWithRetry(tempPath, filePath);
-        // POSIX supports directory fsync for rename durability. Windows does not expose
-        // a directory flush through Node; file data is flushed, rename is atomic.
-        if (process.platform !== 'win32') {
-            const directory = fs_1.default.openSync(path_1.default.dirname(filePath), 'r');
-            try {
-                fs_1.default.fsyncSync(directory);
-            }
-            finally {
-                fs_1.default.closeSync(directory);
-            }
-        }
     }
     catch (error) {
         // Do not leave the temp file behind for a scanner to trip over.

package/dist/src/ai-hub/conversation-search-index.js

@@ -7,14 +7,7 @@ exports.ConversationSearchIndex = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const conversation_search_projection_1 = require("./conversation-search-projection");
-const conversation_search_1 = require("./conversation-search");
-const history_policy_1 = require("./history-policy");
 const conversation_search_state_1 = require("./conversation-search-state");
-const atomic_json_file_1 = require("./atomic-json-file");
-const MAX_CACHE_FILES = 64;
-const MAX_CACHE_BYTES = 4 * 1024 * 1024;
-const MAX_PROJECTION_BYTES = 512 * 1024;
-const MAX_PENDING_BUCKETS = 32;
 function timestampValue(value) {
     if (typeof value === 'number')
         return Number.isFinite(value) ? value : 0;
@@ -27,332 +20,213 @@ function timestampValue(value) {
     }
     return 0;
 }
-function text(value) { return typeof value === 'string' ? value : ''; }
+function text(value) {
+    return typeof value === 'string' ? value : '';
+}
 class ConversationSearchIndex {
     constructor(store) {
         this.store = store;
         this.fileCache = new Map();
-        this.cacheBytes = 0;
-        this.pendingBuckets = new Set();
+        this.pendingByBucket = new Map();
         this.building = false;
         this.disposed = false;
-        this.searching = false;
-        this.waitingSearches = [];
-        this.shutdown = new AbortController();
-    }
-    historyDiagnostics() {
-        return { cacheEntries: this.fileCache.size, cacheBytes: this.cacheBytes, active: Number(this.searching), waiting: this.waitingSearches.length, rebuilding: Number(this.building), pendingBuckets: this.pendingBuckets.size };
     }
+    /** Stop the background indexer. Called from server shutdown so it cannot outlive the Hub. */
     dispose() {
         this.disposed = true;
-        this.shutdown.abort(new history_policy_1.HistoryStoreError('history_search_cancelled', 503));
-        this.pendingBuckets.clear();
-        this.fileCache.clear();
-        this.cacheBytes = 0;
-    }
-    collect(targets, signal) {
-        const corpus = {
-            items: this.iterate(targets, () => corpus, signal),
-            conversationsSearched: 0, pendingConversations: 0, headerOnlyScopes: [],
-        };
-        return corpus;
-    }
-    /** One live scan, two waiters. An aborted read keeps its slot until I/O unwinds. */
-    async search(targets, parsed, options) {
-        const signal = AbortSignal.any([options.signal, this.shutdown.signal]);
-        this.checkCancellation(signal);
-        const work = (async () => {
-            const release = await this.acquireSearch(signal);
-            try {
-                this.checkCancellation(signal);
-                const corpus = this.collect(targets, signal);
-                const outcome = await (0, conversation_search_1.searchConversations)(corpus.items, parsed, { limit: options.limit });
-                this.checkCancellation(signal);
-                return { corpus, outcome };
-            }
-            finally {
-                release();
-            }
-        })();
-        return new Promise((resolve, reject) => {
-            const cancelled = () => reject(signal.reason || new history_policy_1.HistoryStoreError('history_search_cancelled', 503));
-            signal.addEventListener('abort', cancelled, { once: true });
-            if (signal.aborted)
-                cancelled();
-            work.then(resolve, reject).finally(() => signal.removeEventListener('abort', cancelled));
-        });
-    }
-    acquireSearch(signal) {
-        this.checkCancellation(signal);
-        if (this.searching && this.waitingSearches.length >= 2)
-            return Promise.reject(new history_policy_1.HistoryStoreError('history_search_busy', 503));
-        return new Promise((resolve, reject) => {
-            const cancelled = () => {
-                const index = this.waitingSearches.indexOf(grant);
-                if (index >= 0)
-                    this.waitingSearches.splice(index, 1);
-                reject(signal.reason || new history_policy_1.HistoryStoreError('history_search_cancelled', 503));
-            };
-            const grant = () => {
-                signal.removeEventListener('abort', cancelled);
-                this.searching = true;
-                let released = false;
-                resolve(() => {
-                    if (released)
-                        return;
-                    released = true;
-                    this.searching = false;
-                    this.waitingSearches.shift()?.();
-                });
-            };
-            if (!this.searching)
-                grant();
-            else {
-                this.waitingSearches.push(grant);
-                signal.addEventListener('abort', cancelled, { once: true });
-            }
-        });
+        this.pendingByBucket.clear();
     }
-    checkCancellation(signal) {
-        if (signal?.aborted)
-            throw signal.reason || new history_policy_1.HistoryStoreError('history_search_cancelled', 503);
-        if (this.disposed)
-            throw new history_policy_1.HistoryStoreError('history_search_cancelled', 503);
-    }
-    async *iterate(targets, state, signal) {
-        this.checkCancellation(signal);
-        const corpus = state();
-        const degraded = (label) => {
-            if (!corpus.headerOnlyScopes.includes(label))
-                corpus.headerOnlyScopes.push(label);
-        };
+    collect(targets) {
+        const items = [];
+        const headerOnlyScopes = [];
+        let conversationsSearched = 0;
+        let pendingConversations = 0;
         for (const target of targets) {
-            let needsBuild = false;
-            try {
-                for await (const header of this.store.iterateProjectHeaders(target.bucketKey)) {
-                    this.checkCancellation(signal);
-                    corpus.conversationsSearched += 1;
-                    const read = await this.readProjection(target.bucketKey, header.id);
-                    const entry = read.entry;
-                    if (read.unreadable)
-                        degraded(target.projectLabel);
-                    if (!entry) {
-                        corpus.pendingConversations += 1;
-                        needsBuild = true;
-                    }
-                    else if (timestampValue(header.lastUpdatedAt) > timestampValue(entry.lastUpdatedAt))
-                        needsBuild = true;
-                    const item = this.toSearchable(target, header, entry || undefined);
-                    if (header.hasArchivedArtifacts) {
-                        try {
-                            item.artifacts = (0, conversation_search_projection_1.artifactSearchNames)({ artifacts: this.store.readControlDocument(target.bucketKey, header.id, 'artifacts') });
-                        }
-                        catch {
-                            degraded(target.projectLabel);
-                        }
-                    }
-                    const history = header.history;
-                    if (entry && (entry.threadTruncated || history?.archiveTail || header.hasMessageBlobs)) {
-                        item.threadTruncated = false;
-                        item.messages = this.historyMessages(target, header, item, degraded, signal);
-                    }
-                    yield item;
-                }
+            const headers = this.safeHeaders(target.bucketKey);
+            if (headers.length === 0)
+                continue;
+            const projection = this.readProjection(target.bucketKey);
+            if (projection.unreadable > 0 && !headerOnlyScopes.includes(target.projectLabel)) {
+                headerOnlyScopes.push(target.projectLabel);
             }
-            catch (error) {
-                this.checkCancellation(signal);
-                degraded(target.projectLabel);
+            // Two different conditions, deliberately counted differently. A conversation with NO entry
+            // has had no thread text searched, so it is genuinely pending and R30 must say so. A
+            // conversation whose entry is merely stamped older than its header did have its thread
+            // searched; rebuilding it is a refresh, not an incomplete result, so it must not make the UI
+            // claim it is still indexing.
+            const rebuildIds = [];
+            for (const header of headers) {
+                conversationsSearched += 1;
+                const entry = projection.entries.get(header.id);
+                if (!entry) {
+                    pendingConversations += 1;
+                    rebuildIds.push(header.id);
+                }
+                else if (timestampValue(header.lastUpdatedAt) > timestampValue(entry.lastUpdatedAt)) {
+                    rebuildIds.push(header.id);
+                }
+                items.push(this.toSearchable(target, header, entry));
             }
-            if (needsBuild)
-                await this.queueBuild(target.bucketKey);
+            if (rebuildIds.length > 0)
+                this.queueBuild(target.bucketKey, rebuildIds);
+        }
+        return { items, conversationsSearched, pendingConversations, headerOnlyScopes };
+    }
+    // ---- internals ----
+    safeHeaders(bucketKey) {
+        try {
+            return this.store.loadProjectHeaders(bucketKey);
+        }
+        catch {
+            return [];
         }
     }
     toSearchable(target, header, entry) {
         return {
-            id: header.id, projectPath: text(header.projectPath), bucketKey: target.bucketKey,
-            scope: target.scope, projectLabel: target.projectLabel, title: text(header.title),
-            jobId: text(header.jobId), jobTitle: text(header.jobTitle),
-            employeeLabel: (0, conversation_search_projection_1.conversationSpeakerLabel)(header), personaKey: text(header.personaKey),
-            issueNumber: text(header.issueNumber), state: (0, conversation_search_state_1.conversationSearchState)(header),
-            lastUpdatedAt: timestampValue(header.lastUpdatedAt), artifacts: entry?.artifacts || [],
-            messages: entry?.messages || [], threadTruncated: entry?.threadTruncated || false,
+            id: header.id,
+            projectPath: text(header.projectPath),
+            bucketKey: target.bucketKey,
+            scope: target.scope,
+            projectLabel: target.projectLabel,
+            title: text(header.title),
+            jobId: text(header.jobId),
+            jobTitle: text(header.jobTitle),
+            employeeLabel: (0, conversation_search_projection_1.conversationSpeakerLabel)(header),
+            personaKey: text(header.personaKey),
+            issueNumber: text(header.issueNumber),
+            state: (0, conversation_search_state_1.conversationSearchState)(header),
+            lastUpdatedAt: timestampValue(header.lastUpdatedAt),
+            artifacts: entry ? entry.artifacts : [],
+            messages: entry ? entry.messages : [],
+            threadTruncated: entry ? entry.threadTruncated : false,
             threadIndexed: Boolean(entry),
         };
     }
-    async *historyMessages(target, header, item, degraded, signal) {
-        let ordinal = 0;
+    /**
+     * Read a bucket's projection, reusing already-parsed sidecars.
+     *
+     * The memo is keyed per FILE on mtime plus byte size, not per directory. A directory-level memo
+     * (dir mtime + file count) looked cheaper but is unsafe: replacing an existing sidecar leaves the
+     * file count unchanged, so a coarse mtime clock could serve stale thread text for a conversation
+     * that was just patched, and R28 says a run that just finished must be findable. Per-file keys
+     * mean an overwritten sidecar is re-parsed unless its mtime AND its length are both identical, and
+     * `collect` additionally treats any entry older than its header as pending so even that residual
+     * case self-heals rather than going unnoticed.
+     */
+    readProjection(bucketKey) {
+        const dir = (0, conversation_search_projection_1.searchProjectionDirPath)(this.store.bucketDirectory(bucketKey));
+        let files;
         try {
-            for await (const raw of this.store.iterateConversationMessages(target.bucketKey, header.id)) {
-                this.checkCancellation(signal);
-                ordinal += 1;
-                const rawRole = text(raw.role).toLowerCase();
-                const role = ['manager', 'user', 'human'].includes(rawRole) ? 'manager'
-                    : ['employee', 'assistant', 'agent'].includes(rawRole) ? 'employee' : 'system';
-                const who = role === 'manager' ? 'You' : role === 'employee' ? (0, conversation_search_projection_1.conversationSpeakerLabel)(header) : 'System';
-                const content = raw.contentRef;
-                if (!content?.hash) {
-                    yield { role, who, text: text(raw.text), messageKey: ordinal };
-                    continue;
-                }
-                const stream = this.store.openMessageBlob(target.bucketKey, header.id, content.hash, Number(raw.sequence) || undefined);
-                const cancelRead = () => stream.destroy(new history_policy_1.HistoryStoreError('history_search_cancelled', 503));
-                signal?.addEventListener('abort', cancelRead, { once: true });
-                stream.setEncoding('utf8');
-                let overlap = '';
-                try {
-                    for await (const chunk of stream) {
-                        this.checkCancellation(signal);
-                        const combined = overlap + String(chunk);
-                        yield { role, who, text: combined, messageKey: ordinal, overlapText: overlap };
-                        // Includes at least the longest supported phrase plus its preceding character.
-                        overlap = combined.slice(-(conversation_search_1.MAX_SEARCH_QUERY_LENGTH + 1));
-                    }
-                }
-                finally {
-                    signal?.removeEventListener('abort', cancelRead);
-                    stream.destroy();
-                }
-            }
-            if (typeof header.messageCount === 'number' && ordinal !== header.messageCount) {
-                throw new Error('history_incomplete');
-            }
+            files = fs_1.default.readdirSync(dir);
         }
         catch {
-            this.checkCancellation(signal);
-            item.threadTruncated = true;
-            item.threadIndexed = false;
-            degraded(target.projectLabel);
-        }
-    }
-    /** Stat-check one bounded file, and LRU only those entries that fit both budgets. */
-    async readProjection(bucketKey, id) {
-        const filePath = (0, conversation_search_projection_1.searchProjectionEntryPath)(this.store.bucketDirectory(bucketKey), id);
-        let stat;
-        try {
-            stat = await fs_1.default.promises.stat(filePath);
-        }
-        catch (error) {
-            this.dropCached(filePath);
-            return { entry: null, unreadable: error.code !== 'ENOENT' };
-        }
-        const cached = this.fileCache.get(filePath);
-        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-            this.fileCache.delete(filePath);
-            this.fileCache.set(filePath, cached);
-            return { entry: cached.entry, unreadable: !cached.entry };
+            return { entries: new Map(), unreadable: 0, missing: true };
         }
-        this.dropCached(filePath);
-        if (stat.size > MAX_PROJECTION_BYTES)
-            return { entry: null, unreadable: true };
-        let entry = null;
-        try {
-            // Read from a bounded buffer even if a concurrent writer grows the file after stat.
-            const handle = await fs_1.default.promises.open(filePath, 'r');
-            let contents;
+        const entries = new Map();
+        let unreadable = 0;
+        const seen = new Set();
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = path_1.default.join(dir, file);
+            seen.add(filePath);
+            let mtimeMs = -1;
+            let size = -1;
             try {
-                const buffer = Buffer.alloc(Math.min(MAX_PROJECTION_BYTES + 1, stat.size + 1));
-                let offset = 0;
-                while (offset < buffer.length) {
-                    const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
-                    if (bytesRead === 0)
-                        break;
-                    offset += bytesRead;
-                }
-                if (offset > stat.size || offset > MAX_PROJECTION_BYTES)
-                    throw new Error('projection_changed');
-                contents = buffer.toString('utf8', 0, offset);
+                const stat = fs_1.default.statSync(filePath);
+                mtimeMs = stat.mtimeMs;
+                size = stat.size;
+            }
+            catch {
+                unreadable += 1;
+                continue;
             }
-            finally {
-                await handle.close();
+            const cached = this.fileCache.get(filePath);
+            if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+                if (cached.entry)
+                    entries.set(cached.entry.id, cached.entry);
+                else
+                    unreadable += 1;
+                continue;
             }
-            const value = JSON.parse(contents);
-            if (value?.id === id && Array.isArray(value.messages) && Array.isArray(value.artifacts))
-                entry = value;
+            let parsed = null;
+            try {
+                const candidate = JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+                if (candidate && typeof candidate.id === 'string' && Array.isArray(candidate.messages))
+                    parsed = candidate;
+            }
+            catch {
+                parsed = null;
+            }
+            this.fileCache.set(filePath, { mtimeMs, size, entry: parsed });
+            if (parsed)
+                entries.set(parsed.id, parsed);
+            else
+                unreadable += 1;
         }
-        catch { /* A derived file cannot hide header facts. */ }
-        this.fileCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, entry });
-        this.cacheBytes += stat.size;
-        while (this.fileCache.size > MAX_CACHE_FILES || this.cacheBytes > MAX_CACHE_BYTES) {
-            this.dropCached(this.fileCache.keys().next().value);
+        // Drop memo entries for sidecars that are gone, so a pruned conversation cannot linger.
+        for (const filePath of Array.from(this.fileCache.keys())) {
+            if (filePath.startsWith(dir) && !seen.has(filePath))
+                this.fileCache.delete(filePath);
         }
-        return { entry, unreadable: !entry };
-    }
-    dropCached(filePath) {
-        const prior = this.fileCache.get(filePath);
-        if (prior)
-            this.cacheBytes -= prior.size;
-        this.fileCache.delete(filePath);
+        return { entries, unreadable, missing: false };
     }
-    rebuildCursorPath(bucketKey) {
-        return path_1.default.join(this.store.bucketDirectory(bucketKey), 'search-rebuild.json');
-    }
-    async queueBuild(bucketKey) {
-        if (this.disposed || this.pendingBuckets.has(bucketKey))
-            return;
-        // The marker survives shutdown; the next query resumes discovery even if the bounded
-        // in-memory bucket queue is full. No lifetime-sized list of conversation IDs is kept.
-        try {
-            if (!fs_1.default.existsSync(this.rebuildCursorPath(bucketKey))) {
-                (0, atomic_json_file_1.writeJsonAtomic)(this.rebuildCursorPath(bucketKey), { version: 1, lastId: null });
-            }
-        }
-        catch {
+    queueBuild(bucketKey, ids) {
+        if (this.disposed)
             return;
+        let set = this.pendingByBucket.get(bucketKey);
+        if (!set) {
+            set = new Set();
+            this.pendingByBucket.set(bucketKey, set);
         }
-        if (this.pendingBuckets.size >= MAX_PENDING_BUCKETS)
+        for (const id of ids)
+            set.add(id);
+        this.startBuildLoop();
+    }
+    /**
+     * One conversation per event-loop turn. A self-rescheduling `setImmediate` defers the next
+     * conversation to the following loop iteration, so the poll phase runs in between and ordinary
+     * Hub requests are answered while a large store indexes for the first time (R31).
+     */
+    startBuildLoop() {
+        if (this.building || this.disposed)
             return;
-        this.pendingBuckets.add(bucketKey);
-        if (!this.building)
-            void this.buildLoop();
-    }
-    async buildLoop() {
         this.building = true;
-        try {
-            while (!this.disposed && this.pendingBuckets.size > 0) {
-                const bucketKey = this.pendingBuckets.values().next().value;
-                try {
-                    let cursor = null;
-                    try {
-                        const file = this.rebuildCursorPath(bucketKey);
-                        if ((await fs_1.default.promises.stat(file)).size <= 4096) {
-                            const value = JSON.parse(await fs_1.default.promises.readFile(file, 'utf8'));
-                            if (typeof value.lastId === 'string')
-                                cursor = value.lastId;
-                        }
-                    }
-                    catch { /* Missing or invalid derived cursor restarts a bounded scan. */ }
-                    // If the anchor was deleted, restart once from the beginning. Neither pass
-                    // materializes IDs; existing directory order supplies the resume position.
-                    for (let pass = 0; pass < 2; pass += 1) {
-                        let pastCursor = cursor === null;
-                        for await (const header of this.store.iterateProjectHeaders(bucketKey)) {
-                            if (this.disposed)
-                                return;
-                            if (!pastCursor) {
-                                if (header.id === cursor)
-                                    pastCursor = true;
-                                continue;
-                            }
-                            const { entry } = await this.readProjection(bucketKey, header.id);
-                            if (!entry || timestampValue(header.lastUpdatedAt) > timestampValue(entry.lastUpdatedAt)) {
-                                await this.store.indexConversationForSearch(bucketKey, header.id);
-                            }
-                            (0, atomic_json_file_1.writeJsonAtomic)(this.rebuildCursorPath(bucketKey), { version: 1, lastId: header.id });
-                            await new Promise((resolve) => setImmediate(resolve));
-                        }
-                        if (pastCursor)
-                            break;
-                        cursor = null;
-                    }
-                    await fs_1.default.promises.rm(this.rebuildCursorPath(bucketKey), { force: true });
-                }
-                catch { /* Leave the repair marker for another query/restart. */ }
-                this.pendingBuckets.delete(bucketKey);
+        const step = () => {
+            if (this.disposed) {
+                this.building = false;
+                return;
             }
+            const next = this.takeNextPending();
+            if (!next) {
+                this.building = false;
+                return;
+            }
+            try {
+                this.store.indexConversationForSearch(next.bucketKey, next.id);
+            }
+            catch {
+                /* a single unreadable conversation must not stall the whole index */
+            }
+            const handle = setImmediate(step);
+            if (typeof handle.unref === 'function')
+                handle.unref();
+        };
+        const handle = setImmediate(step);
+        if (typeof handle.unref === 'function')
+            handle.unref();
+    }
+    takeNextPending() {
+        for (const [bucketKey, ids] of this.pendingByBucket) {
+            for (const id of ids) {
+                ids.delete(id);
+                if (ids.size === 0)
+                    this.pendingByBucket.delete(bucketKey);
+                return { bucketKey, id };
+            }
+            this.pendingByBucket.delete(bucketKey);
         }
-        finally {
-            this.building = false;
-        }
+        return null;
     }
 }
 exports.ConversationSearchIndex = ConversationSearchIndex;

package/dist/src/ai-hub/conversation-search-projection.js

@@ -91,42 +91,59 @@ function artifactSearchNames(conv) {
 function buildConversationSearchEntry(conv) {
     const rawMessages = Array.isArray(conv.messages) ? conv.messages : [];
     const employeeLabel = conversationSpeakerLabel(conv);
-    // Keep the kickoff plus a bounded newest suffix while scanning. A temporary
-    // candidate per lifetime message would defeat the retained projection budget.
-    const retained = [];
-    let retainedChars = 0;
-    let threadMessageCount = 0;
-    for (const value of rawMessages) {
-        const raw = value;
+    const candidates = [];
+    for (let index = 0; index < rawMessages.length; index += 1) {
+        const raw = rawMessages[index];
         if (!raw || typeof raw !== 'object')
             continue;
-        const original = cleanText(raw.text);
-        if (!original.trim())
+        const text = cleanText(raw.text);
+        if (!text.trim())
             continue;
-        threadMessageCount += 1;
         const role = normalizeRole(raw.role);
-        const candidate = {
-            clipped: original.length > exports.MAX_RETAINED_MESSAGE_CHARS,
+        const clipped = text.length > exports.MAX_RETAINED_MESSAGE_CHARS;
+        candidates.push({
+            index,
+            clipped,
             message: {
                 role,
-                who: role === 'manager' ? MANAGER_SPEAKER_LABEL : role === 'employee' ? employeeLabel : 'System',
-                text: original.slice(0, exports.MAX_RETAINED_MESSAGE_CHARS),
+                who: role === 'manager' ? MANAGER_SPEAKER_LABEL : (role === 'employee' ? employeeLabel : 'System'),
+                text: clipped ? text.slice(0, exports.MAX_RETAINED_MESSAGE_CHARS) : text,
             },
-        };
-        retained.push(candidate);
-        retainedChars += candidate.message.text.length;
-        while (retainedChars > exports.MAX_RETAINED_THREAD_CHARS && retained.length > 1) {
-            retainedChars -= retained.splice(1, 1)[0].message.text.length;
+        });
+    }
+    const keptIndexes = new Set();
+    let budget = exports.MAX_RETAINED_THREAD_CHARS;
+    let clippedAny = false;
+    const take = (candidate) => {
+        if (keptIndexes.has(candidate.index))
+            return true;
+        if (candidate.message.text.length > budget)
+            return false;
+        keptIndexes.add(candidate.index);
+        budget -= candidate.message.text.length;
+        if (candidate.clipped)
+            clippedAny = true;
+        return true;
+    };
+    if (candidates.length > 0) {
+        // The kickoff always wins the first slice of the budget.
+        take(candidates[0]);
+        for (let cursor = candidates.length - 1; cursor >= 1; cursor -= 1) {
+            if (!take(candidates[cursor]))
+                break;
         }
     }
+    const retained = candidates
+        .filter((candidate) => keptIndexes.has(candidate.index))
+        .sort((a, b) => a.index - b.index);
     return {
         version: exports.SEARCH_PROJECTION_VERSION,
         id: cleanText(conv.id),
         lastUpdatedAt: conv.lastUpdatedAt ?? conv.createdAt ?? 0,
         messages: retained.map((candidate) => candidate.message),
         artifacts: artifactSearchNames(conv),
-        threadTruncated: retained.some((candidate) => candidate.clipped) || retained.length < threadMessageCount,
-        threadMessageCount,
+        threadTruncated: clippedAny || retained.length < candidates.length,
+        threadMessageCount: candidates.length,
     };
 }
 // ---- disk layout -----------------------------------------------------------