devchain-cli 0.23.2 → 0.23.3

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

@@ -1,6 +1,7 @@
 import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
 import type { SessionReaderAdapter, SessionSourceRef } from '../adapters/session-reader-adapter.interface';
 import type { UnifiedSession } from '../dtos/unified-session.types';
+import { type FileContentAnchors } from './bounded-anchor-proof';
 import { MetricsService } from '../../metrics/services/metrics.service';
 import type { CacheStats } from '../../metrics/types/metrics.types';
 import type { UnifiedChunk } from '../dtos/unified-chunk.types';
@@ -33,7 +34,7 @@ export interface SessionCacheEntry {
     lastSize: number;
     lastMtime: number;
     fileIdentity?: string;
-    fileContentDigest?: string;
+    fileContentAnchors?: FileContentAnchors;
     sourceVersion: number;
     freshnessToken: unknown;
     lastAccessedAt: number;
@@ -42,6 +43,7 @@ export interface SessionCacheEntry {
     chunks?: CachedChunks;
     dto?: CachedTranscriptDto;
     boundaryFold: boolean;
+    continuationState?: unknown;
 }
 export type SourceChangeKind = 'cache-hit' | 'same-file-append' | 'file-replacement' | 'file-truncation' | 'same-file-rewrite' | 'db-update' | 'unknown-full-parse';
 export interface GetOrParseResult {
@@ -53,7 +55,25 @@ export interface GetOrParseResult {
     lastMtime: number;
     sourceVersion: number;
     boundaryFold: boolean;
+    fileContentAnchors?: FileContentAnchors;
+    continuationState?: unknown;
 }
+export interface PreParseGeneration {
+    sourceVersion: number;
+    messageCount: number;
+    chunkCount: number;
+}
+export type RefreshIfPresentResult = {
+    present: false;
+    lastFullParse?: {
+        seq: number;
+        durationMs: number;
+    };
+} | {
+    present: true;
+    preParse: PreParseGeneration;
+    result: GetOrParseResult;
+};
 export declare class SessionCacheService implements OnModuleDestroy, OnModuleInit {
     private readonly metricsService;
     private readonly logger;
@@ -68,6 +88,8 @@ export declare class SessionCacheService implements OnModuleDestroy, OnModuleIni
     private dtoMisses;
     private budgetUsedBytes;
     private evictions;
+    private fullParseSeq;
+    private readonly fullParseCosts;
     private idleSweepTimer?;
     private readonly config;
     constructor(metricsService: MetricsService, config?: TranscriptCacheConfig);
@@ -80,10 +102,17 @@ export declare class SessionCacheService implements OnModuleDestroy, OnModuleIni
     getOrParse(sessionId: string, source: string | SessionSourceRef, adapter: SessionReaderAdapter): Promise<UnifiedSession>;
     getOrParseWithMeta(sessionId: string, source: string | SessionSourceRef, adapter: SessionReaderAdapter): Promise<GetOrParseResult>;
     private getOrParseResult;
+    refreshIfPresent(sessionId: string, source: string | SessionSourceRef, adapter: SessionReaderAdapter): Promise<RefreshIfPresentResult>;
+    private resolveIfPresentFlight;
+    private toRefreshResult;
     private startParseFlight;
     private sharedResult;
+    private timedFullParse;
+    private recordFullParse;
     private parseSession;
     getEntry(sessionId: string): SessionCacheEntry | undefined;
+    private preParseGeneration;
+    private preParseFromResult;
     getChunks(sessionId: string, sourceVersion: number): UnifiedChunk[] | undefined;
     setChunks(sessionId: string, sourceVersion: number, chunks: UnifiedChunk[]): void;
     getDto(sessionId: string, maxToolResultLength: number, enrichmentFingerprint: string): CachedTranscriptDto | undefined;
@@ -104,12 +133,12 @@ export declare class SessionCacheService implements OnModuleDestroy, OnModuleIni
     private estimateSourceWeight;
     private withoutDerivedChunks;
     private foldLeadingContinuationIntoCachedTail;
-    private mergeMetrics;
     private mergeWarnings;
     private statFile;
     private classifyUnsafeFileChange;
-    private tryHashFileContent;
-    private hashFileContent;
+    private tryHashFileAnchors;
+    private resolveStoredAnchors;
+    private snapshotEndsOnLineBoundary;
     private toSourceRef;
     private sourceIdentity;
     private computeFreshness;

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}`)
@@ -88,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) {
@@ -106,6 +110,7 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             this.idleSweepTimer = undefined;
         }
         this.clear();
+        this.fullParseCosts.clear();
     }
     getCacheStats() {
         const total = this.hits + this.misses;
@@ -190,26 +195,77 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
                 if (sameSource)
                     throw error;
             }
-            if (sameSource && snapshot && flight.generation > arrivalGeneration) {
-                return this.sharedResult(snapshot.result);
+            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 ? snapshot : undefined);
+            const refresh = this.startParseFlight(sessionId, source, adapter, sameSource ? shareable : undefined);
             flight.next = refresh;
             return (await refresh.promise).result;
         }
     }
-    startParseFlight(sessionId, source, adapter, previous) {
+    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))
+                .then(() => this.parseSession(sessionId, source, adapter, sourceIdentity, previous, mode))
                 .finally(() => {
                 if (this.parseFlights.get(sessionId) === flight) {
                     this.parseFlights.delete(sessionId);
@@ -223,30 +279,57 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         this.hits += 1;
         return { ...result, cacheHit: true, sourceChangeKind: 'cache-hit', boundaryFold: false };
     }
-    async parseSession(sessionId, source, adapter, sourceIdentity, previous) {
+    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 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?.session === previous.result.session)
+            if (cached && cached.session === previous.result?.session)
                 this.touchLru(sessionId, cached, now);
-            return { result: this.sharedResult(previous.result), freshnessToken: freshness.token };
+            return {
+                result: this.sharedResult(previous.result),
+                freshnessToken: freshness.token,
+                preParse,
+            };
         }
         const freshSession = this.takeFreshCachedSession(sessionId, cached, freshness.token, now);
         if (freshSession && cached) {
             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;
@@ -254,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'
@@ -273,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;
@@ -309,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,
@@ -329,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);
@@ -339,11 +430,7 @@ 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 = {
@@ -353,13 +440,14 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             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;
@@ -367,11 +455,26 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         return {
             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) {
@@ -473,6 +576,8 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
             lastMtime: entry.lastMtime,
             sourceVersion: entry.sourceVersion,
             boundaryFold: cacheHit ? false : entry.boundaryFold,
+            fileContentAnchors: entry.fileContentAnchors,
+            continuationState: entry.continuationState,
         };
     }
     touchLru(sessionId, entry, now) {
@@ -516,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 };
         }
@@ -552,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) {
@@ -628,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) {