devchain-cli 0.12.3 → 0.13.0

package/dist/server/modules/session-reader/services/transcript-persistence.listener.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -17,26 +50,32 @@ exports.TranscriptPersistenceListener = void 0;
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
 const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
 const db_provider_1 = require("../../storage/db/db.provider");
 const sqlite_raw_1 = require("../../storage/db/sqlite-raw");
 const events_service_1 = require("../../events/services/events.service");
 const transcript_path_validator_service_1 = require("./transcript-path-validator.service");
 const session_reader_adapter_factory_1 = require("../adapters/session-reader-adapter.factory");
 const storage_interface_1 = require("../../storage/interfaces/storage.interface");
+const adapters_1 = require("../../providers/adapters");
 const file_search_util_1 = require("../adapters/utils/file-search.util");
-const DISCOVERY_MAX_RETRIES = 3;
-const DISCOVERY_RETRY_DELAY_MS = 2_000;
-const CONTENT_MATCH_MAX_CANDIDATES = 50;
+const codex_session_reader_adapter_1 = require("../adapters/codex-session-reader.adapter");
+const DISCOVERY_MAX_RETRIES = 6;
+const DISCOVERY_RETRY_BACKOFF_MS = [500, 1_000, 2_000, 4_000, 8_000, 16_000];
+const DISCOVERY_MAX_ATTEMPTS = DISCOVERY_MAX_RETRIES + 1;
+const CONTENT_MATCH_MAX_CANDIDATES = 200;
 const CONTENT_SEARCH_MAX_BYTES_JSONL = 16_384;
-const CONTENT_SEARCH_MAX_BYTES_JSON = 32_768;
 const CONTENT_TIMESTAMP_WINDOW_MS = 120_000;
