@murphai/murph 1.3.0 → 1.3.1

package/node_modules/@murphai/assistant-engine/dist/assistant/store/persistence.js

@@ -1,8 +1,10 @@
-import { access, open, readdir, readFile, } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { access, open, readdir, readFile, rename, rm, } from 'node:fs/promises';
 import path from 'node:path';
-import { z } from 'zod';
-import { assistantAliasStoreSchema, assistantAutomationStateSchema, assistantPersistedSessionSchema, assistantTranscriptEntrySchema, parseAssistantSessionRecord, } from '@murphai/operator-config/assistant-cli-contracts';
+import * as z from '@murphai/contracts/zod-runtime';
+import { assistantAliasStoreSchema, assistantAutomationStateSchema, assistantPersistedSessionSchema, assistantSessionIdSchema, assistantTranscriptEntrySchema, parseAssistantSessionRecord, } from '@murphai/operator-config/assistant-cli-contracts';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
+import { adoptAssistantStateFile, openSqliteRuntimeDatabase, readSqliteRuntimeUserVersion, withImmediateTransaction, writeSqliteRuntimeUserVersion, } from '@murphai/runtime-state/node';
 import { assistantWithinConversationDriftFields, getAssistantBindingIsolationConflicts, mergeAssistantBinding, } from '../bindings.js';
 import { createAssistantBoundedRuntimeCache, ASSISTANT_AUTOMATION_STATE_CACHE, } from '../runtime-budget-policy.js';
 import { appendTextFile, compareAssistantTimestampsAscending, ensureAssistantStateDirectory, normalizeNullableString, parseAssistantJsonLinesWithTailSalvage, writeTextFileAtomic, writeJsonFileAtomic, } from '../shared.js';
@@ -12,7 +14,6 @@ import { extractAssistantSessionSecretsForPersistence, mergeAssistantSessionSecr
 import { quarantineAssistantStateFile } from '../quarantine.js';
 import { appendAssistantRuntimeEventAtPaths } from '../runtime-events.js';
 import { resolveAssistantOpaqueStateFilePath } from '../state-ids.js';
-export const ASSISTANT_INDEX_STORE_VERSION = 1;
 export const ASSISTANT_AUTOMATION_STATE_VERSION = 1;
 export const ASSISTANT_TRANSCRIPT_AUDIT_RETENTION_LIMIT = 100;
 /**
@@ -26,6 +27,19 @@ export const ASSISTANT_TRANSCRIPT_AUDIT_RETENTION_LIMIT = 100;
  */
 export const ASSISTANT_TRANSCRIPT_CONTENT_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
 const ASSISTANT_RECENT_SESSIONS_INDEX_LIMIT = 50;
+const ASSISTANT_SESSION_ROUTING_DATABASE_VERSION = 1;
+const ASSISTANT_SESSION_ROUTING_DATABASE_NAME = 'session-routing.sqlite';
+class AssistantSessionRoutingDatabaseValidationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'AssistantSessionRoutingDatabaseValidationError';
+    }
+}
+const assistantRecentSessionRowSchema = z
+    .object({
+    sessionId: assistantSessionIdSchema,
+})
+    .strict();
 const assistantAutomationStateCache = createAssistantBoundedRuntimeCache({
     name: 'assistant.automation-state',
     ...ASSISTANT_AUTOMATION_STATE_CACHE,
@@ -180,6 +194,16 @@ export function resolveAssistantSessionPath(paths, sessionId) {
         value: sessionId,
     });
 }
