devchain-cli 0.23.1 → 0.23.3

package/dist/server/modules/session-reader/services/transcript-watcher.service.js

@@ -52,10 +52,15 @@ const session_cache_service_1 = require("./session-cache.service");
 const session_reader_adapter_factory_1 = require("../adapters/session-reader-adapter.factory");
 const events_service_1 = require("../../events/services/events.service");
 const chunk_builder_1 = require("../builders/chunk-builder");
+const bounded_anchor_proof_1 = require("./bounded-anchor-proof");
+const metrics_merge_1 = require("./metrics-merge");
+const estimate_content_tokens_1 = require("../adapters/utils/estimate-content-tokens");
 const transcript_cursor_1 = require("./transcript-cursor");
 const transcript_truncation_1 = require("./transcript-truncation");
 const transcript_serialization_1 = require("./transcript-serialization");
 const DEBOUNCE_MS = 100;
+const COSTLY_REFRESH_MS = 50;
+const FILE_REFRESH_COOLDOWN_MS = 2_000;
 const STAT_POLL_INTERVAL_MS = 3_000;
 const MAX_INCREMENTAL_BYTES = 10 * 1024 * 1024;
 function requiresCanonicalRefetch(sourceChangeKind) {
@@ -76,18 +81,27 @@ function requiresCanonicalRefetch(sourceChangeKind) {
 function assertNever(value) {
     throw new Error(`Unhandled source change kind: ${String(value)}`);
 }
+function toFreshnessSnapshot(stat) {
+    return {
+        size: stat.size,
+        mtimeMs: stat.mtime.getTime(),
+        fileIdentity: `${stat.dev}:${stat.ino}`,
+    };
+}
 let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatcherService {
     cacheService;
     adapterFactory;
     events;
     logger = new common_1.Logger(TranscriptWatcherService_1.name);
     watchers = new Map();
+    endingWatchers = new Map();
     constructor(cacheService, adapterFactory, events) {
         this.cacheService = cacheService;
         this.adapterFactory = adapterFactory;
         this.events = events;
     }
     onModuleDestroy() {
+        this.endingWatchers.clear();
         const sessionIds = [...this.watchers.keys()];
         for (const sessionId of sessionIds) {
             this.cleanupResources(sessionId);
@@ -114,106 +128,107 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
         }
         const adapter = this.adapterFactory.getAdapter(providerName);
         const sourceKind = adapter?.sourceKind ?? 'file';
+        if (sourceKind === 'db' && !providerSessionId) {
+            this.logger.warn({ sessionId, filePath, providerName }, 'DB-backed watcher requires providerSessionId — skipping watcher');
+            return;
+        }
+        const sourceRef = sourceKind === 'db' ? { filePath, providerName, providerSessionId, kind: 'db' } : undefined;
+        const state = {
+            sessionId,
+            filePath,
+            providerName,
+            sourceKind,
+            sourceRef,
+            watchPath: sourceKind === 'db' ? `${filePath}-wal` : filePath,
+            fsWatcher: null,
+            pollTimer: null,
+            debounceTimer: null,
+            active: true,
+            pending: false,
+            nextEligibleAt: 0,
+            lastDev: 0,
+            lastIno: 0,
+            lastSize: 0,
+            replacementPending: false,
+            pendingCreation: false,
+            lastMessageCount: 0,
+            lastChunkCount: 0,
+            lastSourceVersion: 0,
+            lastMetrics: { totalTokens: 0, inputTokens: 0, outputTokens: 0, costUsd: 0, messageCount: 0 },
+            lastSummaryMetrics: null,
+            inLane: false,
+            costlyLanePass: false,
+        };
+        this.endingWatchers.delete(sessionId);
+        this.watchers.set(sessionId, state);
         let stat = null;
         try {
             stat = await fsPromises.stat(filePath);
         }
         catch (error) {
+            if (!this.isCurrent(state))
+                return;
             const fsCode = error.code;
             if (sourceKind !== 'file' || fsCode !== 'ENOENT') {
                 this.logger.warn({ sessionId, filePath, fsCode }, 'Cannot stat transcript file — skipping watcher');
+                this.cleanupResources(sessionId);
                 return;
             }
-            this.logger.debug({ sessionId, filePath }, 'Transcript file not created yet — waiting with stat poll');
+            state.pendingCreation = true;
         }
-        let sourceRef;
-        if (sourceKind === 'db') {
-            if (!providerSessionId) {
-                this.logger.warn({ sessionId, filePath, providerName }, 'DB-backed watcher requires providerSessionId — skipping watcher');
-                return;
-            }
-            sourceRef = { filePath, providerName, providerSessionId, kind: 'db' };
-        }
-        const watchPath = sourceKind === 'db' ? `${filePath}-wal` : filePath;
-        let fsWatcher = null;
+        if (!this.isCurrent(state))
+            return;
+        state.lastDev = stat?.dev ?? 0;
+        state.lastIno = stat?.ino ?? 0;
+        state.lastSize = stat?.size ?? 0;
+        state.lastSourceVersion = stat?.size ?? 0;
         if (stat) {
             try {
-                fsWatcher = this.createFsWatcher(sessionId, watchPath);
+                state.fsWatcher = this.createFsWatcher(state);
             }
             catch {
-                this.logger.warn({ sessionId, watchPath }, 'fs.watch failed to start — using poll only (expected for not-yet-created -wal)');
+                this.logger.warn({ sessionId, watchPath: state.watchPath }, 'fs.watch failed to start — using poll only (expected for not-yet-created -wal)');
             }
         }
-        let lastMessageCount = 0;
-        let lastChunkCount = 0;
-        let lastSourceVersion = stat?.size ?? 0;
-        let lastFreshnessToken;
-        let lastMetrics = {
-            totalTokens: 0,
-            inputTokens: 0,
-            outputTokens: 0,
-            costUsd: 0,
-            messageCount: 0,
-        };
-        let lastSummaryMetrics = null;
         try {
-            if (adapter && sourceKind === 'db' && sourceRef) {
-                const { session, sourceVersion } = await this.cacheService.getOrParseWithMeta(sessionId, sourceRef, adapter);
-                lastMessageCount = session.metrics.messageCount;
-                lastChunkCount = (0, chunk_builder_1.buildChunks)(session.messages).length;
-                lastSourceVersion = sourceVersion;
-                lastMetrics = this.toMetricsSnapshot(session.metrics);
-                lastSummaryMetrics = session.metrics;
-                if (adapter.getFreshnessToken) {
-                    lastFreshnessToken = await adapter.getFreshnessToken(sourceRef);
+            if (adapter && (sourceKind === 'db' || (stat && stat.size > 0))) {
+                const seeded = this.isLaneEligible(adapter) && !this.cacheService.getEntry(sessionId)
+                    ? await this.buildLaneFromSummary(state, adapter)
+                    : false;
+                if (!this.isCurrent(state))
+                    return;
+                if (!seeded) {
+                    const result = await this.cacheService.getOrParseWithMeta(sessionId, sourceRef ?? filePath, adapter);
+                    if (!this.isCurrent(state))
+                        return;
+                    this.applyBodyResultToState(state, adapter, result, stat);
+                }
+                if (sourceRef && adapter.getFreshnessToken) {
+                    const token = await adapter.getFreshnessToken(sourceRef);
+                    if (!this.isCurrent(state))
+                        return;
+                    state.lastFreshnessToken = token;
                 }
-            }
-            else if (adapter && stat && stat.size > 0) {
-                const { session, sourceVersion } = await this.cacheService.getOrParseWithMeta(sessionId, filePath, adapter);
-                lastMessageCount = session.metrics.messageCount;
-                lastChunkCount = (0, chunk_builder_1.buildChunks)(session.messages).length;
-                lastSourceVersion = sourceVersion;
-                lastMetrics = this.toMetricsSnapshot(session.metrics);
-                lastSummaryMetrics = session.metrics;
             }
         }
         catch (error) {
+            if (!this.isCurrent(state))
+                return;
             this.logger.warn({ error, sessionId }, 'Failed to seed watcher state — starting from zero');
         }
-        const pollTimer = setInterval(() => {
-            this.pollSource(sessionId).catch((error) => {
-                this.logger.error({ error, sessionId }, 'Source poll error');
-            });
-        }, STAT_POLL_INTERVAL_MS);
-        this.watchers.set(sessionId, {
-            sessionId,
-            filePath,
-            watchPath,
-            providerName,
-            sourceKind,
-            sourceRef,
-            fsWatcher,
-            pollTimer,
-            debounceTimer: null,
-            lastDev: stat?.dev ?? 0,
-            lastIno: stat?.ino ?? 0,
-            lastSize: stat?.size ?? 0,
-            replacementPending: false,
-            pendingCreation: stat === null,
-            lastMessageCount,
-            lastChunkCount,
-            lastMetrics,
-            lastSummaryMetrics,
-            lastFreshnessToken,
-            lastSourceVersion,
-        });
+        if (!this.isCurrent(state))
+            return;
+        state.pollTimer = setInterval(() => this.requestRefresh(state, true), STAT_POLL_INTERVAL_MS);
+        state.active = false;
+        if (state.pending)
+            this.requestRefresh(state);
         this.logger.log({
             sessionId,
             filePath,
-            watchPath,
+            watchPath: state.watchPath,
             sourceKind,
-            pendingCreation: stat === null,
-            hasFsWatch: !!fsWatcher,
+            pendingCreation: state.pendingCreation,
+            hasFsWatch: !!state.fsWatcher,
         }, 'Started transcript watcher');
     }
     toMetricsSnapshot(metrics) {
@@ -231,24 +246,26 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             return;
         const { filePath, providerName, lastMetrics } = state;
         this.cleanupResources(sessionId);
+        this.endingWatchers.set(sessionId, state);
         let finalMetrics = lastMetrics;
         try {
             const adapter = this.adapterFactory.getAdapter(providerName);
             if (adapter) {
-                const source = state.sourceKind === 'db' && state.sourceRef ? state.sourceRef : filePath;
-                const session = await this.cacheService.getOrParse(sessionId, source, adapter);
-                finalMetrics = {
-                    totalTokens: session.metrics.totalTokens,
-                    inputTokens: session.metrics.inputTokens,
-                    outputTokens: session.metrics.outputTokens,
-                    costUsd: session.metrics.costUsd,
-                    messageCount: session.metrics.messageCount,
-                };
+                if (this.isLaneEligible(adapter) && !this.cacheService.getEntry(sessionId)) {
+                    finalMetrics = await this.finalizeLaneMetrics(state, adapter, lastMetrics);
+                }
+                else {
+                    const source = state.sourceKind === 'db' && state.sourceRef ? state.sourceRef : filePath;
+                    const session = await this.cacheService.getOrParse(sessionId, source, adapter);
+                    finalMetrics = this.toMetricsSnapshot(session.metrics);
+                }
             }
         }
         catch (error) {
             this.logger.warn({ error, sessionId }, 'Final parse failed — using last known metrics');
         }
+        if (this.endingWatchers.get(sessionId) !== state)
+            return;
         try {
             await this.events.publish('session.transcript.ended', {
                 sessionId,
@@ -260,6 +277,10 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
         catch (error) {
             this.logger.error({ error, sessionId }, 'Failed to emit transcript ended event');
         }
+        finally {
+            if (this.endingWatchers.get(sessionId) === state)
+                this.endingWatchers.delete(sessionId);
+        }
     }
     get activeWatcherCount() {
         return this.watchers.size;
@@ -275,40 +296,73 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
         if (watcher)
             watcher.lastSummaryMetrics = null;
     }
-    scheduleDebounce(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state)
+    isCurrent(state) {
+        return this.watchers.get(state.sessionId) === state;
+    }
+    laneOwned(state, ending) {
+        const map = ending ? this.endingWatchers : this.watchers;
+        return map.get(state.sessionId) === state;
+    }
+    requestRefresh(state, poll = false) {
+        if (!this.isCurrent(state))
+            return;
+        state.pending = true;
+        if (state.active || state.debounceTimer)
+            return;
+        const remaining = state.nextEligibleAt - performance.now();
+        if (poll && remaining <= 0) {
+            this.launchRefresh(state, true);
             return;
-        if (state.debounceTimer) {
-            clearTimeout(state.debounceTimer);
         }
+        const delay = remaining > 0 ? remaining : DEBOUNCE_MS;
         state.debounceTimer = setTimeout(() => {
             state.debounceTimer = null;
-            this.handleSourceChanged(sessionId).catch((error) => {
-                this.logger.error({ error, sessionId }, 'Error in debounced change handler');
-            });
-        }, DEBOUNCE_MS);
+            this.launchRefresh(state, false);
+        }, delay);
     }
-    async pollSource(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state)
-            return;
-        if (state.sourceKind === 'db') {
-            await this.checkDbPoll(state);
-        }
-        else {
-            await this.checkStatPoll(sessionId);
-        }
+    launchRefresh(state, poll) {
+        const pass = this.runRefresh(state, poll);
+        state.activeRefresh = pass;
+        void pass.finally(() => {
+            if (state.activeRefresh === pass)
+                state.activeRefresh = undefined;
+        });
     }
-    async handleSourceChanged(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state)
+    async runRefresh(state, poll) {
+        if (!this.isCurrent(state))
             return;
-        if (state.sourceKind === 'db') {
-            await this.handleDbChanged(sessionId);
+        state.active = true;
+        state.pending = false;
+        state.costlyLanePass = false;
+        const startedAt = performance.now();
+        try {
+            if (poll) {
+                if (state.sourceKind === 'db')
+                    await this.checkDbPoll(state);
+                else
+                    await this.checkStatPoll(state);
+            }
+            else if (state.sourceKind === 'db') {
+                await this.handleDbChanged(state);
+            }
+            else {
+                await this.handleFileChanged(state);
+            }
         }
-        else {
-            await this.handleFileChanged(sessionId);
+        catch (error) {
+            this.logger.error({ error, sessionId: state.sessionId }, 'Source refresh failed');
+        }
+        finally {
+            if (this.isCurrent(state)) {
+                state.active = false;
+                if (!poll && state.sourceKind === 'file') {
+                    const completedAt = performance.now();
+                    const costly = completedAt - startedAt >= COSTLY_REFRESH_MS || state.costlyLanePass;
+                    state.nextEligibleAt = costly ? completedAt + FILE_REFRESH_COOLDOWN_MS : 0;
+                }
+                if (state.pending)
+                    this.requestRefresh(state);
+            }
         }
     }
     async checkDbPoll(state) {
@@ -323,19 +377,21 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             this.logger.debug({ error, sessionId: state.sessionId }, 'DB freshness poll failed — retry');
             return;
         }
+        if (!this.isCurrent(state))
+            return;
         if (JSON.stringify(token) !== JSON.stringify(state.lastFreshnessToken)) {
-            this.scheduleDebounce(state.sessionId);
+            this.requestRefresh(state);
         }
     }
-    async checkStatPoll(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state)
-            return;
+    async checkStatPoll(state) {
+        const { sessionId } = state;
         let stat;
         try {
             stat = await fsPromises.stat(state.filePath);
         }
         catch (error) {
+            if (!this.isCurrent(state))
+                return;
             if (error.code === 'ENOENT') {
                 if (state.pendingCreation)
                     return;
@@ -345,6 +401,8 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             }
             throw error;
         }
+        if (!this.isCurrent(state))
+            return;
         if (state.pendingCreation) {
             state.pendingCreation = false;
             state.lastDev = stat.dev;
@@ -352,7 +410,7 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             state.lastSize = 0;
             state.replacementPending = true;
             this.reopenFsWatcher(state);
-            this.scheduleDebounce(sessionId);
+            this.requestRefresh(state);
             this.logger.log({ sessionId, filePath: state.filePath }, 'Transcript file materialized — activating watcher');
             return;
         }
@@ -365,36 +423,39 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             state.replacementPending = true;
         }
         if (identityChanged || state.replacementPending || stat.size !== state.lastSize) {
-            this.scheduleDebounce(sessionId);
+            this.requestRefresh(state);
         }
     }
-    async handleFileChanged(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state)
-            return;
+    async handleFileChanged(state) {
+        const { sessionId } = state;
         try {
             let stat;
             try {
                 stat = await fsPromises.stat(state.filePath);
             }
             catch (error) {
+                if (!this.isCurrent(state))
+                    return;
                 if (error.code === 'ENOENT') {
+                    if (state.pendingCreation)
+                        return;
                     this.logger.warn({ sessionId }, 'Transcript file deleted during change handling');
                     await this.stopWatching(sessionId, 'file.deleted');
                     return;
                 }
                 throw error;
             }
+            if (!this.isCurrent(state))
+                return;
             const identityChanged = stat.dev !== state.lastDev || stat.ino !== state.lastIno;
-            const isReplacement = state.replacementPending || identityChanged;
-            if (identityChanged) {
+            const isReplacement = state.pendingCreation || state.replacementPending || identityChanged;
+            if (identityChanged || state.pendingCreation) {
                 this.logger.debug({ sessionId }, 'Inode rotation detected');
                 this.reopenFsWatcher(state);
                 state.lastDev = stat.dev;
                 state.lastIno = stat.ino;
+                state.pendingCreation = false;
             }
-            if (stat.size === state.lastSize && !isReplacement)
-                return;
             const delta = stat.size - state.lastSize;
             if (delta > MAX_INCREMENTAL_BYTES) {
                 this.logger.warn({ sessionId, delta, maxBytes: MAX_INCREMENTAL_BYTES }, 'Incremental delta exceeds 10MB bound — proceeding with parse');
@@ -404,77 +465,343 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
                 this.logger.error({ sessionId, providerName: state.providerName }, 'No adapter found');
                 return;
             }
-            const { session, sourceChangeKind, sourceVersion } = await this.cacheService.getOrParseWithMeta(sessionId, state.filePath, adapter);
-            const boundaryFold = this.cacheService.getEntry(sessionId)?.boundaryFold ?? false;
-            const newMessageCount = session.metrics.messageCount - state.lastMessageCount;
-            const isFullRefresh = isReplacement || session.metrics.messageCount < state.lastMessageCount;
-            if (isFullRefresh) {
-                this.logger.debug({
-                    sessionId,
-                    isReplacement,
-                    previousMessageCount: state.lastMessageCount,
-                    messageCount: session.metrics.messageCount,
-                }, 'Transcript source replaced or messageCount deflated — requiring canonical refetch');
+            if (this.isLaneEligible(adapter)) {
+                const outcome = await this.cacheService.refreshIfPresent(sessionId, state.filePath, adapter);
+                if (!this.isCurrent(state))
+                    return;
+                if (!outcome.present) {
+                    const last = outcome.lastFullParse;
+                    const readerPaidCostlyFullParse = last !== undefined &&
+                        last.seq !== state.lastFullParseSeqSeen &&
+                        last.durationMs >= COSTLY_REFRESH_MS;
+                    state.lastFullParseSeqSeen = last?.seq;
+                    await this.runFileLane(state, stat, adapter, isReplacement, {
+                        readerPaidCostlyFullParse,
+                    });
+                    return;
+                }
+                if (state.inLane) {
+                    state.lastSourceVersion = outcome.preParse.sourceVersion;
+                    state.lastMessageCount = outcome.preParse.messageCount;
+                    state.lastChunkCount = outcome.preParse.chunkCount;
+                    state.inLane = false;
+                }
+                await this.publishBodyResult(state, stat, adapter, outcome.result, isReplacement);
+                return;
             }
-            const chunks = (0, chunk_builder_1.buildChunks)(session.messages);
-            const prevCursor = (0, transcript_cursor_1.encodeCursor)(state.lastSourceVersion, state.lastMessageCount, state.lastChunkCount);
-            const cursor = (0, transcript_cursor_1.encodeCursor)(sourceVersion, session.metrics.messageCount, chunks.length);
-            const replaceFromChunkIndex = isFullRefresh ? 0 : Math.max(0, state.lastChunkCount - 1);
-            const sliceFromMessage = isFullRefresh ? 0 : state.lastMessageCount;
-            const newChunkIds = chunks.slice(replaceFromChunkIndex).map((c) => c.id);
-            const truncatedDeltaMessages = (0, transcript_truncation_1.truncateMessages)(session.messages.slice(sliceFromMessage));
-            const truncatedDeltaChunks = (0, transcript_truncation_1.truncateChunks)(chunks.slice(replaceFromChunkIndex));
-            const deltaChunks = truncatedDeltaChunks.map(transcript_serialization_1.serializeChunk);
-            const deltaMessages = truncatedDeltaMessages.map(transcript_serialization_1.serializeMessage);
-            state.lastSize = stat.size;
-            state.lastSourceVersion = sourceVersion;
-            state.lastDev = stat.dev;
-            state.lastIno = stat.ino;
-            state.replacementPending = false;
-            state.lastMessageCount = session.metrics.messageCount;
-            state.lastChunkCount = chunks.length;
-            state.lastMetrics = {
-                totalTokens: session.metrics.totalTokens,
-                inputTokens: session.metrics.inputTokens,
-                outputTokens: session.metrics.outputTokens,
-                costUsd: session.metrics.costUsd,
-                messageCount: session.metrics.messageCount,
-            };
-            state.lastSummaryMetrics = session.metrics;
-            if (isReplacement || requiresCanonicalRefetch(sourceChangeKind)) {
-                await this.events.publish('session.transcript.updated', {
-                    kind: 'full-refetch-required',
-                    sessionId,
-                    transcriptPath: state.filePath,
-                    sourceChangeKind,
-                });
+            const result = await this.cacheService.getOrParseWithMeta(sessionId, state.filePath, adapter);
+            if (!this.isCurrent(state))
                 return;
+            await this.publishBodyResult(state, stat, adapter, result, isReplacement);
+        }
+        catch (error) {
+            this.logger.error({ error, sessionId }, 'File change handler failed — watcher continues');
+        }
+    }
+    isLaneEligible(adapter) {
+        return (adapter.sourceKind ?? 'file') === 'file' && adapter.incrementalMode === 'delta';
+    }
+    laneRef(state) {
+        return (state.sourceRef ?? {
+            filePath: state.filePath,
+            providerName: state.providerName,
+            kind: 'file',
+        });
+    }
+    async laneFreshness(filePath) {
+        try {
+            return toFreshnessSnapshot(await fsPromises.stat(filePath));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async tryHashAnchors(filePath, expected, offset, allowGrowth = false) {
+        try {
+            return await (0, bounded_anchor_proof_1.hashFileAnchors)(filePath, expected, offset, allowGrowth);
+        }
+        catch (error) {
+            this.logger.debug({ error, filePath }, 'Lane anchor proof unavailable — rescanning');
+            return undefined;
+        }
+    }
+    async buildLaneFromSummary(state, adapter, ending = false) {
+        if (!adapter.getSummary)
+            return false;
+        const summary = await adapter.getSummary(this.laneRef(state));
+        if (!this.laneOwned(state, ending))
+            return true;
+        if (!summary?.laneSeed)
+            return false;
+        const seed = summary.laneSeed;
+        const fresh = await this.laneFreshness(state.filePath);
+        if (!this.laneOwned(state, ending))
+            return true;
+        const anchors = fresh
+            ? await this.tryHashAnchors(state.filePath, fresh, seed.endOffset)
+            : undefined;
+        if (!this.laneOwned(state, ending))
+            return true;
+        state.lane = {
+            offset: seed.endOffset,
+            anchors,
+            fileIdentity: fresh?.fileIdentity,
+            revision: fresh?.mtimeMs,
+            metrics: { ...summary.metrics },
+            tail: seed.tail,
+            visibleContextTokens: seed.visibleContextTokens,
+            firstMessageTimestamp: seed.firstMessageTimestamp,
+            lastMessageTimestamp: seed.lastMessageTimestamp,
+            continuationState: seed.continuationState,
+            messageCount: seed.messageCount,
+        };
+        state.inLane = true;
+        this.applyLaneToState(state);
+        return true;
+    }
+    markStatConsumed(state, stat) {
+        state.lastSize = stat.size;
+        state.lastDev = stat.dev;
+        state.lastIno = stat.ino;
+        state.replacementPending = false;
+    }
+    applyLaneToState(state) {
+        const lane = state.lane;
+        if (!lane)
+            return;
+        state.lastMessageCount = lane.messageCount;
+        state.lastMetrics = this.toMetricsSnapshot(lane.metrics);
+        state.lastSummaryMetrics = lane.metrics;
+    }
+    refreshLaneFromResult(state, result, stat) {
+        const msgs = result.session.messages;
+        const last = msgs[msgs.length - 1];
+        const visibleContextTokens = result.sourceChangeKind === 'same-file-append'
+            ? result.session.metrics.visibleContextTokens
+            : (0, estimate_content_tokens_1.estimateVisibleFromMessages)(msgs);
+        const fresh = toFreshnessSnapshot(stat);
+        state.lane = {
+            offset: result.lastOffset,
+            anchors: result.fileContentAnchors,
+            fileIdentity: fresh.fileIdentity,
+            revision: fresh.mtimeMs,
+            metrics: result.session.metrics,
+            tail: (0, metrics_merge_1.describeTail)(last),
+            visibleContextTokens,
+            firstMessageTimestamp: msgs.length > 0 ? msgs[0].timestamp.getTime() : undefined,
+            lastMessageTimestamp: last ? last.timestamp.getTime() : undefined,
+            continuationState: result.continuationState,
+            messageCount: msgs.length,
+        };
+    }
+    advanceVisible(base, messages) {
+        let visible = base;
+        for (const m of messages) {
+            if (m.isCompactSummary) {
+                visible = 0;
+                continue;
             }
-            const isInPlaceTailFold = boundaryFold && newMessageCount === 0 && !isFullRefresh;
-            if (newMessageCount > 0 || isFullRefresh || isInPlaceTailFold) {
-                await this.events.publish('session.transcript.updated', {
-                    kind: 'delta',
-                    sessionId,
-                    transcriptPath: state.filePath,
-                    newMessageCount: Math.max(0, newMessageCount),
-                    metrics: state.lastMetrics,
-                    cursor,
-                    prevCursor,
-                    replaceFromChunkIndex,
-                    newChunkIds,
-                    totalChunkCount: chunks.length,
-                    deltaChunks,
-                    deltaMessages,
+            if (m.isSidechain)
+                continue;
+            visible += (0, estimate_content_tokens_1.estimateMessageTokens)(m.content);
+        }
+        return visible;
+    }
+    advanceLaneWithSlice(lane, slice, proofAnchors, fresh) {
+        const newMessages = slice.entries;
+        const fold = (0, metrics_merge_1.computeLeadingContinuationFold)(lane.tail, newMessages);
+        const netNew = newMessages.length - fold.foldCount;
+        const newCount = lane.messageCount + netNew;
+        const newVisible = this.advanceVisible(lane.visibleContextTokens, newMessages);
+        const firstTs = lane.firstMessageTimestamp ??
+            (newMessages.length > 0 ? newMessages[0].timestamp.getTime() : undefined);
+        const lastTs = netNew > 0
+            ? newMessages[newMessages.length - 1].timestamp.getTime()
+            : lane.lastMessageTimestamp;
+        let durationMs = lane.metrics.durationMs;
+        if (newCount >= 2 && firstTs !== undefined && lastTs !== undefined) {
+            durationMs = lastTs - firstTs;
+        }
+        const derived = { messageCount: newCount, visibleContextTokens: newVisible, durationMs };
+        lane.metrics = slice.metrics
+            ? (0, metrics_merge_1.mergeMetrics)(lane.metrics, slice.metrics, derived)
+            : { ...lane.metrics, ...derived };
+        lane.offset = slice.nextByteOffset;
+        lane.anchors = proofAnchors;
+        lane.fileIdentity = fresh.fileIdentity;
+        lane.revision = fresh.mtimeMs;
+        lane.tail = fold.newTail;
+        lane.visibleContextTokens = newVisible;
+        lane.firstMessageTimestamp = firstTs;
+        lane.lastMessageTimestamp = lastTs;
+        lane.continuationState = slice.continuationState;
+        lane.messageCount = newCount;
+        return netNew > 0 || fold.tailMutatedWithoutNewMessage;
+    }
+    async runFileLane(state, stat, adapter, isReplacement, { readerPaidCostlyFullParse = false, ending = false, } = {}) {
+        state.inLane = true;
+        const fresh = toFreshnessSnapshot(stat);
+        const lane = state.lane;
+        if (!isReplacement &&
+            lane !== undefined &&
+            lane.fileIdentity === fresh.fileIdentity &&
+            lane.revision === fresh.mtimeMs &&
+            fresh.size === lane.offset) {
+            this.markStatConsumed(state, stat);
+            return;
+        }
+        const canAppend = !isReplacement &&
+            lane !== undefined &&
+            lane.anchors !== undefined &&
+            lane.fileIdentity === fresh.fileIdentity &&
+            fresh.size > lane.offset;
+        let advanced = false;
+        let changed = false;
+        if (canAppend && lane) {
+            const preAnchors = await this.tryHashAnchors(state.filePath, fresh, lane.offset);
+            if (!this.laneOwned(state, ending))
+                return;
+            if ((0, bounded_anchor_proof_1.anchorsEqual)(preAnchors, lane.anchors)) {
+                const slice = await adapter.parseIncremental(state.filePath, {
+                    byteOffset: lane.offset,
+                    endByteOffset: fresh.size,
+                    includeToolCalls: true,
+                    continuationState: lane.continuationState,
                 });
+                if (!this.laneOwned(state, ending))
+                    return;
+                const newOffset = slice.nextByteOffset;
+                const prefixHeld = newOffset >= lane.offset &&
+                    (0, bounded_anchor_proof_1.anchorsEqual)(await this.tryHashAnchors(state.filePath, fresh, lane.offset, true), lane.anchors);
+                if (!this.laneOwned(state, ending))
+                    return;
+                const proofAnchors = prefixHeld
+                    ? await this.tryHashAnchors(state.filePath, fresh, newOffset, true)
+                    : undefined;
+                if (!this.laneOwned(state, ending))
+                    return;
+                if (proofAnchors) {
+                    changed = this.advanceLaneWithSlice(lane, slice, proofAnchors, fresh);
+                    advanced = true;
+                }
             }
         }
-        catch (error) {
-            this.logger.error({ error, sessionId }, 'File change handler failed — watcher continues');
+        if (!advanced) {
+            const reseeded = await this.buildLaneFromSummary(state, adapter, ending);
+            if (!this.laneOwned(state, ending))
+                return;
+            if (!reseeded)
+                return;
+            changed = true;
+        }
+        this.markStatConsumed(state, stat);
+        this.applyLaneToState(state);
+        if (changed && !ending) {
+            if (readerPaidCostlyFullParse)
+                state.costlyLanePass = true;
+            await this.events.publish('session.transcript.updated', {
+                kind: 'full-refetch-required',
+                sessionId: state.sessionId,
+                transcriptPath: state.filePath,
+                sourceChangeKind: 'unknown-full-parse',
+            });
         }
     }
-    async handleDbChanged(sessionId) {
-        const state = this.watchers.get(sessionId);
-        if (!state || !state.sourceRef)
+    async finalizeLaneMetrics(state, adapter, fallback) {
+        const statIfOwned = async () => {
+            try {
+                const stat = await fsPromises.stat(state.filePath);
+                return this.laneOwned(state, true) ? stat : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        let stat = await statIfOwned();
+        if (!stat)
+            return fallback;
+        const inflight = state.activeRefresh;
+        if (inflight) {
+            await inflight.catch(() => undefined);
+            stat = await statIfOwned();
+            if (!stat)
+                return fallback;
+        }
+        await this.runFileLane(state, stat, adapter, false, { ending: true });
+        return this.laneOwned(state, true) ? state.lastMetrics : fallback;
+    }
+    applyBodyResultToState(state, adapter, result, stat) {
+        state.lastMessageCount = result.session.metrics.messageCount;
+        state.lastChunkCount = (0, chunk_builder_1.buildChunks)(result.session.messages).length;
+        state.lastSourceVersion = result.sourceVersion;
+        state.lastMetrics = this.toMetricsSnapshot(result.session.metrics);
+        state.lastSummaryMetrics = result.session.metrics;
+        state.inLane = false;
+        if (stat && this.isLaneEligible(adapter))
+            this.refreshLaneFromResult(state, result, stat);
+    }
+    async publishBodyResult(state, stat, adapter, result, isReplacement) {
+        const { sessionId } = state;
+        const { session, sourceChangeKind, sourceVersion, boundaryFold } = result;
+        const changedCacheHit = sourceChangeKind === 'cache-hit' && sourceVersion !== state.lastSourceVersion;
+        const newMessageCount = session.metrics.messageCount - state.lastMessageCount;
+        const isFullRefresh = isReplacement || session.metrics.messageCount < state.lastMessageCount;
+        if (isFullRefresh) {
+            this.logger.debug({
+                sessionId,
+                isReplacement,
+                previousMessageCount: state.lastMessageCount,
+                messageCount: session.metrics.messageCount,
+            }, 'Transcript source replaced or messageCount deflated — requiring canonical refetch');
+        }
+        const chunks = (0, chunk_builder_1.buildChunks)(session.messages);
+        const prevCursor = (0, transcript_cursor_1.encodeCursor)(state.lastSourceVersion, state.lastMessageCount, state.lastChunkCount);
+        const cursor = (0, transcript_cursor_1.encodeCursor)(sourceVersion, session.metrics.messageCount, chunks.length);
+        const replaceFromChunkIndex = isFullRefresh ? 0 : Math.max(0, state.lastChunkCount - 1);
+        const sliceFromMessage = isFullRefresh ? 0 : state.lastMessageCount;
+        const newChunkIds = chunks.slice(replaceFromChunkIndex).map((c) => c.id);
+        const truncatedDeltaMessages = (0, transcript_truncation_1.truncateMessages)(session.messages.slice(sliceFromMessage));
+        const truncatedDeltaChunks = (0, transcript_truncation_1.truncateChunks)(chunks.slice(replaceFromChunkIndex));
+        const deltaChunks = truncatedDeltaChunks.map(transcript_serialization_1.serializeChunk);
+        const deltaMessages = truncatedDeltaMessages.map(transcript_serialization_1.serializeMessage);
+        this.markStatConsumed(state, stat);
+        state.lastSourceVersion = sourceVersion;
+        state.lastMessageCount = session.metrics.messageCount;
+        state.lastChunkCount = chunks.length;
+        state.lastMetrics = this.toMetricsSnapshot(session.metrics);
+        state.lastSummaryMetrics = session.metrics;
+        if (this.isLaneEligible(adapter))
+            this.refreshLaneFromResult(state, result, stat);
+        if (isReplacement || changedCacheHit || requiresCanonicalRefetch(sourceChangeKind)) {
+            await this.events.publish('session.transcript.updated', {
+                kind: 'full-refetch-required',
+                sessionId,
+                transcriptPath: state.filePath,
+                sourceChangeKind,
+            });
+            return;
+        }
+        const isInPlaceTailFold = boundaryFold && newMessageCount === 0 && !isFullRefresh;
+        if (newMessageCount > 0 || isFullRefresh || isInPlaceTailFold) {
+            await this.events.publish('session.transcript.updated', {
+                kind: 'delta',
+                sessionId,
+                transcriptPath: state.filePath,
+                newMessageCount: Math.max(0, newMessageCount),
+                metrics: state.lastMetrics,
+                cursor,
+                prevCursor,
+                replaceFromChunkIndex,
+                newChunkIds,
+                totalChunkCount: chunks.length,
+                deltaChunks,
+                deltaMessages,
+            });
+        }
+    }
+    async handleDbChanged(state) {
+        const { sessionId } = state;
+        if (!state.sourceRef)
             return;
         try {
             const adapter = this.adapterFactory.getAdapter(state.providerName);
@@ -491,11 +818,15 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
                     this.logger.debug({ error, sessionId }, 'DB freshness check failed during change — retry');
                     return;
                 }
+                if (!this.isCurrent(state))
+                    return;
                 if (JSON.stringify(token) === JSON.stringify(state.lastFreshnessToken)) {
                     return;
                 }
             }
             const { session, sourceVersion } = await this.cacheService.getOrParseWithMeta(sessionId, state.sourceRef, adapter);
+            if (!this.isCurrent(state))
+                return;
             const isFullRefresh = session.metrics.messageCount < state.lastMessageCount;
             if (isFullRefresh) {
                 this.logger.debug({
@@ -540,29 +871,34 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
             this.logger.error({ error, sessionId }, 'DB change handler failed — watcher continues');
         }
     }
-    createFsWatcher(sessionId, watchPath) {
-        const watcher = fs.watch(watchPath, (eventType) => {
+    createFsWatcher(state) {
+        const { sessionId } = state;
+        const watcher = fs.watch(state.watchPath, (eventType) => {
+            if (!this.isCurrent(state) || state.fsWatcher !== watcher)
+                return;
             if (eventType === 'change' || eventType === 'rename') {
-                this.scheduleDebounce(sessionId);
+                this.requestRefresh(state);
             }
         });
         watcher.on('error', (err) => {
+            if (!this.isCurrent(state) || state.fsWatcher !== watcher)
+                return;
             this.logger.warn({ error: err, sessionId }, 'fs.watch error — relying on stat-poll fallback');
-            const state = this.watchers.get(sessionId);
-            if (state?.fsWatcher) {
-                state.fsWatcher.close();
-                state.fsWatcher = null;
-            }
+            state.fsWatcher = null;
+            watcher.close();
         });
         return watcher;
     }
     reopenFsWatcher(state) {
+        if (!this.isCurrent(state))
+            return;
         if (state.fsWatcher) {
-            state.fsWatcher.close();
+            const previous = state.fsWatcher;
             state.fsWatcher = null;
+            previous.close();
         }
         try {
-            state.fsWatcher = this.createFsWatcher(state.sessionId, state.watchPath);
+            state.fsWatcher = this.createFsWatcher(state);
         }
         catch {
             this.logger.warn({ sessionId: state.sessionId }, 'Failed to reopen fs.watch after inode rotation');
@@ -572,12 +908,17 @@ let TranscriptWatcherService = TranscriptWatcherService_1 = class TranscriptWatc
         const state = this.watchers.get(sessionId);
         if (!state)
             return;
+        this.watchers.delete(sessionId);
         if (state.debounceTimer)
             clearTimeout(state.debounceTimer);
-        clearInterval(state.pollTimer);
+        state.debounceTimer = null;
+        state.pending = false;
+        if (state.pollTimer)
+            clearInterval(state.pollTimer);
+        state.pollTimer = null;
         if (state.fsWatcher)
             state.fsWatcher.close();
-        this.watchers.delete(sessionId);
+        state.fsWatcher = null;
         this.logger.debug({ sessionId }, 'Cleaned up transcript watcher');
     }
 };