+const METADATA_TIMESTAMP_WINDOW_MS = 30_000;
 const DISCOVERED_FILE_WARN_BYTES = 10 * 1024 * 1024;
 let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class TranscriptPersistenceListener {
-    constructor(db, validator, events, adapterFactory, storage) {
+    constructor(db, validator, events, adapterFactory, storage, providerAdapterFactory) {
         this.validator = validator;
         this.events = events;
         this.adapterFactory = adapterFactory;
         this.storage = storage;
+        this.providerAdapterFactory = providerAdapterFactory;
         this.logger = new common_1.Logger(TranscriptPersistenceListener_1.name);
         this.sqlite = (0, sqlite_raw_1.getRawSqliteClient)(db);
     }
@@ -106,19 +145,65 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
             this.logger.debug({ sessionId, providerName }, 'No session-reader adapter for provider — skipping auto-discovery');
             return;
         }
-        for (let attempt = 1; attempt <= DISCOVERY_MAX_RETRIES; attempt++) {
-            const isFinalAttempt = attempt === DISCOVERY_MAX_RETRIES;
-            if (this.hasTranscriptPath(sessionId)) {
-                this.logger.debug({ sessionId, attempt }, 'Transcript already discovered — skipping auto-discovery');
+        const realpathCache = new Map();
+        let resolvedProjectRoot = null;
+        const getResolvedProjectRoot = async () => {
+            if (!resolvedProjectRoot) {
+                resolvedProjectRoot = await this.safeRealpathCached(projectRoot, realpathCache);
+            }
+            return resolvedProjectRoot;
+        };
+        for (let attempt = 1; attempt <= DISCOVERY_MAX_ATTEMPTS; attempt++) {
+            const isFinalAttempt = attempt === DISCOVERY_MAX_ATTEMPTS;
+            const gate = this.getDiscoveryGate(sessionId);
+            if (!gate.needsAny) {
+                this.logger.debug({ sessionId, attempt }, 'Transcript metadata already complete — skipping auto-discovery');
                 return;
             }
             const files = await adapter.discoverSessionFile({ projectRoot });
             if (files.length > 0) {
-                if (providerName === 'claude') {
-                    await this.persistDiscoveredPath(sessionId, agentId, projectId, files[0], providerName);
-                    return;
+                const provAdapter = this.resolveProviderAdapter(providerName);
+                if (provAdapter &&
+                    (0, adapters_1.isTranscriptDiscoveryCapable)(provAdapter) &&
+                    provAdapter.transcriptDiscoveryStrategy === 'first') {
+                    const outcome = await this.persistDiscoveredPath(sessionId, agentId, projectId, files[0], providerName);
+                    if (this.shouldStopAfterPersistOutcome(outcome, isFinalAttempt, attempt)) {
+                        return;
+                    }
+                    await this.delayBeforeRetry(attempt);
+                    continue;
+                }
+                const readCandidates = await this.readCandidates(files, providerName, sessionId);
+                const candidates = await this.excludeAlreadyAssignedCandidates(readCandidates, sessionId, realpathCache);
+                if (providerName === 'codex') {
+                    const sessionStartedAt = this.getSessionStartedAt(sessionId);
+                    if (sessionStartedAt) {
+                        const metadataMatch = await this.findByMetadata(candidates, {
+                            projectRootRealpath: await getResolvedProjectRoot(),
+                            sessionStartedAt,
+                            attempt,
+                            maxRetries: DISCOVERY_MAX_ATTEMPTS,
+                            realpathCache,
+                            sessionId,
+                        });
+                        if (metadataMatch) {
+                            this.logger.log({
+                                sessionId,
+                                providerName,
+                                filePath: metadataMatch.file.filePath,
+                                matchType: metadataMatch.matchType,
+                                attempt,
+                                candidatesScanned: candidates.length,
+                            }, 'Auto-discovered transcript via Codex metadata match');
+                            const outcome = await this.persistDiscoveredPath(sessionId, agentId, projectId, metadataMatch.file, providerName);
+                            if (this.shouldStopAfterPersistOutcome(outcome, isFinalAttempt, attempt)) {
+                                return;
+                            }
+                            await this.delayBeforeRetry(attempt);
+                            continue;
+                        }
+                    }
                 }
-                const candidates = await this.readCandidates(files, providerName, sessionId);
                 const contentMatch = this.findMatchByContent(candidates, sessionId);
                 if (contentMatch) {
                     this.logger.log({
@@ -129,23 +214,29 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
                         attempt,
                         candidatesScanned: candidates.length,
                     }, 'Auto-discovered transcript via content match');
-                    await this.persistDiscoveredPath(sessionId, agentId, projectId, contentMatch.file, providerName);
-                    return;
+                    const outcome = await this.persistDiscoveredPath(sessionId, agentId, projectId, contentMatch.file, providerName);
+                    if (this.shouldStopAfterPersistOutcome(outcome, isFinalAttempt, attempt)) {
+                        return;
+                    }
+                    await this.delayBeforeRetry(attempt);
+                    continue;
                 }
                 if (isFinalAttempt) {
                     const sessionStartedAt = this.getSessionStartedAt(sessionId);
                     if (sessionStartedAt) {
-                        const timestampHeuristicMatch = this.findByContentTimestampWindow(candidates, sessionStartedAt, CONTENT_TIMESTAMP_WINDOW_MS);
+                        const timestampHeuristicMatch = await this.findByContentTimestampWindow(candidates, sessionStartedAt, CONTENT_TIMESTAMP_WINDOW_MS, providerName === 'codex' ? await getResolvedProjectRoot() : null, realpathCache);
                         if (timestampHeuristicMatch) {
                             this.logger.warn({
                                 sessionId,
                                 providerName,
                                 filePath: timestampHeuristicMatch.filePath,
+                                matchType: 'timestamp-fallback',
                                 attempt,
                                 candidatesScanned: candidates.length,
                                 hint: 'initial prompt may omit {session_id}',
                             }, 'Auto-discovered transcript via timestamp heuristic fallback');
-                            await this.persistDiscoveredPath(sessionId, agentId, projectId, timestampHeuristicMatch, providerName);
+                            const outcome = await this.persistDiscoveredPath(sessionId, agentId, projectId, timestampHeuristicMatch, providerName);
+                            this.shouldStopAfterPersistOutcome(outcome, isFinalAttempt, attempt);
                             return;
                         }
                     }
@@ -157,12 +248,11 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
                     providerName,
                     attempt,
                     maxRetries: DISCOVERY_MAX_RETRIES,
-                    hint: providerName === 'claude' ? undefined : 'initial prompt may omit {session_id}',
                 }, 'Transcript not found after all discovery retries');
             }
             else {
                 this.logger.debug({ sessionId, providerName, attempt, maxRetries: DISCOVERY_MAX_RETRIES }, 'Transcript file not found — will retry');
-                await this.delay(DISCOVERY_RETRY_DELAY_MS);
+                await this.delayBeforeRetry(attempt);
             }
         }
     }
@@ -183,11 +273,21 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
             return null;
         }
     }
