devchain-cli 0.23.1 → 0.23.3

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

@@ -51,15 +51,17 @@ exports.getTranscriptCacheConfig = getTranscriptCacheConfig;
 const common_1 = require("@nestjs/common");
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs/promises"));
-const estimate_content_tokens_1 = require("../adapters/utils/estimate-content-tokens");
-const tool_result_fold_1 = require("../adapters/utils/tool-result-fold");
 const coalesce_turns_1 = require("../adapters/utils/coalesce-turns");
+const metrics_merge_1 = require("./metrics-merge");
+const bounded_anchor_proof_1 = require("./bounded-anchor-proof");
+const bounded_line_read_1 = require("../parsers/bounded-line-read");
 const metrics_service_1 = require("../../metrics/services/metrics.service");
+const chunk_builder_1 = require("../builders/chunk-builder");
 const DEFAULT_CACHE_IDLE_TTL_MS = 10 * 60 * 1_000;
 const DEFAULT_CACHE_SWEEP_INTERVAL_MS = 60_000;
 const DEFAULT_CACHE_BUDGET_BYTES = 64 * 1024 * 1024;
 const SAFE_INTEGER_LOW_BITS = 0x20_0000;
-const FILE_HASH_CHUNK_BYTES = 64 * 1024;
+const FULL_PARSE_COST_CAP = 256;
 function fileSourceVersion(stat) {
     const digest = (0, node_crypto_1.createHash)('sha256')
         .update(`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`)
@@ -78,6 +80,8 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
     metricsService;
     logger = new common_1.Logger(SessionCacheService_1.name);
     cache = new Map();
+    parseFlights = new Map();
+    flightGeneration = 0;
     hits = 0;
     misses = 0;
     chunksHits = 0;
@@ -86,6 +90,8 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
     dtoMisses = 0;
     budgetUsedBytes = 0;
     evictions = 0;
+    fullParseSeq = 0;
+    fullParseCosts = new Map();
     idleSweepTimer;
     config;
     constructor(metricsService, config) {
@@ -104,6 +110,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             this.idleSweepTimer = undefined;
         }
         this.clear();
+        this.fullParseCosts.clear();
     }
     getCacheStats() {
         const total = this.hits + this.misses;
@@ -159,6 +166,8 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         if (!cached)
             return undefined;
         const ref = this.toSourceRef(source, adapter);
+        if (cached.sourceIdentity !== this.sourceIdentity(ref))
+            return undefined;
         const freshness = await this.computeFreshness(ref, adapter);
         return this.takeFreshCachedSession(sessionId, cached, freshness.token, Date.now());
     }
