From 02757a0de84e56096fc224292503294c86278404 Mon Sep 17 00:00:00 2001 From: mariopasquali Date: Sun, 8 Nov 2026 20:07:11 +0100 Subject: [PATCH 1/3] fix(persist): retain calibration model provenance on cold load --- src/persist.ts | 11 ++-- tests/persist-calibration-model.test.ts | 80 +++++++++++++++++++++++++ 2 files changed, 87 insertions(+), 4 deletions(-) create mode 100644 tests/persist-calibration-model.test.ts diff --git a/src/persist.ts b/src/persist.ts index 4b16a3ebb9..a66eb8fb10 100644 --- a/src/persist.ts +++ b/src/persist.ts @@ -222,7 +222,8 @@ interface PersistedSession { lastUsageGradeTokens?: number; calibratedEstimate?: number; calibratedEstimateOrigin?: string; - calibrationRing?: { origin: string; values: number[] }; + calibratedEstimateModel?: string; + calibrationRing?: { origin: string; model?: string; values: number[] }; pendingFoldUsage?: boolean; lastLocalTextEstimate?: number; lastLocalTextEstimateOrigin?: string; @@ -4106,14 +4107,15 @@ function restoreCalibratedEstimate(v: unknown): number | undefined { // itself would admit (finite, within the plausibility band) and only the newest // window-size entries; anything else drops the ring wholesale so a malformed // file can neither teach a factor nor mask a fresh learning run on restart. -function restoreCalibrationRing(v: unknown): { origin: string; values: number[] } | undefined { +function restoreCalibrationRing(v: unknown): { origin: string; model?: string; values: number[] } | undefined { if (!v || typeof v !== "object") return undefined; - const ring = v as { origin?: unknown; values?: unknown }; + const ring = v as { origin?: unknown; model?: unknown; values?: unknown }; if (typeof ring.origin !== "string" || ring.origin.length === 0) return undefined; if (!Array.isArray(ring.values)) return undefined; const values = ring.values.filter((x): x is number => typeof x === "number" && Number.isFinite(x) && x >= CALIBRATION_SAMPLE_MIN && x <= CALIBRATION_SAMPLE_MAX); const recent = values.slice(-CALIBRATION_SAMPLE_WINDOW); - return recent.length > 0 ? { origin: ring.origin, values: recent } : undefined; + const model = typeof ring.model === "string" && ring.model.trim().length > 0 ? ring.model : undefined; + return recent.length > 0 ? { origin: ring.origin, ...(model === undefined ? {} : { model }), values: recent } : undefined; } function restoreBlockContents(entries: Iterable): Map { @@ -4199,6 +4201,7 @@ function buildSession(parsed: PersistedSession): Session { lastInputTokensOrigin: typeof stats.lastInputTokensOrigin === "string" && stats.lastInputTokensOrigin.trim().length > 0 ? stats.lastInputTokensOrigin : undefined, calibratedEstimate: restoreCalibratedEstimate(stats.calibratedEstimate), calibratedEstimateOrigin: typeof stats.calibratedEstimateOrigin === "string" && stats.calibratedEstimateOrigin.trim().length > 0 ? stats.calibratedEstimateOrigin : undefined, + calibratedEstimateModel: typeof stats.calibratedEstimateModel === "string" && stats.calibratedEstimateModel.trim().length > 0 ? stats.calibratedEstimateModel : undefined, calibrationRing: restoreCalibrationRing(stats.calibrationRing), // Intentionally NOT restored (#2129 triage): pendingFoldUsage is set at // compress execution and consumed only as a log-suffix attribution by the diff --git a/tests/persist-calibration-model.test.ts b/tests/persist-calibration-model.test.ts new file mode 100644 index 0000000000..85de57705c --- /dev/null +++ b/tests/persist-calibration-model.test.ts @@ -0,0 +1,80 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import {mkdtempSync, readdirSync, readFileSync, writeFileSync} from 'node:fs'; +import {tmpdir} from 'node:os'; +import path from 'node:path'; +import {createInitialState} from 'acp-kernel'; +import {SessionStore} from '../src/persist.ts'; +import type {Session} from '../src/session.ts'; +import {currentCalibrationFactor} from '../src/util.ts'; +import {rmrf} from './tmp-rm.ts'; + +process.env.BILI_CONFIG_FILE = path.join(tmpdir(), 'calibration-model-no-config.json'); +process.env.BILI_PERSIST_ZSTD = '0'; + +function session(id: string, model?: string): Session { + return {id, meta:{protocol:'anthropic',upstreamOrigin:'http://synthetic.invalid'}, + stats:{requests:3,tokensSaved:0,inputTokens:10,cachedTokens:0,outputTokens:5, + cacheSamples:0,lastInputTokens:10,contextTokens:1000,compressCreditTokens:0, + retrieveCalls:0,retrieveHits:0,retrieveMisses:0,storedBytes:0,storeBytesSaved:0,rangeRestores:0, + calibratedEstimate:0.8,calibratedEstimateOrigin:'http://synthetic.invalid', + calibratedEstimateModel:model, + calibrationRing:{origin:'http://synthetic.invalid',...(model === undefined ? {} : {model}),values:[0.8,0.8]}}, + metadata:{},createdAt:1700000000000,lastSeen:1700000001000,state:createInitialState(), + blockContents:new Map(),inFlight:0,persisted:false,pendingRetrievals:[]}; +} + +for (const mode of ['legacy','full']) { + for (const model of ['synthetic-model-a', undefined]) { + test(`calibration provenance survives ${mode} cold load (${model ?? 'legacy unknown model'})`, async () => { + process.env.BILI_STORAGE_UNIFIED = mode; + const dir = mkdtempSync(path.join(tmpdir(),'bili-calibration-model-')); + const original = session('calibration-roundtrip',model); + let store = new SessionStore({dir,enabled:true,debounceMs:1}); + try { + await store.writeNow(original); + store.closeQuietly(); + store = new SessionStore({dir,enabled:true,debounceMs:1}); + const restored = store.loadSync(original.id,original.meta); + assert.ok(restored); + assert.deepEqual(restored.stats.calibrationRing,original.stats.calibrationRing, + 'Cold load must retain the ring including its exact model provenance'); + assert.equal(restored.stats.calibratedEstimateModel,model); + assert.equal(currentCalibrationFactor(restored.stats,'synthetic-model-a'),0.8); + assert.equal(currentCalibrationFactor(restored.stats,'synthetic-model-b'), + model === undefined ? 0.8 : undefined, + 'Known-model factors must not cross a model switch; unknown legacy models retain existing behavior'); + } finally {store.closeQuietly();rmrf(dir);} + }); + } +} + +for (const invalid of [123,' ',{},null]) { + test(`invalid persisted model provenance is rejected (${JSON.stringify(invalid)})`, async () => { + process.env.BILI_STORAGE_UNIFIED = 'legacy'; + const dir = mkdtempSync(path.join(tmpdir(),'bili-calibration-invalid-model-')); + const original = session('invalid-provenance','synthetic-model-a'); + let store = new SessionStore({dir,enabled:true,debounceMs:1}); + try { + await store.writeNow(original); + store.closeQuietly(); + const files = readdirSync(dir,{recursive:true}).filter(x => typeof x === 'string' && x.endsWith('.json')); + const file = files.map(x => path.join(dir,String(x))).find(x => { + const raw = JSON.parse(readFileSync(x,'utf8')); + return (raw.payload ?? raw).id === original.id; + }); + assert.ok(file,'Fixture must have written its session envelope'); + const raw = JSON.parse(readFileSync(file,'utf8')); + const payload = raw.payload ?? raw; + payload.stats.calibrationRing.model = invalid; + payload.stats.calibratedEstimateModel = invalid; + writeFileSync(file,JSON.stringify(raw)); + store = new SessionStore({dir,enabled:true,debounceMs:1}); + const restored = store.loadSync(original.id,original.meta); + assert.ok(restored); + assert.equal(restored.stats.calibrationRing?.model,undefined); + assert.equal(restored.stats.calibratedEstimateModel,undefined); + assert.deepEqual(restored.stats.calibrationRing?.values,[0.8,0.8]); + } finally {store.closeQuietly();rmrf(dir);} + }); +} From fa9b19215923ca069f227b66db1ff9196df77904 Mon Sep 17 00:00:00 2001 From: mariopasquali Date: Sun, 8 Nov 2026 21:18:05 +0100 Subject: [PATCH 2/3] test: pin restored calibration model provenance --- tests/golden/storage-render/anthropic.json | 6 +++--- tests/golden/storage-render/chat.json | 6 +++--- tests/golden/storage-render/google.json | 6 +++--- tests/golden/storage-render/responses.json | 6 +++--- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/golden/storage-render/anthropic.json b/tests/golden/storage-render/anthropic.json index 558829d15d..4a4635108a 100644 --- a/tests/golden/storage-render/anthropic.json +++ b/tests/golden/storage-render/anthropic.json @@ -95,12 +95,12 @@ "foldAt": 9, "editedAt": 12, "summaryFrom": 9, - "stateDigest": "1f528f4fee4f59026d3b005f99a0489cadc139e54698896b2e5a0dadbc95ee2b", - "stateDigestAligned": "a796f61ccd006f5fa1573e1ef33bf756dc24bf017154fab8bde4c0b369516537", + "stateDigest": "a23b586430ac45c20ef2dde916ef8a4c61411da597ac6919adeaa34443da9788", + "stateDigestAligned": "439eaffb4cbd4a0123ca87885c1de7ca511795ab7de232abeeda4a84bf992a8d", "sectionDigests": { "state": "56e66f6b72c7f0dd", "blockContents": "dc7d13d250c94bb4", - "stats": "e83198a55e6b2c29", + "stats": "7bab3f342a5398ab", "metadata": "65894bb8839e9947" }, "stateKeyDigests": { diff --git a/tests/golden/storage-render/chat.json b/tests/golden/storage-render/chat.json index ae4923dd78..68cbe276e2 100644 --- a/tests/golden/storage-render/chat.json +++ b/tests/golden/storage-render/chat.json @@ -95,12 +95,12 @@ "foldAt": 9, "editedAt": 12, "summaryFrom": 9, - "stateDigest": "a7b5a67f54a2cbd7978e2a57ad78f522f7af8f94a4e2402898aee4d93479541a", - "stateDigestAligned": "76f701f5ab1631fe1615a3f1cd8fa0fcd0a3fa19c02658cc5d077ae565f4897a", + "stateDigest": "90c1cb8316cb9773a232553e9df85203dad45e5eeaa0a8793e8ea9b4dd12d91d", + "stateDigestAligned": "75c6bb40c005994e35b80aaad7f9df065b8fdd6fc81a81259bcc542cf706dcad", "sectionDigests": { "state": "90857fbf82001a2b", "blockContents": "94a58f96d7c5cfc3", - "stats": "5c2f0fe203d710e8", + "stats": "fecf844aec250fc2", "metadata": "0c7d1819e0d4c0f6" }, "stateKeyDigests": { diff --git a/tests/golden/storage-render/google.json b/tests/golden/storage-render/google.json index 3dde0e8cdc..8e142db87c 100644 --- a/tests/golden/storage-render/google.json +++ b/tests/golden/storage-render/google.json @@ -95,12 +95,12 @@ "foldAt": 9, "editedAt": 12, "summaryFrom": 9, - "stateDigest": "f8d07462fd8881896c5b52864e84ff9a1a79b0cdb73cd2ef87e16d361b5a07d3", - "stateDigestAligned": "219c42a0f17ed7c9061174627ca56e5b6733e7413d8af98953105bf5d60a40b7", + "stateDigest": "a55c6c0f1183719742c722ec9dd3ab6b73fabe0b4df7b11de0898a200d884fe5", + "stateDigestAligned": "e5fd59bf2e422098783953f62216ff9844fd2bf17501aa4937f5560ddf069eac", "sectionDigests": { "state": "c5243ba17364d3ac", "blockContents": "473264d9df8ba338", - "stats": "a3c84817f1d0c3dd", + "stats": "794b12c5699ae15a", "metadata": "615f125909ed135d" }, "stateKeyDigests": { diff --git a/tests/golden/storage-render/responses.json b/tests/golden/storage-render/responses.json index c9aa385f1a..325e63b6e3 100644 --- a/tests/golden/storage-render/responses.json +++ b/tests/golden/storage-render/responses.json @@ -95,12 +95,12 @@ "foldAt": 9, "editedAt": 12, "summaryFrom": 9, - "stateDigest": "aa95de9ed8ddaff40f0b0e2deb1991c85582e33a17149c030687f46cfa34a9a3", - "stateDigestAligned": "5f40c3661d4c43338d855b5a5e79b2915da934affe33d6cb07680a1da39bb996", + "stateDigest": "b15d8a327a7448f4f386c10d6e171084ac51f70a3ceccc8da68990effcb91976", + "stateDigestAligned": "7c4e6f8831979140b2f847c2339b9320fe986bcc9015536006e9e9bff0c8e89d", "sectionDigests": { "state": "e686a14f31d69ce5", "blockContents": "b6701268a0bdcd8a", - "stats": "099bde0a9cf64cad", + "stats": "e8ebcb92d0bb0878", "metadata": "be12181116331419" }, "stateKeyDigests": { From 36b13ada460deea7dd284bf44e43e574751a8bbd Mon Sep 17 00:00:00 2001 From: mariopasquali Date: Sun, 8 Nov 2026 23:43:25 +0100 Subject: [PATCH 3/3] fix: restore persisted emergency shrink status evidence --- src/persist.ts | 6 ++++ tests/persist-emergency-marker.test.ts | 41 ++++++++++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 tests/persist-emergency-marker.test.ts diff --git a/src/persist.ts b/src/persist.ts index a66eb8fb10..4e7fa6a57d 100644 --- a/src/persist.ts +++ b/src/persist.ts @@ -202,6 +202,8 @@ interface PersistedSession { cacheSamples?: number; lastInputTokens?: number; lastInputTokensSource?: string; + emergencyShrinkAt?: number; + emergencyShrinkEstimate?: number; lastInputTokensOrigin?: string; overflowArmTokens?: number; overflowArmCompletionReserve?: number; @@ -4176,6 +4178,10 @@ function buildSession(parsed: PersistedSession): Session { // #857: provenance — legacy files lack it; absent stays absent and // evidence-grade consumers treat absent as untrusted. lastInputTokensSource: stats.lastInputTokensSource === "usage" || stats.lastInputTokensSource === "estimate" || stats.lastInputTokensSource === "overflow-arm" ? stats.lastInputTokensSource : undefined, + // Preserve the explanation saved by armFailureShrink alongside its + // raised baseline. A real usage settlement clears both markers. + emergencyShrinkAt: typeof stats.emergencyShrinkAt === "number" && Number.isFinite(stats.emergencyShrinkAt) && stats.emergencyShrinkAt >= 0 ? stats.emergencyShrinkAt : undefined, + emergencyShrinkEstimate: typeof stats.emergencyShrinkEstimate === "number" && Number.isFinite(stats.emergencyShrinkEstimate) && stats.emergencyShrinkEstimate > 0 ? stats.emergencyShrinkEstimate : undefined, // #1110: one-shot overflow arm — legacy files lack it; absent = no arm. overflowArmTokens: typeof stats.overflowArmTokens === "number" && Number.isFinite(stats.overflowArmTokens) && stats.overflowArmTokens > 0 ? stats.overflowArmTokens : undefined, // #3450: proven completion reservation + one-time warn flag — legacy files lack both. diff --git a/tests/persist-emergency-marker.test.ts b/tests/persist-emergency-marker.test.ts new file mode 100644 index 0000000000..b5ddd9f650 --- /dev/null +++ b/tests/persist-emergency-marker.test.ts @@ -0,0 +1,41 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import {mkdtempSync} from 'node:fs'; +import {tmpdir} from 'node:os'; +import path from 'node:path'; +import {createInitialState} from 'acp-kernel'; +import {SessionStore} from '../src/persist.ts'; +import type {Session} from '../src/session.ts'; +import {rmrf} from './tmp-rm.ts'; + +for(const mode of ['legacy','full']){ + for(const armed of [true,false]){ + test(`failure-shrink status evidence survives ${mode} restart (armed=${armed})`,async()=>{ + process.env.BILI_STORAGE_UNIFIED=mode; + process.env.BILI_PERSIST_ZSTD='0'; + const dir=mkdtempSync(path.join(tmpdir(),'bili-shrink-marker-test-')); + process.env.BILI_CONFIG_FILE=path.join(dir,'absent-config'); + const session:Session={id:'synthetic-shrink-marker',meta:{protocol:'anthropic',upstreamOrigin:'http://synthetic.invalid'}, + stats:{requests:1,tokensSaved:0,inputTokens:1000,cachedTokens:0,outputTokens:5,cacheSamples:0, + lastInputTokens:10000,lastInputTokensSource:armed?'estimate':'usage',contextTokens:10000,compressCreditTokens:0, + retrieveCalls:0,retrieveHits:0,retrieveMisses:0,storedBytes:0,storeBytesSaved:0,rangeRestores:0, + ...(armed?{emergencyShrinkAt:1700000000000,emergencyShrinkEstimate:10000}:{})},metadata:{}, + createdAt:1700000000000,lastSeen:1700000001000,state:createInitialState(),blockContents:new Map(), + inFlight:0,persisted:false,pendingRetrievals:[]}; + let store=new SessionStore({dir,enabled:true,debounceMs:1}); + try{ + await store.writeNow(session);store.closeQuietly();store=new SessionStore({dir,enabled:true,debounceMs:1}); + const restored=store.loadSync(session.id,session.meta);assert.ok(restored); + assert.equal(restored.stats.emergencyShrinkAt,armed?1700000000000:undefined); + assert.equal(restored.stats.emergencyShrinkEstimate,armed?10000:undefined); + assert.equal(restored.stats.lastInputTokens,10000); + assert.equal(restored.stats.lastInputTokensSource,armed?'estimate':'usage'); + delete restored.stats.emergencyShrinkAt;delete restored.stats.emergencyShrinkEstimate; + await store.writeNow(restored);store.closeQuietly();store=new SessionStore({dir,enabled:true,debounceMs:1}); + const cleared=store.loadSync(session.id,session.meta);assert.ok(cleared); + assert.equal(cleared.stats.emergencyShrinkAt,undefined); + assert.equal(cleared.stats.emergencyShrinkEstimate,undefined); + }finally{store.closeQuietly();rmrf(dir);} + }); + } +}