-    hasTranscriptPath(sessionId) {
+    getDiscoveryGate(sessionId) {
         const row = this.sqlite
-            .prepare('SELECT transcript_path FROM sessions WHERE id = ?')
+            .prepare('SELECT transcript_path, provider_session_id FROM sessions WHERE id = ?')
             .get(sessionId);
-        return !!row?.transcript_path;
+        if (!row) {
+            return { needsAny: true, transcriptPath: null, providerSessionId: null };
+        }
+        if (row.transcript_path && row.provider_session_id) {
+            return { needsAny: false };
+        }
+        return {
+            needsAny: true,
+            transcriptPath: row.transcript_path,
+            providerSessionId: row.provider_session_id,
+        };
     }
     async persistDiscoveredPath(sessionId, agentId, projectId, file, providerName) {
         if (file.sizeBytes > DISCOVERED_FILE_WARN_BYTES) {
@@ -199,40 +299,237 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
         }
         catch (error) {
             this.logger.warn({ error, filePath: file.filePath, sessionId }, 'Discovered transcript path failed validation — skipping');
-            return;
+            return { kind: 'skipped', sessionId, reason: 'validationFailed' };
         }
+        const providerSessionId = file.providerSessionId ?? null;
         const now = new Date().toISOString();
-        const result = this.sqlite
-            .prepare(`UPDATE sessions
-         SET transcript_path = ?, provider_session_id = ?, updated_at = ?
-         WHERE id = ? AND transcript_path IS NULL`)
-            .run(normalizedPath, file.providerSessionId ?? null, now, sessionId);
-        if (result.changes === 0) {
-            this.logger.debug({ sessionId }, 'Session transcript_path already set (hook won race) or session not found — skipping');
-            return;
+        let transactionOpen = false;
+        this.sqlite.prepare('BEGIN').run();
+        transactionOpen = true;
+        try {
+            const row = this.sqlite
+                .prepare(`SELECT transcript_path, provider_session_id, provider_name_at_launch
+           FROM sessions
+           WHERE id = ?`)
+                .get(sessionId);
+            if (!row) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                return { kind: 'skipped', sessionId, reason: 'sessionNotFound' };
+            }
+            if (!row.transcript_path) {
+                this.sqlite
+                    .prepare(`UPDATE sessions
+             SET transcript_path = ?, provider_session_id = ?, updated_at = ?
+             WHERE id = ?`)
+                    .run(normalizedPath, providerSessionId, now, sessionId);
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                if (providerSessionId || !this.requiresProviderSessionIdForRestore(providerName)) {
+                    this.logger.log({ sessionId, transcriptPath: normalizedPath, providerName }, 'Auto-discovered and persisted transcript path');
+                    await this.events.publish('session.transcript.discovered', {
+                        sessionId,
+                        agentId,
+                        projectId,
+                        transcriptPath: normalizedPath,
+                        providerName,
+                    });
+                    return { kind: 'persisted', sessionId };
+                }
+                this.logger.log({ sessionId, transcriptPath: normalizedPath, providerName, pathOnly: true }, 'Auto-discovered and persisted transcript path without provider session id');
+                await this.events.publish('session.transcript.discovered', {
+                    sessionId,
+                    agentId,
+                    projectId,
+                    transcriptPath: normalizedPath,
+                    providerName,
+                });
+                return { kind: 'persistedPathOnly', sessionId };
+            }
+            this.sqlite.prepare('COMMIT').run();
+            transactionOpen = false;
+            return this.backfillProviderSessionIdForTranscriptPath({
+                sessionId,
+                providerName,
+                transcriptPath: normalizedPath,
+                providerSessionId,
+            });
+        }
+        catch (error) {
+            if (transactionOpen) {
+                this.sqlite.prepare('ROLLBACK').run();
+            }
+            throw error;
+        }
+    }
+    async backfillProviderSessionIdForTranscriptPath(input) {
+        const incomingPath = this.normalizePathForCompare(input.transcriptPath);
+        const now = new Date().toISOString();
+        const emitEvent = input.emitEvent ?? true;
+        let transactionOpen = false;
+        this.sqlite.prepare('BEGIN').run();
+        transactionOpen = true;
+        try {
+            const row = this.sqlite
+                .prepare(`SELECT transcript_path, provider_session_id, provider_name_at_launch
+           FROM sessions
+           WHERE id = ?`)
+                .get(input.sessionId);
+            if (!row) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                return { kind: 'skipped', sessionId: input.sessionId, reason: 'sessionNotFound' };
+            }
+            if (!row.transcript_path) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                return { kind: 'skipped', sessionId: input.sessionId, reason: 'noTranscriptPath' };
+            }
+            const existingPath = this.normalizePathForCompare(row.transcript_path);
+            if (existingPath !== incomingPath) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                this.logger.warn({
+                    sessionId: input.sessionId,
+                    existing: row.transcript_path,
+                    incoming: input.transcriptPath,
+                }, 'Discovered transcript path does not match existing session path — skipping');
+                return {
+                    kind: 'pathMismatch',
+                    sessionId: input.sessionId,
+                    existing: row.transcript_path,
+                    incoming: input.transcriptPath,
+                };
+            }
+            if (row.provider_session_id) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                return { kind: 'alreadyComplete', sessionId: input.sessionId };
+            }
+            if (!input.providerSessionId) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                if (this.requiresProviderSessionIdForRestore(input.providerName)) {
+                    if (emitEvent) {
+                        this.logger.log({
+                            sessionId: input.sessionId,
+                            transcriptPath: input.transcriptPath,
+                            providerName: input.providerName,
+                            pathOnly: true,
+                        }, 'Discovered transcript path still lacks provider session id');
+                    }
+                    return { kind: 'persistedPathOnly', sessionId: input.sessionId };
+                }
+                return { kind: 'skipped', sessionId: input.sessionId, reason: 'noIdAvailable' };
+            }
+            if (row.provider_name_at_launch &&
+                row.provider_name_at_launch.toLowerCase() !== input.providerName.toLowerCase()) {
+                this.sqlite.prepare('COMMIT').run();
+                transactionOpen = false;
+                return { kind: 'skipped', sessionId: input.sessionId, reason: 'providerMismatch' };
+            }
+            const result = this.sqlite
+                .prepare(`UPDATE sessions
+           SET provider_session_id = ?, updated_at = ?
+           WHERE id = ? AND provider_session_id IS NULL`)
+                .run(input.providerSessionId, now, input.sessionId);
+            this.sqlite.prepare('COMMIT').run();
+            transactionOpen = false;
+            if (result.changes === 0) {
+                return { kind: 'alreadyComplete', sessionId: input.sessionId };
+            }
+            if (emitEvent) {
+                this.logger.log({
+                    sessionId: input.sessionId,
+                    providerName: input.providerName,
+                    providerSessionId: input.providerSessionId,
+                    repaired: true,
+                }, 'Backfilled provider session id for discovered transcript');
+                await this.events.publish('session.providerSessionId.discovered', {
+                    sessionId: input.sessionId,
+                    providerSessionId: input.providerSessionId,
+                    providerName: input.providerName,
+                });
+            }
+            return { kind: 'backfilledId', sessionId: input.sessionId };
+        }
+        catch (error) {
+            if (transactionOpen) {
+                this.sqlite.prepare('ROLLBACK').run();
+            }
+            throw error;
         }