+export function resolveAssistantSessionRoutingDatabasePath(paths) {
+    return path.join(paths.stateDirectory, ASSISTANT_SESSION_ROUTING_DATABASE_NAME);
+}
+function resolveAssistantSessionRoutingKeyDigest(kind, key) {
+    return createHash('sha256')
+        .update(kind)
+        .update('\0')
+        .update(key)
+        .digest('hex');
+}
 export async function inspectAssistantSessionStorage(input) {
     const sessionPath = resolveAssistantSessionPath(input.paths, input.sessionId);
     const transcriptPath = resolveAssistantTranscriptPath(input.paths, input.sessionId);
@@ -437,6 +461,12 @@ export async function loadAndPersistResolvedSession(input) {
     if (!existing) {
         return null;
     }
+    if ((input.expectedAlias !== undefined &&
+        existing.alias !== input.expectedAlias) ||
+        (input.expectedConversationKey !== undefined &&
+            existing.binding.conversationKey !== input.expectedConversationKey)) {
+        return null;
+    }
     if (input.skipIfExpired &&
         isAssistantSessionExpired(existing, input.maxSessionAgeMs, input.now)) {
         return null;
@@ -489,95 +519,398 @@ export function isAssistantSessionExpired(session, maxSessionAgeMs, now) {
     }
     return nowTime - referenceTime >= normalizedMaxAgeMs;
 }
-export async function readAssistantIndexStore(paths) {
-    let raw;
+export async function readAssistantSessionRouting(paths, input) {
+    return await withAssistantSessionRoutingDatabase(paths, (database) => {
+        const readRoute = database.prepare(`
+      SELECT session_id AS sessionId
+      FROM assistant_session_routes
+      WHERE kind = ? AND key_digest = ?
+    `);
+        const readSessionId = (kind, key) => {
+            const row = readRoute.get(kind, resolveAssistantSessionRoutingKeyDigest(kind, key));
+            if (!row) {
+                return null;
+            }
+            return parseAssistantSessionRoutingSessionId(row.sessionId);
+        };
+        const aliasSessionId = input.alias
+            ? readSessionId('alias', input.alias)
+            : null;
+        const conversationKeySessionIds = new Map();
+        for (const conversationKey of new Set(input.conversationKeys)) {
+            const sessionId = readSessionId('conversation-key', conversationKey);
+            if (sessionId) {
+                conversationKeySessionIds.set(conversationKey, sessionId);
+            }
+        }
+        return {
+            aliasSessionId,
+            conversationKeySessionIds,
+        };
+    });
+}
+export async function synchronizeAssistantIndexes(paths, session, previous) {
+    await withAssistantSessionRoutingDatabase(paths, (database) => {
+        synchronizeAssistantSessionRoutingDatabase(database, session, previous);
+    });
+}
+export async function readAssistantRecentSessionIds(paths, options) {
+    const limit = Math.max(0, Math.trunc(options.limit));
+    if (limit === 0) {
+        return [];
+    }
+    return await withAssistantSessionRoutingDatabase(paths, (database) => {
+        const rows = database.prepare(`
+      SELECT
+        session_id AS sessionId
+      FROM assistant_recent_sessions
+      ORDER BY last_active_at_ms DESC, session_id ASC
+      LIMIT ?
+    `).all(limit);
+        return rows.map(parseAssistantRecentSessionRow).map((row) => row.sessionId);
+    });
+}
+async function collectAssistantSessionsForRoutingRebuild(paths) {
+    const entries = await readdir(paths.sessionsDirectory, {
+        withFileTypes: true,
+    });
+    const sessions = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) {
+            continue;
+        }
+        try {
+            const session = await readAssistantSession({
+                paths,
+                sessionId: entry.name.replace(/\.json$/u, ''),
+                treatCorruptedAsMissing: true,
+            });
+            if (!session) {
+                continue;
+            }
+            sessions.push(session);
+        }
+        catch {
+            // Quarantine already happened in readAssistantSession; keep rebuild best-effort.
+        }
+    }
+    return sessions;
+}
+function buildAssistantSessionRoutingProjection(sessions) {
+    const aliases = {};
+    const conversationKeys = {};
+    const recentSessions = {};
+    for (const session of sortSessionsForIndexRebuild(sessions)) {
+        if (session.alias) {
+            aliases[session.alias] = session.sessionId;
+        }
+        if (session.binding.conversationKey) {
+            conversationKeys[session.binding.conversationKey] = session.sessionId;
+        }
+        recentSessions[session.sessionId] =
+            resolveAssistantIndexRebuildTimestamp(session);
+    }
+    return assistantAliasStoreSchema.parse({
+        version: 1,
+        aliases,
+        conversationKeys,
+        recentSessions: pruneAssistantRecentSessions(recentSessions),
+    });
+}
+async function withAssistantSessionRoutingDatabase(paths, operation) {
+    const database = await openOrRebuildAssistantSessionRoutingDatabase(paths);
     try {
-        raw = await readFile(paths.indexesPath, 'utf8');
+        const result = operation(database);
+        database.close();
+        return result;
     }
     catch (error) {
-        if (!isMissingFileError(error)) {
+        try {
+            database.close();
+        }
+        catch {
+            // Preserve the operation or close error for the shared recovery policy.
+        }
+        if (isAssistantSessionRoutingProjectionRecoveryError(error)) {
+            // The callback may have reached a write with an ambiguous commit outcome,
+            // so never replay it. Quarantine the closed projection and let the next
+            // ordinary attempt rebuild before running its own operation.
+            await quarantineAssistantSessionRoutingDatabase(paths, error);
+        }
+        throw error;
+    }
+}
+async function openOrRebuildAssistantSessionRoutingDatabase(paths) {
+    if (await pathExists(paths.indexesPath)) {
+        return await rebuildAssistantSessionRoutingDatabase(paths, await readAssistantLegacyIndex(paths));
+    }
+    const databasePath = resolveAssistantSessionRoutingDatabasePath(paths);
+    if (!await pathExists(databasePath)) {
+        return await rebuildAssistantSessionRoutingDatabase(paths);
+    }
+    try {
+        return openAssistantSessionRoutingDatabase(paths);
+    }
+    catch (error) {
+        if (!isAssistantSessionRoutingProjectionRecoveryError(error)) {
             throw error;
         }
-        if (await hasDurableAssistantSessions(paths)) {
-            return rebuildAssistantIndexStore(paths);
+        await quarantineAssistantSessionRoutingDatabase(paths, error);
+        return await rebuildAssistantSessionRoutingDatabase(paths);
+    }
+}
+async function readAssistantLegacyIndex(paths) {
+    let raw;
+    try {
+        raw = await readFile(paths.indexesPath, 'utf8');
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
         }
-        const initial = createInitialAssistantIndexStore();
-        await writeJsonFileAtomic(paths.indexesPath, initial);
-        return initial;
+        throw error;
     }
     try {
-        const parsed = assistantAliasStoreSchema.parse(JSON.parse(raw));
-        if (parsed.recentSessions === undefined) {
-            if (await hasDurableAssistantSessions(paths)) {
-                return rebuildAssistantIndexStore(paths);
-            }
-            const upgraded = assistantAliasStoreSchema.parse({
-                ...parsed,
-                recentSessions: {},
-            });
-            await writeJsonFileAtomic(paths.indexesPath, upgraded);
-            return upgraded;
+        return assistantAliasStoreSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function openAssistantSessionRoutingDatabase(paths) {
+    const database = openSqliteRuntimeDatabase(resolveAssistantSessionRoutingDatabasePath(paths), {
+        journalMode: 'DELETE',
+        synchronous: 'FULL',
+    });
+    try {
+        const version = readSqliteRuntimeUserVersion(database);
+        if (version !== ASSISTANT_SESSION_ROUTING_DATABASE_VERSION) {
+            throw new AssistantSessionRoutingDatabaseValidationError(`Unsupported assistant session routing database version: ${version}.`);
         }
-        return parsed;
+        assertAssistantSessionRoutingDatabaseShape(database);
+        return database;
     }
     catch (error) {
-        const quarantine = await quarantineAssistantStateFile({
-            artifactKind: 'indexes',
-            error,
-            expectedContent: raw,
-            filePath: paths.indexesPath,
-            paths,
-        });
-        if (!quarantine) {
-            return await readAssistantIndexStore(paths);
+        try {
+            database.close();
+        }
+        catch {
+            // Preserve the validation or SQLite error for the recovery boundary.
         }
-        return await rebuildAssistantIndexStore(paths);
+        throw error;
     }
 }
-export async function synchronizeAssistantIndexes(paths, session, previous) {
-    const store = await readAssistantIndexStore(paths);
-    const aliases = {
-        ...store.aliases,
-    };
-    const conversationKeys = {
-        ...store.conversationKeys,
-    };
-    if (previous?.alias && previous.alias !== session.alias) {
-        delete aliases[previous.alias];
+function assertAssistantSessionRoutingDatabaseShape(database) {
+    try {
+        database.prepare(`
+      SELECT kind, key_digest, session_id
+      FROM assistant_session_routes
+      LIMIT 0
+    `).all();
+        database.prepare(`
+      SELECT session_id, last_active_at_ms
+      FROM assistant_recent_sessions
+      LIMIT 0
+    `).all();
+    }
+    catch (error) {
+        if (!isAssistantSessionRoutingDatabaseShapeError(error)) {
+            throw error;
+        }
+        throw new AssistantSessionRoutingDatabaseValidationError('Assistant session routing database has an invalid schema.', { cause: error });
     }
-    if (previous?.binding.conversationKey &&
-        previous.binding.conversationKey !== session.binding.conversationKey) {
-        delete conversationKeys[previous.binding.conversationKey];
+}
+function isAssistantSessionRoutingDatabaseShapeError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
     }
-    if (session.alias) {
-        aliases[session.alias] = session.sessionId;
+    const candidate = error;
+    return (candidate.code === 'ERR_SQLITE_ERROR' &&
+        candidate.errcode === 1 &&
+        typeof candidate.message === 'string' &&
+        /^(?:no such (?:column|table)|table .* has no column named)/u.test(candidate.message));
+}
+// This is the single destructive classification for both opening and using the
+// projection. All unlisted SQLite failures preserve the active database.
+function isAssistantSessionRoutingProjectionRecoveryError(error) {
+    if (error instanceof AssistantSessionRoutingDatabaseValidationError) {
+        return true;
     }
-    if (session.binding.conversationKey) {
-        conversationKeys[session.binding.conversationKey] = session.sessionId;
+    if (!error || typeof error !== 'object') {
+        return false;
     }
-    const updated = assistantAliasStoreSchema.parse({
-        version: ASSISTANT_INDEX_STORE_VERSION,
-        aliases,
-        conversationKeys,
-        recentSessions: pruneAssistantRecentSessions({
-            ...(store.recentSessions ?? {}),
-            [session.sessionId]: session.lastTurnAt ?? session.updatedAt,
-        }),
+    const candidate = error;
+    if (candidate.code !== 'ERR_SQLITE_ERROR' ||
+        typeof candidate.errcode !== 'number') {
+        return false;
+    }
+    const primaryCode = candidate.errcode & 0xff;
+    return primaryCode === 11 || primaryCode === 26;
+}
+function parseAssistantSessionRoutingSessionId(value) {
+    try {
+        return assistantSessionIdSchema.parse(value);
+    }
+    catch (error) {
+        throw new AssistantSessionRoutingDatabaseValidationError('Assistant session routing database contains an invalid route session id.', { cause: error });
+    }
+}
+function parseAssistantRecentSessionRow(value) {
+    try {
+        return assistantRecentSessionRowSchema.parse(value);
+    }
+    catch (error) {
+        throw new AssistantSessionRoutingDatabaseValidationError('Assistant session routing database contains an invalid recent session row.', { cause: error });
+    }
+}
+function initializeAssistantSessionRoutingDatabase(database, projection) {
+    withImmediateTransaction(database, () => {
+        database.exec(`
+      CREATE TABLE assistant_session_routes (
+        kind TEXT NOT NULL CHECK (kind IN ('alias', 'conversation-key')),
+        key_digest TEXT NOT NULL CHECK (length(key_digest) = 64),
+        session_id TEXT NOT NULL,
+        PRIMARY KEY (kind, key_digest)
+      ) STRICT;
+      CREATE TABLE assistant_recent_sessions (
+        session_id TEXT PRIMARY KEY,
+        last_active_at_ms INTEGER NOT NULL
+      ) STRICT;
+    `);
+        const upsertRoute = database.prepare(`
+      INSERT INTO assistant_session_routes (kind, key_digest, session_id)
+      VALUES (?, ?, ?)
+      ON CONFLICT (kind, key_digest) DO UPDATE SET session_id = excluded.session_id
+    `);
+        const upsertRecent = database.prepare(`
+      INSERT INTO assistant_recent_sessions (session_id, last_active_at_ms)
+      VALUES (?, ?)
+    `);
+        for (const [alias, sessionId] of Object.entries(projection.aliases)) {
+            upsertRoute.run('alias', resolveAssistantSessionRoutingKeyDigest('alias', alias), sessionId);
+        }
+        for (const [conversationKey, sessionId] of Object.entries(projection.conversationKeys)) {
+            upsertRoute.run('conversation-key', resolveAssistantSessionRoutingKeyDigest('conversation-key', conversationKey), sessionId);
+        }
+        for (const [sessionId, lastActiveAt] of Object.entries(pruneAssistantRecentSessions(projection.recentSessions ?? {}))) {
+            upsertRecent.run(sessionId, Date.parse(lastActiveAt));
+        }
+        writeSqliteRuntimeUserVersion(database, ASSISTANT_SESSION_ROUTING_DATABASE_VERSION);
     });
-    await writeJsonFileAtomic(paths.indexesPath, updated);
 }
-export async function readAssistantRecentSessionIds(paths, options) {
-    const limit = Math.max(0, Math.trunc(options.limit));
-    if (limit === 0) {
-        return [];
+async function rebuildAssistantSessionRoutingDatabase(paths, legacyIndex = null) {
+    const projection = await resolveAssistantSessionRoutingProjection(paths, legacyIndex);
+    const databasePath = resolveAssistantSessionRoutingDatabasePath(paths);
+    const rebuildDirectory = path.join(path.dirname(databasePath), '.tmp');
+    const rebuildPath = path.join(rebuildDirectory, `${path.basename(databasePath)}.rebuild`);
+    await rm(rebuildDirectory, { force: true, recursive: true });
+    let rebuilt = null;
+    try {
+        rebuilt = openSqliteRuntimeDatabase(rebuildPath, {
+            journalMode: 'DELETE',
+            synchronous: 'FULL',
+        });
+        await adoptAssistantStateFile(rebuildPath);
+        initializeAssistantSessionRoutingDatabase(rebuilt, projection);
+        rebuilt.close();
+        rebuilt = null;
+        await removeAssistantSessionRoutingDatabaseSidecars(rebuildPath);
+        await removeAssistantSessionRoutingDatabaseSidecars(databasePath);
+        await rename(rebuildPath, databasePath);
+        await rm(rebuildDirectory, { force: true, recursive: true });
+        // A legacy aggregate is one-way migration input. Publishing this projection
+        // establishes the runtime rollback floor before the aggregate is removed.
+        await rm(paths.indexesPath, { force: true });
     }
-    const store = await readAssistantIndexStore(paths);
-    return sortRecentSessionIds(store.recentSessions ?? {}).slice(0, limit);
+    catch (error) {
+        try {
+            rebuilt?.close();
+        }
+        catch {
+            // Preserve the rebuild error that determines recovery.
+        }
+        await rm(rebuildDirectory, { force: true, recursive: true }).catch(() => undefined);
+        throw error;
+    }
+    await appendAssistantRuntimeEventAtPaths(paths, {
+        component: 'state',
+        entityId: 'indexes',
+        entityType: 'indexes',
+        kind: 'indexes.rebuilt',
+        level: 'warn',
+        message: 'Assistant session indexes were rebuilt from available routing state.',
+    }).catch(() => undefined);
+    return openAssistantSessionRoutingDatabase(paths);
 }
-function sortRecentSessionIds(recentSessions) {
-    return Object.entries(recentSessions)
-        .sort(([, left], [, right]) => compareAssistantTimestampsAscending(right, left))
-        .map(([sessionId]) => sessionId);
+async function resolveAssistantSessionRoutingProjection(paths, legacyIndex) {
+    if (legacyIndex?.recentSessions !== undefined) {
+        return legacyIndex;
+    }
+    const rebuilt = buildAssistantSessionRoutingProjection(await collectAssistantSessionsForRoutingRebuild(paths));
+    return legacyIndex
+        ? assistantAliasStoreSchema.parse({
+            ...rebuilt,
+            aliases: legacyIndex.aliases,
+            conversationKeys: legacyIndex.conversationKeys,
+        })
+        : rebuilt;
+}
+function synchronizeAssistantSessionRoutingDatabase(database, session, previous) {
+    return withImmediateTransaction(database, () => {
+        const upsertRoute = database.prepare(`
+      INSERT INTO assistant_session_routes (kind, key_digest, session_id)
+      VALUES (?, ?, ?)
+      ON CONFLICT (kind, key_digest) DO UPDATE SET session_id = excluded.session_id
+    `);
+        const removeRouteIfOwned = database.prepare(`
+      DELETE FROM assistant_session_routes
+      WHERE kind = ? AND key_digest = ? AND session_id = ?
+    `);
+        if (session.alias) {
+            upsertRoute.run('alias', resolveAssistantSessionRoutingKeyDigest('alias', session.alias), session.sessionId);
+        }
+        if (session.binding.conversationKey) {
+            upsertRoute.run('conversation-key', resolveAssistantSessionRoutingKeyDigest('conversation-key', session.binding.conversationKey), session.sessionId);
+        }
+        if (previous?.alias && previous.alias !== session.alias) {
+            removeRouteIfOwned.run('alias', resolveAssistantSessionRoutingKeyDigest('alias', previous.alias), session.sessionId);
+        }
+        if (previous?.binding.conversationKey &&
+            previous.binding.conversationKey !== session.binding.conversationKey) {
+            removeRouteIfOwned.run('conversation-key', resolveAssistantSessionRoutingKeyDigest('conversation-key', previous.binding.conversationKey), session.sessionId);
+        }
+        database.prepare(`
+      INSERT INTO assistant_recent_sessions (session_id, last_active_at_ms)
+      VALUES (?, ?)
+      ON CONFLICT (session_id) DO UPDATE SET last_active_at_ms = excluded.last_active_at_ms
+    `).run(session.sessionId, Date.parse(session.lastTurnAt ?? session.updatedAt));
+        database.exec(`
+      DELETE FROM assistant_recent_sessions
+      WHERE session_id IN (
+        SELECT session_id
+        FROM assistant_recent_sessions
+        ORDER BY last_active_at_ms DESC, session_id ASC
+        LIMIT -1 OFFSET ${ASSISTANT_RECENT_SESSIONS_INDEX_LIMIT}
+      )
+    `);
+    });
+}
+async function quarantineAssistantSessionRoutingDatabase(paths, error) {
+    const databasePath = resolveAssistantSessionRoutingDatabasePath(paths);
+    await quarantineAssistantStateFile({
+        artifactKind: 'indexes',
+        error,
+        filePath: databasePath,
+        paths,
+    });
+    await removeAssistantSessionRoutingDatabaseSidecars(databasePath);
+}
+async function removeAssistantSessionRoutingDatabaseSidecars(databasePath) {
+    await Promise.all([
+        rm(`${databasePath}-journal`, { force: true }),
+        rm(`${databasePath}-shm`, { force: true }),
+        rm(`${databasePath}-wal`, { force: true }),
+    ]);
 }
 function pruneAssistantRecentSessions(recentSessions) {
     return Object.fromEntries(Object.entries(recentSessions)
@@ -641,75 +974,13 @@ export async function readAutomationState(paths, options) {
         return initial;
     }
 }
-function createInitialAssistantIndexStore() {
-    return assistantAliasStoreSchema.parse({
-        version: ASSISTANT_INDEX_STORE_VERSION,
-        aliases: {},
-        conversationKeys: {},
-        recentSessions: {},
-    });
-}
-async function rebuildAssistantIndexStore(paths) {
-    const entries = await readdir(paths.sessionsDirectory, {
-        withFileTypes: true,
-    });
-    const sessions = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.json')) {
-            continue;
-        }
-        try {
-            const session = await readAssistantSession({
-                paths,
-                sessionId: entry.name.replace(/\.json$/u, ''),
-                treatCorruptedAsMissing: true,
-            });
-            if (!session) {
-                continue;
-            }
-            sessions.push(session);
-        }
-        catch {
-            // Quarantine already happened in readAssistantSession; keep rebuild best-effort.
-        }
-    }
-    const aliases = {};
-    const conversationKeys = {};
-    const recentSessions = {};
-    for (const session of sortSessionsForIndexRebuild(sessions)) {
-        if (session.alias) {
-            aliases[session.alias] = session.sessionId;
-        }
-        if (session.binding.conversationKey) {
-            conversationKeys[session.binding.conversationKey] = session.sessionId;
-        }
-        recentSessions[session.sessionId] = resolveAssistantIndexRebuildTimestamp(session);
-    }
-    const rebuilt = assistantAliasStoreSchema.parse({
-        version: ASSISTANT_INDEX_STORE_VERSION,
-        aliases,
-        conversationKeys,
-        recentSessions: pruneAssistantRecentSessions(recentSessions),
-    });
-    await writeJsonFileAtomic(paths.indexesPath, rebuilt);
-    await appendAssistantRuntimeEventAtPaths(paths, {
-        component: 'state',
-        entityId: 'indexes',
-        entityType: 'indexes',
-        kind: 'indexes.rebuilt',
-        level: 'warn',
-        message: 'Assistant session indexes were rebuilt from durable session files.',
-    }).catch(() => undefined);
-    return rebuilt;
-}
-async function hasDurableAssistantSessions(paths) {
-    const entries = await readdir(paths.sessionsDirectory, {
-        withFileTypes: true,
-    });
-    return entries.some((entry) => entry.isFile() && entry.name.endsWith('.json'));
-}
 function sortSessionsForIndexRebuild(sessions) {
-    return [...sessions].sort((left, right) => compareAssistantTimestampsAscending(resolveAssistantIndexRebuildTimestamp(left), resolveAssistantIndexRebuildTimestamp(right)));
+    return [...sessions].sort((left, right) => {
+        const timestampOrder = compareAssistantTimestampsAscending(resolveAssistantIndexRebuildTimestamp(left), resolveAssistantIndexRebuildTimestamp(right));
+        return timestampOrder === 0
+            ? left.sessionId.localeCompare(right.sessionId)
+            : timestampOrder;
+    });
 }
 function resolveAssistantIndexRebuildTimestamp(session) {
     return (normalizeNullableString(session.lastTurnAt) ??