@@ -169,20 +178,158 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         return this.getOrParseResult(sessionId, source, adapter);
     }
     async getOrParseResult(sessionId, source, adapter) {
+        const sourceIdentity = this.sourceIdentity(this.toSourceRef(source, adapter));
+        const arrivalGeneration = this.flightGeneration;
+        const existing = this.parseFlights.get(sessionId);
+        if (!existing) {
+            return (await this.startParseFlight(sessionId, source, adapter).promise).result;
+        }
+        let flight = existing;
+        for (;;) {
+            const sameSource = flight.sourceIdentity === sourceIdentity;
+            let snapshot;
+            try {
+                snapshot = await flight.promise;
+            }
+            catch (error) {
+                if (sameSource)
+                    throw error;
+            }
+            const shareable = snapshot && !snapshot.absent ? snapshot : undefined;
+            if (sameSource && shareable && flight.generation > arrivalGeneration) {
+                return this.sharedResult(shareable.result);
+            }
+            const next = flight.next ?? this.parseFlights.get(sessionId);
+            if (next) {
+                flight = next;
+                continue;
+            }
+            const refresh = this.startParseFlight(sessionId, source, adapter, sameSource ? shareable : undefined);
+            flight.next = refresh;
+            return (await refresh.promise).result;
+        }
+    }
+    async refreshIfPresent(sessionId, source, adapter) {
+        const snapshot = await this.resolveIfPresentFlight(sessionId, source, adapter);
+        return this.toRefreshResult(sessionId, snapshot);
+    }
+    async resolveIfPresentFlight(sessionId, source, adapter) {
+        const sourceIdentity = this.sourceIdentity(this.toSourceRef(source, adapter));
+        const arrivalGeneration = this.flightGeneration;
+        const existing = this.parseFlights.get(sessionId);
+        if (!existing) {
+            return this.startParseFlight(sessionId, source, adapter, undefined, 'ifPresent').promise;
+        }
+        let flight = existing;
+        for (;;) {
+            const sameSource = flight.sourceIdentity === sourceIdentity;
+            let snapshot;
+            try {
+                snapshot = await flight.promise;
+            }
+            catch {
+            }
+            const shareable = snapshot && !snapshot.absent ? snapshot : undefined;
+            if (sameSource && shareable && flight.generation > arrivalGeneration) {
+                return shareable;
+            }
+            const next = flight.next ?? this.parseFlights.get(sessionId);
+            if (next) {
+                flight = next;
+                continue;
+            }
+            const refresh = this.startParseFlight(sessionId, source, adapter, sameSource ? shareable : undefined, 'ifPresent');
+            flight.next = refresh;
+            return refresh.promise;
+        }
+    }
+    toRefreshResult(sessionId, snapshot) {
+        if (snapshot.absent || !snapshot.result) {
+            const record = this.fullParseCosts.get(sessionId);
+            return record
+                ? { present: false, lastFullParse: { seq: record.seq, durationMs: record.durationMs } }
+                : { present: false };
+        }
+        if (snapshot.preParse) {
+            return { present: true, preParse: snapshot.preParse, result: snapshot.result };
+        }
+        return {
+            present: true,
+            preParse: this.preParseFromResult(snapshot.result),
+            result: this.sharedResult(snapshot.result),
+        };
+    }
+    startParseFlight(sessionId, source, adapter, previous, mode = 'always') {
+        const sourceIdentity = this.sourceIdentity(this.toSourceRef(source, adapter));
+        const flight = {
+            sourceIdentity,
+            generation: ++this.flightGeneration,
+            promise: Promise.resolve()
+                .then(() => this.parseSession(sessionId, source, adapter, sourceIdentity, previous, mode))
+                .finally(() => {
+                if (this.parseFlights.get(sessionId) === flight) {
+                    this.parseFlights.delete(sessionId);
+                }
+            }),
+        };
+        this.parseFlights.set(sessionId, flight);
+        return flight;
+    }
+    sharedResult(result) {
+        this.hits += 1;
+        return { ...result, cacheHit: true, sourceChangeKind: 'cache-hit', boundaryFold: false };
+    }
+    async timedFullParse(sessionId, adapter, filePath, threadRef) {
+        const startedAt = performance.now();
+        const session = threadRef
+            ? await adapter.parseFullSession(filePath, threadRef)
+            : await adapter.parseFullSession(filePath);
+        this.recordFullParse(sessionId, performance.now() - startedAt);
+        return session;
+    }
+    recordFullParse(sessionId, durationMs) {
+        this.fullParseSeq += 1;
+        if (!this.fullParseCosts.has(sessionId) && this.fullParseCosts.size >= FULL_PARSE_COST_CAP) {
+            const oldest = this.fullParseCosts.keys().next().value;
+            if (oldest !== undefined)
+                this.fullParseCosts.delete(oldest);
+        }
+        this.fullParseCosts.set(sessionId, { seq: this.fullParseSeq, durationMs });
+    }
+    async parseSession(sessionId, source, adapter, sourceIdentity, previous, mode = 'always') {
         const now = Date.now();
         const ref = this.toSourceRef(source, adapter);
         const threadRef = typeof source !== 'string' ? ref : undefined;
         let freshness = await this.computeFreshness(ref, adapter);
-        const cached = this.cache.get(sessionId);
+        const retained = this.cache.get(sessionId);
+        const cached = retained?.sourceIdentity === sourceIdentity ? retained : undefined;
+        if (mode === 'ifPresent' && !cached) {
+            return { absent: true, freshnessToken: freshness.token };
+        }
+        const preParse = mode === 'ifPresent' && cached ? this.preParseGeneration(cached) : undefined;
+        if (previous && JSON.stringify(previous.freshnessToken) === JSON.stringify(freshness.token)) {
+            if (cached && cached.session === previous.result?.session)
+                this.touchLru(sessionId, cached, now);
+            return {
+                result: this.sharedResult(previous.result),
+                freshnessToken: freshness.token,
+                preParse,
+            };
+        }
         const freshSession = this.takeFreshCachedSession(sessionId, cached, freshness.token, now);
         if (freshSession && cached) {
-            return this.toGetOrParseResult(freshSession, cached, true, 'cache-hit');
+            return {
+                result: this.toGetOrParseResult(freshSession, cached, true, 'cache-hit'),
+                freshnessToken: freshness.token,
+                preParse,
+            };
         }
         this.misses += 1;
         let session;
         let lastOffset;
         let boundaryFold = false;
-        let acceptedFileDigests;
+        let acceptedFileAnchors;
+        let continuationState;
         const sameFileIdentity = ref.kind !== 'file' ||
             (cached?.fileIdentity !== undefined && cached.fileIdentity === freshness.fileIdentity);
         const fileReplaced = cached !== undefined && ref.kind === 'file' && !sameFileIdentity;
@@ -190,12 +337,12 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             ref.kind === 'file' &&
             sameFileIdentity &&
             freshness.size > cached.lastSize;
-        const growthDigests = sameIdentityGrowth && cached.fileContentDigest !== undefined
-            ? await this.tryHashFileContent(ref.filePath, freshness, cached.lastOffset)
+        const growthAnchors = sameIdentityGrowth && cached.fileContentAnchors !== undefined
+            ? await this.tryHashFileAnchors(ref.filePath, freshness, cached.lastOffset)
             : undefined;
         const provenSameFileAppend = sameIdentityGrowth &&
-            cached.fileContentDigest !== undefined &&
-            growthDigests?.prefixDigest === cached.fileContentDigest;
+            cached.fileContentAnchors !== undefined &&
+            (0, bounded_anchor_proof_1.anchorsEqual)(growthAnchors, cached.fileContentAnchors);
         let sourceChangeKind = !cached
             ? 'unknown-full-parse'
             : ref.kind === 'db'
@@ -209,26 +356,36 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
                         : freshness.size < cached.lastSize
                             ? 'file-truncation'
                             : 'same-file-rewrite';
-        if (cached && provenSameFileAppend && growthDigests) {
+        if (cached && provenSameFileAppend && cached.fileContentAnchors) {
             this.logger.debug({ sessionId, lastOffset: cached.lastOffset, currentSize: freshness.size }, 'Incremental parse (source grew)');
             const incOptions = { byteOffset: cached.lastOffset, includeToolCalls: true };
+            if (adapter.incrementalMode === 'delta') {
+                incOptions.endByteOffset = freshness.size;
+            }
+            if (cached.continuationState !== undefined) {
+                incOptions.continuationState = cached.continuationState;
+            }
             let tentativeResult = threadRef
                 ? await adapter.parseIncremental(ref.filePath, incOptions, threadRef)
                 : await adapter.parseIncremental(ref.filePath, incOptions);
-            const postParseDigests = await this.tryHashFileContent(ref.filePath, freshness, freshness.size);
-            if (postParseDigests?.fullDigest !== growthDigests.fullDigest) {
+            const newOffset = tentativeResult.nextByteOffset;
+            const prefixHeld = newOffset >= cached.lastOffset &&
+                (0, bounded_anchor_proof_1.anchorsEqual)(await this.tryHashFileAnchors(ref.filePath, freshness, cached.lastOffset, true), cached.fileContentAnchors);
+            const proofAnchors = prefixHeld
+                ? await this.tryHashFileAnchors(ref.filePath, freshness, newOffset, true)
+                : undefined;
+            if (proofAnchors === undefined) {
                 this.logger.debug({ sessionId }, 'Discarding incremental parse because its proven file revision drifted');
                 tentativeResult = undefined;
                 freshness = await this.computeFreshness(ref, adapter);
                 sourceChangeKind = this.classifyUnsafeFileChange(cached, freshness);
-                session = threadRef
-                    ? await adapter.parseFullSession(ref.filePath, threadRef)
-                    : await adapter.parseFullSession(ref.filePath);
+                session = await this.timedFullParse(sessionId, adapter, ref.filePath, threadRef);
                 lastOffset = freshness.size;
             }
             else {
                 const acceptedResult = tentativeResult;
-                acceptedFileDigests = postParseDigests;
+                acceptedFileAnchors = proofAnchors;
+                continuationState = acceptedResult.continuationState;
                 const newMessages = acceptedResult.entries;
                 if (adapter.incrementalMode === 'snapshot') {
                     const snapshotMetrics = acceptedResult.metrics ?? cached.session.metrics;
@@ -245,7 +402,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
                     boundaryFold = folded.tailMutatedWithoutNewMessage;
                     const mergedMessages = folded.merged;
                     const mergedMetrics = acceptedResult.metrics
-                        ? this.mergeMetrics(cached.session.metrics, acceptedResult.metrics, mergedMessages)
+                        ? (0, metrics_merge_1.mergeMetrics)(cached.session.metrics, acceptedResult.metrics, (0, metrics_merge_1.deriveMergeInputsFromMessages)(cached.session.metrics, mergedMessages))
                         : cached.session.metrics;
                     session = {
                         ...cached.session,
@@ -265,9 +422,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             else if (cached && freshness.size < cached.lastSize) {
                 this.logger.debug({ sessionId }, 'Full reparse (source truncated)');
             }
-            session = threadRef
-                ? await adapter.parseFullSession(ref.filePath, threadRef)
-                : await adapter.parseFullSession(ref.filePath);
+            session = await this.timedFullParse(sessionId, adapter, ref.filePath, threadRef);
             lastOffset = freshness.size;
         }
         const coalesced = (0, coalesce_turns_1.coalesceAssistantTurns)(session);
@@ -275,44 +430,51 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             session = { ...session, messages: coalesced.messages, metrics: coalesced.metrics };
         }
         session = this.withoutDerivedChunks(session);
-        const fileContentDigest = ref.kind === 'file'
-            ? lastOffset === freshness.size && acceptedFileDigests !== undefined
-                ? acceptedFileDigests.fullDigest
-                : (await this.tryHashFileContent(ref.filePath, freshness, lastOffset))?.prefixDigest
-            : undefined;
+        const fileContentAnchors = await this.resolveStoredAnchors(ref, freshness, lastOffset, acceptedFileAnchors);
         this.deleteEntry(sessionId);
         const sourceWeightBytes = this.estimateSourceWeight(ref, session, freshness.size);
         const entry = {
+            sourceIdentity,
             session,
             lastOffset,
             lastSize: freshness.size,
             lastMtime: freshness.mtimeMs,
             fileIdentity: freshness.fileIdentity,
-            fileContentDigest,
+            fileContentAnchors,
             sourceVersion: freshness.sourceVersion,
             freshnessToken: freshness.token,
             lastAccessedAt: now,
             sourceWeightBytes,
             weights: { parsed: sourceWeightBytes * 2, chunks: 0, dto: 0 },
             boundaryFold,
+            continuationState,
         };
         this.cache.set(sessionId, entry);
         this.budgetUsedBytes += entry.weights.parsed;
         this.enforceBudget();
         return {
-            session,
-            cacheHit: false,
-            sourceChangeKind,
-            lastOffset,
-            lastSize: freshness.size,
-            lastMtime: freshness.mtimeMs,
-            sourceVersion: freshness.sourceVersion,
-            boundaryFold,
+            result: this.toGetOrParseResult(session, entry, false, sourceChangeKind),
+            freshnessToken: freshness.token,
+            preParse,
         };
     }
     getEntry(sessionId) {
         return this.cache.get(sessionId);
     }
+    preParseGeneration(entry) {
+        return {
+            sourceVersion: entry.sourceVersion,
+            messageCount: entry.session.messages.length,
+            chunkCount: entry.chunks?.chunks.length ?? (0, chunk_builder_1.buildChunks)(entry.session.messages).length,
+        };
+    }
+    preParseFromResult(result) {
+        return {
+            sourceVersion: result.sourceVersion,
+            messageCount: result.session.messages.length,
+            chunkCount: result.session.chunks?.length ?? (0, chunk_builder_1.buildChunks)(result.session.messages).length,
+        };
+    }
     getChunks(sessionId, sourceVersion) {
         const entry = this.cache.get(sessionId);
         if (!entry?.chunks || entry.chunks.sourceVersion !== sourceVersion) {
@@ -394,7 +556,9 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         return this.cache.size;
     }
     takeFreshCachedSession(sessionId, cached, freshnessToken, now) {
-        if (!cached || JSON.stringify(cached.freshnessToken) !== JSON.stringify(freshnessToken)) {
+        if (!cached ||
+            this.cache.get(sessionId) !== cached ||
+            JSON.stringify(cached.freshnessToken) !== JSON.stringify(freshnessToken)) {
             return undefined;
         }
         this.logger.debug({ sessionId }, 'Session cache hit');
@@ -411,10 +575,14 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             lastSize: entry.lastSize,
             lastMtime: entry.lastMtime,
             sourceVersion: entry.sourceVersion,
-            boundaryFold: entry.boundaryFold,
+            boundaryFold: cacheHit ? false : entry.boundaryFold,
+            fileContentAnchors: entry.fileContentAnchors,
+            continuationState: entry.continuationState,
         };
     }
     touchLru(sessionId, entry, now) {
+        if (this.cache.get(sessionId) !== entry)
+            return;
         entry.lastAccessedAt = now;
         this.cache.delete(sessionId);
         this.cache.set(sessionId, entry);
@@ -453,27 +621,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
     }
     foldLeadingContinuationIntoCachedTail(cachedMessages, newMessages) {
         const tail = cachedMessages[cachedMessages.length - 1];
-        if (!tail || tail.role !== 'assistant' || newMessages.length === 0) {
-            return { merged: [...cachedMessages, ...newMessages], tailMutatedWithoutNewMessage: false };
-        }
-        let foldCount = 0;
-        let tailStopReason = tail.stopReason ?? null;
-        while (foldCount < newMessages.length) {
-            const m = newMessages[foldCount];
-            if (m.isSidechain !== tail.isSidechain)
-                break;
-            if (m.isCompactSummary)
-                break;
-            const isToolResult = (0, tool_result_fold_1.isToolResultOnlyMessage)(m);
-            const isContinuationAssistant = m.role === 'assistant';
-            if (!isToolResult && !isContinuationAssistant)
-                break;
-            if (isContinuationAssistant && tailStopReason === 'end_turn')
-                break;
-            if (isContinuationAssistant)
-                tailStopReason = m.stopReason ?? null;
-            foldCount += 1;
-        }
+        const { foldCount, tailMutatedWithoutNewMessage } = (0, metrics_merge_1.computeLeadingContinuationFold)((0, metrics_merge_1.describeTail)(tail), newMessages);
         if (foldCount === 0) {
             return { merged: [...cachedMessages, ...newMessages], tailMutatedWithoutNewMessage: false };
         }
@@ -489,51 +637,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         const remaining = newMessages.slice(foldCount);
         return {
             merged: [...cachedMessages.slice(0, -1), foldedTail, ...remaining],
-            tailMutatedWithoutNewMessage: remaining.length === 0,
-        };
-    }
-    mergeMetrics(existing, incremental, allMessages) {
-        const inputTokens = existing.inputTokens + incremental.inputTokens;
-        const outputTokens = existing.outputTokens + incremental.outputTokens;
-        const cacheReadTokens = existing.cacheReadTokens + incremental.cacheReadTokens;
-        const cacheCreationTokens = existing.cacheCreationTokens + incremental.cacheCreationTokens;
-        const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens;
-        let durationMs = existing.durationMs;
-        if (allMessages.length >= 2) {
-            durationMs =
-                allMessages[allMessages.length - 1].timestamp.getTime() -
-                    allMessages[0].timestamp.getTime();
-        }
-        const modelsSet = new Set();
-        if (existing.primaryModel)
-            modelsSet.add(existing.primaryModel);
-        if (incremental.primaryModel)
-            modelsSet.add(incremental.primaryModel);
-        if (existing.modelsUsed)
-            existing.modelsUsed.forEach((m) => modelsSet.add(m));
-        if (incremental.modelsUsed)
-            incremental.modelsUsed.forEach((m) => modelsSet.add(m));
-        const modelsUsed = modelsSet.size > 1 ? Array.from(modelsSet) : undefined;
-        return {
-            inputTokens,
-            outputTokens,
-            cacheReadTokens,
-            cacheCreationTokens,
-            totalTokens,
-            costUsd: existing.costUsd + incremental.costUsd,
-            primaryModel: incremental.primaryModel ?? existing.primaryModel,
-            modelsUsed,
-            isOngoing: incremental.isOngoing,
-            visibleContextTokens: (0, estimate_content_tokens_1.estimateVisibleFromMessages)(allMessages),
-            totalContextTokens: incremental.totalContextTokens > 0
-                ? incremental.totalContextTokens
-                : existing.totalContextTokens,
-            contextWindowTokens: incremental.contextWindowTokens ?? existing.contextWindowTokens,
-            messageCount: allMessages.length,
-            durationMs,
-            totalContextConsumption: existing.totalContextConsumption,
-            compactionCount: existing.compactionCount,
-            phaseBreakdowns: existing.phaseBreakdowns,
+            tailMutatedWithoutNewMessage,
         };
     }
     mergeWarnings(existing, incremental) {
@@ -565,59 +669,31 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         }
         return 'same-file-rewrite';
     }
-    async tryHashFileContent(filePath, expected, prefixLength) {
+    async tryHashFileAnchors(filePath, expected, offset, allowGrowth = false) {
         try {
-            return await this.hashFileContent(filePath, expected, prefixLength);
+            return await (0, bounded_anchor_proof_1.hashFileAnchors)(filePath, expected, offset, allowGrowth);
         }
         catch (error) {
-            this.logger.debug({ error, filePath }, 'File prefix proof unavailable — append is unsafe');
+            this.logger.debug({ error, filePath }, 'File anchor proof unavailable — append is unsafe');
             return undefined;
         }
     }
-    async hashFileContent(filePath, expected, prefixLength) {
-        if (!Number.isSafeInteger(prefixLength) ||
-            prefixLength < 0 ||
-            prefixLength > expected.size ||
-            expected.fileIdentity === undefined) {
-            throw new Error('Invalid file prefix proof bounds');
-        }
-        const handle = await fs.open(filePath, 'r');
-        const assertStableSnapshot = async () => {
-            const current = await handle.stat();
-            if (current.size !== expected.size ||
-                current.mtime.getTime() !== expected.mtimeMs ||
-                `${current.dev}:${current.ino}` !== expected.fileIdentity) {
-                throw new Error('File changed while computing append proof');
-            }
-        };
+    async resolveStoredAnchors(ref, freshness, lastOffset, acceptedFileAnchors) {
+        if (ref.kind !== 'file')
+            return undefined;
+        if (acceptedFileAnchors)
+            return acceptedFileAnchors;
+        if (!(await this.snapshotEndsOnLineBoundary(ref.filePath, lastOffset)))
+            return undefined;
+        return this.tryHashFileAnchors(ref.filePath, freshness, lastOffset);
+    }
+    async snapshotEndsOnLineBoundary(filePath, offset) {
         try {
-            await assertStableSnapshot();
-            const prefixHash = (0, node_crypto_1.createHash)('sha256');
-            const fullHash = (0, node_crypto_1.createHash)('sha256');
-            const buffer = Buffer.allocUnsafe(Math.min(FILE_HASH_CHUNK_BYTES, Math.max(1, expected.size)));
-            let position = 0;
-            while (position < expected.size) {
-                const requested = Math.min(buffer.byteLength, expected.size - position);
-                const { bytesRead } = await handle.read(buffer, 0, requested, position);
-                if (bytesRead === 0) {
-                    throw new Error('File ended while computing append proof');
-                }
-                const chunk = buffer.subarray(0, bytesRead);
-                fullHash.update(chunk);
-                const prefixBytes = Math.min(bytesRead, Math.max(0, prefixLength - position));
-                if (prefixBytes > 0) {
-                    prefixHash.update(chunk.subarray(0, prefixBytes));
-                }
-                position += bytesRead;
-            }
-            await assertStableSnapshot();
-            return {
-                prefixDigest: prefixHash.digest('hex'),
-                fullDigest: fullHash.digest('hex'),
-            };
+            return (await (0, bounded_line_read_1.lastCompleteLineEnd)(filePath, 0, offset)) === offset;
         }
-        finally {
-            await handle.close();
+        catch (error) {
+            this.logger.debug({ error, filePath }, 'Line-boundary probe failed — withholding append proof');
+            return false;
         }
     }
     toSourceRef(source, adapter) {
@@ -630,6 +706,14 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         }
         return source;
     }
+    sourceIdentity(ref) {
+        return JSON.stringify([
+            ref.providerName.trim().toLowerCase(),
+            ref.kind,
+            ref.filePath,
+            ref.kind === 'db' ? ref.providerSessionId : undefined,
+        ]);
+    }
     async computeFreshness(ref, adapter) {
         const { size, mtimeMs, dev, ino, fileIdentity } = await this.statFile(ref.filePath);
         const adapterToken = adapter.getFreshnessToken