-        this.logger.log({ sessionId, transcriptPath: normalizedPath, providerName }, 'Auto-discovered and persisted transcript path');
-        await this.events.publish('session.transcript.discovered', {
-            sessionId,
-            agentId,
-            projectId,
-            transcriptPath: normalizedPath,
-            providerName,
-        });
+    }
+    shouldStopAfterPersistOutcome(outcome, isFinalAttempt, attempt, maxRetries = DISCOVERY_MAX_RETRIES) {
+        switch (outcome.kind) {
+            case 'persisted':
+            case 'backfilledId':
+            case 'alreadyComplete':
+                return true;
+            case 'persistedPathOnly':
+                if (isFinalAttempt) {
+                    this.logger.warn({
+                        sessionId: outcome.sessionId,
+                        reason: 'providerSessionIdNotFlushed',
+                        attempt,
+                        maxRetries,
+                    }, 'Provider session id not available after final discovery attempt');
+                    return true;
+                }
+                return false;
+            case 'pathMismatch':
+            case 'skipped':
+                this.logger.warn(outcome, 'Transcript persistence did not complete');
+                return true;
+        }
+    }
+    normalizePathForCompare(filePath) {
+        return path.normalize(path.resolve(filePath));
+    }
+    async safeRealpath(filePath) {
+        try {
+            return path.normalize(await fs.realpath(filePath));
+        }
+        catch {
+            return this.normalizePathForCompare(filePath);
+        }
+    }
+    async safeRealpathCached(filePath, cache) {
+        const cached = cache.get(filePath);
+        if (cached) {
+            return cached;
+        }
+        const resolved = await this.safeRealpath(filePath);
+        cache.set(filePath, resolved);
+        return resolved;
+    }
+    requiresProviderSessionIdForRestore(providerName) {
+        const provAdapter = this.resolveProviderAdapter(providerName);
+        if (provAdapter && (0, adapters_1.isTranscriptDiscoveryCapable)(provAdapter)) {
+            return provAdapter.providerSessionIdRequiredForRestore ?? false;
+        }
+        return false;
     }
     async readCandidates(files, providerName, sessionId) {
         const maxBytes = this.getSearchMaxBytes(providerName);
         const candidates = [];
-        const filesToScan = files.slice(0, CONTENT_MATCH_MAX_CANDIDATES);
+        const filesToScan = files.slice(0, this.getContentMatchMaxCandidates(providerName));
         for (const file of filesToScan) {
             const content = await (0, file_search_util_1.readFileHead)(file.filePath, maxBytes);
             if (content === null) {
                 continue;
             }
+            const codexMetadata = providerName.toLowerCase() === 'codex'
+                ? (0, codex_session_reader_adapter_1.extractCodexMetadataFromContent)(content)
+                : undefined;
+            const fileWithProviderSessionId = codexMetadata?.providerSessionId && !file.providerSessionId
+                ? { ...file, providerSessionId: codexMetadata.providerSessionId }
+                : file;
             candidates.push({
-                file,
+                file: fileWithProviderSessionId,
                 content,
                 contentTimestamp: this.extractContentTimestamp(content),
+                codexMetadata,
             });
             if (sessionId && content.includes(sessionId)) {
                 break;
@@ -240,10 +537,39 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
         }
         return candidates;
     }
+    async excludeAlreadyAssignedCandidates(candidates, sessionId, realpathCache) {
+        if (candidates.length === 0) {
+            return candidates;
+        }
+        const assignedRows = this.sqlite
+            .prepare('SELECT id, transcript_path FROM sessions WHERE transcript_path IS NOT NULL')
+            .all();
+        if (assignedRows.length === 0) {
+            return candidates;
+        }
+        const ownedByOtherSession = new Set();
+        for (const row of assignedRows) {
+            if (!row.transcript_path || row.id === sessionId) {
+                continue;
+            }
+            ownedByOtherSession.add(await this.safeRealpathCached(row.transcript_path, realpathCache));
+        }
+        if (ownedByOtherSession.size === 0) {
+            return candidates;
+        }
+        const filtered = [];
+        for (const candidate of candidates) {
+            const candidatePath = await this.safeRealpathCached(candidate.file.filePath, realpathCache);
+            if (!ownedByOtherSession.has(candidatePath)) {
+                filtered.push(candidate);
+            }
+        }
+        return filtered;
+    }
     findMatchByContent(candidates, sessionId) {
         const fullMatch = candidates.find((candidate) => candidate.content.includes(sessionId));
         if (fullMatch) {
-            return { file: fullMatch.file, matchType: 'full' };
+            return { file: fullMatch.file, matchType: 'content' };
         }
         const shortId = sessionId.slice(0, 8);
         if (shortId.length === 0) {
@@ -251,13 +577,52 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
         }
         const shortMatches = candidates.filter((candidate) => candidate.content.includes(`Session ${shortId}`) || candidate.content.includes(shortId));
         if (shortMatches.length === 1) {
-            return { file: shortMatches[0].file, matchType: 'short' };
+            return { file: shortMatches[0].file, matchType: 'short-id' };
         }
         if (shortMatches.length > 1) {
             this.logger.warn({ sessionId, shortId, shortMatchCount: shortMatches.length }, 'Short session prefix matched multiple transcript candidates — refusing ambiguous match');
         }
         return null;
     }
+    async findByMetadata(candidates, ctx) {
+        const windowMs = ctx.attempt === ctx.maxRetries ? CONTENT_TIMESTAMP_WINDOW_MS : METADATA_TIMESTAMP_WINDOW_MS;
+        const metadataCandidates = [];
+        for (const candidate of candidates) {
+            const metadata = candidate.codexMetadata;
+            if (!metadata?.providerSessionId || !metadata.metaCwd || !metadata.metaTimestamp) {
+                continue;
+            }
+            const metaTimestamp = new Date(metadata.metaTimestamp);
+            if (Number.isNaN(metaTimestamp.getTime())) {
+                continue;
+            }
+            const metaCwd = await this.safeRealpathCached(metadata.metaCwd, ctx.realpathCache);
+            if (metaCwd !== ctx.projectRootRealpath) {
+                continue;
+            }
+            const deltaMs = Math.abs(metaTimestamp.getTime() - ctx.sessionStartedAt.getTime());
+            if (deltaMs <= windowMs) {
+                metadataCandidates.push(candidate);
+            }
+        }
+        if (metadataCandidates.length === 0) {
+            return null;
+        }
+        metadataCandidates.sort((a, b) => {
+            const aTimestamp = new Date(a.codexMetadata?.metaTimestamp ?? 0).getTime();
+            const bTimestamp = new Date(b.codexMetadata?.metaTimestamp ?? 0).getTime();
+            return (Math.abs(aTimestamp - ctx.sessionStartedAt.getTime()) -
+                Math.abs(bTimestamp - ctx.sessionStartedAt.getTime()));
+        });
+        if (metadataCandidates.length === 1) {
+            return { file: metadataCandidates[0].file, matchType: 'metadata' };
+        }
+        const contentMatch = this.findMatchByContent(metadataCandidates, ctx.sessionId);
+        if (contentMatch) {
+            return { file: contentMatch.file, matchType: 'metadata+content' };
+        }
+        return null;
+    }
     extractContentTimestamp(content) {
         const codexTimestampMatch = content.match(/"timestamp"\s*:\s*"([^"]+)"/);
         if (codexTimestampMatch?.[1]) {
@@ -275,18 +640,46 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
         }
         return null;
     }
-    findByContentTimestampWindow(candidates, sessionStartedAt, windowMs) {
-        const matchesInWindow = candidates.filter((candidate) => {
+    async findByContentTimestampWindow(candidates, sessionStartedAt, windowMs, projectRootRealpath, realpathCache) {
+        const matchesInWindow = [];
+        for (const candidate of candidates) {
             if (!candidate.contentTimestamp) {
-                return false;
+                continue;
             }
             const deltaMs = Math.abs(candidate.contentTimestamp.getTime() - sessionStartedAt.getTime());
-            return deltaMs <= windowMs;
-        });
-        if (matchesInWindow.length !== 1) {
+            if (deltaMs <= windowMs) {
+                matchesInWindow.push(candidate);
+            }
+        }
+        if (matchesInWindow.length === 0) {
             return null;
         }
-        return matchesInWindow[0].file;
+        const cwdFilteredMatches = [];
+        if (projectRootRealpath) {
+            for (const candidate of matchesInWindow) {
+                if (!candidate.codexMetadata?.metaCwd) {
+                    continue;
+                }
+                const metaCwd = await this.safeRealpathCached(candidate.codexMetadata.metaCwd, realpathCache);
+                if (metaCwd === projectRootRealpath) {
+                    cwdFilteredMatches.push(candidate);
+                }
+            }
+        }
+        const matchesToRank = cwdFilteredMatches.length > 0 ? cwdFilteredMatches : matchesInWindow;
+        const rankedMatches = [...matchesToRank].sort((a, b) => {
+            const aDelta = Math.abs(a.contentTimestamp.getTime() - sessionStartedAt.getTime());
+            const bDelta = Math.abs(b.contentTimestamp.getTime() - sessionStartedAt.getTime());
+            return aDelta - bDelta;
+        });
+        if (rankedMatches.length > 1) {
+            const firstDelta = Math.abs(rankedMatches[0].contentTimestamp.getTime() - sessionStartedAt.getTime());
+            const secondDelta = Math.abs(rankedMatches[1].contentTimestamp.getTime() - sessionStartedAt.getTime());
+            if (firstDelta === secondDelta) {
+                return null;
+            }
+        }
+        return rankedMatches[0].file;
     }
     getSessionStartedAt(sessionId) {
         const row = this.sqlite
@@ -303,13 +696,38 @@ let TranscriptPersistenceListener = TranscriptPersistenceListener_1 = class Tran
         return startedAt;
     }
     getSearchMaxBytes(providerName) {
-        return providerName === 'gemini'
-            ? CONTENT_SEARCH_MAX_BYTES_JSON
-            : CONTENT_SEARCH_MAX_BYTES_JSONL;
+        const provAdapter = this.resolveProviderAdapter(providerName);
+        if (provAdapter &&
+            (0, adapters_1.isTranscriptDiscoveryCapable)(provAdapter) &&
+            provAdapter.transcriptContentSearchMaxBytes) {
+            return provAdapter.transcriptContentSearchMaxBytes;
+        }
+        return CONTENT_SEARCH_MAX_BYTES_JSONL;
+    }
+    getContentMatchMaxCandidates(providerName) {
+        const provAdapter = this.resolveProviderAdapter(providerName);
+        if (provAdapter &&
+            (0, adapters_1.isTranscriptDiscoveryCapable)(provAdapter) &&
+            provAdapter.contentMatchMaxCandidates) {
+            return provAdapter.contentMatchMaxCandidates;
+        }
+        return CONTENT_MATCH_MAX_CANDIDATES;
+    }
+    resolveProviderAdapter(providerName) {
+        try {
+            return this.providerAdapterFactory.getAdapter(providerName);
+        }
+        catch {
+            return undefined;
+        }
     }
     delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    delayBeforeRetry(attempt) {
+        return this.delay(DISCOVERY_RETRY_BACKOFF_MS[attempt - 1] ??
+            DISCOVERY_RETRY_BACKOFF_MS[DISCOVERY_RETRY_BACKOFF_MS.length - 1]);
+    }
 };
 exports.TranscriptPersistenceListener = TranscriptPersistenceListener;
 __decorate([
@@ -331,6 +749,6 @@ exports.TranscriptPersistenceListener = TranscriptPersistenceListener = Transcri
     __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database,
         transcript_path_validator_service_1.TranscriptPathValidator,
         events_service_1.EventsService,
-        session_reader_adapter_factory_1.SessionReaderAdapterFactory, Object])
+        session_reader_adapter_factory_1.SessionReaderAdapterFactory, Object, adapters_1.ProviderAdapterFactory])
 ], TranscriptPersistenceListener);
 //# sourceMappingURL=transcript-persistence.listener.js.map