From abb7d22a5605e6dee274107a97e378dfe23151fa Mon Sep 17 00:00:00 2001 From: netcatty-bot <308658023+netcatty-bot@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:13:54 +0000 Subject: [PATCH] fix: address Codex review on PR #3604 --- .../ai/harness/toolOutputStore.test.ts | 53 +++++++++---------- infrastructure/ai/harness/toolOutputStore.ts | 50 ++++++++++------- 2 files changed, 58 insertions(+), 45 deletions(-) diff --git a/infrastructure/ai/harness/toolOutputStore.test.ts b/infrastructure/ai/harness/toolOutputStore.test.ts index 7d60c37ad..fbfe43add 100644 --- a/infrastructure/ai/harness/toolOutputStore.test.ts +++ b/infrastructure/ai/harness/toolOutputStore.test.ts @@ -222,12 +222,11 @@ test('ToolOutputStore global quotas keep the borrowed fork alias when every reco // The global handle quota is already full when the fork is created. Every // registry entry is protected by the rehome — the fork's retained messages // advertise the cloned handle (the alias), and the source record backs the - // original conversation — so the protected pass cannot make room. The - // overshoot is resolved during the rehome itself (not deferred to the next - // plain `store()`, whose oldest-first sweep would kill both copies): the - // borrowed alias owns no durable content, so it is the copy sacrificed, - // and the source-owned record keeps the handle readable with the registry - // back within quota. + // original conversation — so no eviction can admit the clone without + // destroying output a live conversation still resolves. The fork is + // refused: the borrowed alias (which owns nothing) is rolled back, the + // source-owned record keeps the handle readable for the original + // conversation, and no spill file is deleted. const original = new ToolOutputStore({ spillThresholdChars: 0, maxHandlesGlobal: 1, persistence }); const handle = original.store({ chatSessionId: 'chat-source', @@ -236,17 +235,17 @@ test('ToolOutputStore global quotas keep the borrowed fork alias when every reco }); await handle.spillPromise; - // `read` cannot serve the durable content, so the clone aliases the + // `read` cannot serve the durable content, so the clone would alias the // source-owned spill path as a non-owning borrow. await original.rehomeChatSession('chat-source', 'chat-fork'); const sourceCopy = original.get(handle.id, 'chat-source'); assert.ok(sourceCopy); assert.ok(files.has(`/netcatty/${handle.id}-chat-source.log`)); - // Evicting the alias never deletes the shared file. + // Rolling the alias back never deletes the shared file. assert.equal(deletedPaths.length, 0); - // The alias (which owns nothing) is the copy sacrificed; the fork's read - // of this handle id now misses, but the original conversation keeps it. + // The fork is refused: its read of this handle id misses, but the original + // conversation keeps it. assert.equal(original.get(handle.id, 'chat-fork'), undefined); }); @@ -354,7 +353,7 @@ test('ToolOutputStore retires the borrowed fork alias before its owner is evicte assert.equal(await original.readChunkAsync({ handleId: handle.id, mode: 'head', maxChars: 10 }, 'chat-fork'), null); }); -test('ToolOutputStore global quotas resolve an over-quota protected set during rehoming', async () => { +test('ToolOutputStore global quotas refuse a fork whose copies cannot fit', async () => { const files = new Map(); const deletedPaths: string[] = []; const persistence: ToolOutputPersistence = { @@ -391,13 +390,12 @@ test('ToolOutputStore global quotas resolve an over-quota protected set during r // the only unprotected entry is nothing — the freshly cloned handle and // its source are both protected, because the clone must survive quota // enforcement (the fork advertises its handle id) and the source record - // backs the original conversation. The overshoot is resolved during the - // rehome itself (not deferred to the next plain `store()`, whose - // oldest-first sweep would kill both copies before the newly stored - // handle): the follow-up unprotected pass sacrifices the older source - // copy so only one copy of the handle id dies, and the clone — which - // re-read the source's durable content — re-spills a durable - // target-owned record the fork keeps reading. + // backs the original conversation. No eviction can fit both copies, so + // the fork is refused: the fresh clone (which re-read the source's + // durable content but has not yet spilled it) is rolled back, and the + // source-owned record — the one the original conversation still resolves — + // keeps its durable file. The fork's read of the handle id misses instead + // of invalidating either live copy. const original = new ToolOutputStore({ spillThresholdChars: 0, maxHandlesGlobal: 1, persistence }); const handle = original.store({ chatSessionId: 'chat-source', @@ -408,17 +406,18 @@ test('ToolOutputStore global quotas resolve an over-quota protected set during r await original.rehomeChatSession('chat-source', 'chat-fork'); - // The source copy is what got sacrificed to bring the registry within - // quota; its source-owned spill file is gone with it. - assert.equal(original.get(handle.id, 'chat-source'), undefined); - assert.deepEqual(deletedPaths, [`/netcatty/${handle.id}-chat-source.log`]); - assert.equal(files.has(`/netcatty/${handle.id}-chat-source.log`), false); - // The clone survives and owns its own durable record. - assert.ok(original.get(handle.id, 'chat-fork')); - assert.ok(files.has(`/netcatty/${handle.id}-chat-fork.log`)); + // The source copy survives untouched with its durable spill file. + const sourceCopy = original.get(handle.id, 'chat-source'); + assert.ok(sourceCopy); + assert.deepEqual(deletedPaths, []); + assert.ok(files.has(`/netcatty/${handle.id}-chat-source.log`)); assert.equal(( - await original.readChunkAsync({ handleId: handle.id, mode: 'head', maxChars: 100 }, 'chat-fork') + await original.readChunkAsync({ handleId: handle.id, mode: 'head', maxChars: 100 }, 'chat-source') )?.content?.length, 100); + // The fork is refused: no clone, no target-owned record for it. + assert.equal(original.get(handle.id, 'chat-fork'), undefined); + assert.equal(files.has(`/netcatty/${handle.id}-chat-fork.log`), false); + assert.equal(await original.readChunkAsync({ handleId: handle.id, mode: 'head', maxChars: 100 }, 'chat-fork'), null); }); test('ToolOutputStore global quotas evict an unrelated session\'s older handle, not the fresh clone', async () => { diff --git a/infrastructure/ai/harness/toolOutputStore.ts b/infrastructure/ai/harness/toolOutputStore.ts index 62d3b9d34..1060e5c55 100644 --- a/infrastructure/ai/harness/toolOutputStore.ts +++ b/infrastructure/ai/harness/toolOutputStore.ts @@ -443,24 +443,35 @@ export class ToolOutputStore { // still reads): when the quota is already full, the oldest unprotected // pre-existing handle (mirroring the plain `store()` eviction policy) // absorbs the overflow instead. When the protected set itself exceeds - // the quota (e.g. a very small `maxHandlesGlobal`), the pass above - // cannot finish the job; deferring the rebalance to the next plain - // `store()` would let its oldest-first sweep — run without protection - // and with the source and its clone sharing the same older `accessedAt` - // — evict *both* copies before the newly stored handle, killing the - // handle in the fork and the original conversation at once. So a - // follow-up unprotected pass resolves the overshoot right here: the two - // copies still coexist, the borrow protection keeps the durable owner - // alive when a clone aliases its path, and at most one copy per handle - // id is sacrificed (the pass breaks as soon as the quota is met, so the - // twin the other session reads survives). - this.enforceGlobalLimits(new Set([ + // the quota (e.g. a very small `maxHandlesGlobal`), no eviction can + // admit the clones without destroying output a live conversation still + // resolves: dropping one copy would either delete the source-owned file + // the original conversation reads, or — when the clone is a borrowed + // alias — leave the fork publishing a handle id that immediately + // misses. Refuse the fork instead: roll back the fresh clones so the + // registry returns to its pre-fork (compliant) state, keeping the + // source record intact. The fork's retained messages then miss on + // `tool_output_read`, but no existing conversation's output is + // invalidated. + const withinQuota = this.enforceGlobalLimits(new Set([ ...selected.map(([, handle]) => handle), ...freshClones, ])); - // A no-op when the protected pass already brought the registry within - // quota; otherwise trims it immediately as described above. - this.enforceGlobalLimits(); + if (!withinQuota) { + // The fresh clones own no durable files yet (their spills happen below), + // so removing them deletes nothing and retires no borrow aliases. + for (const clone of freshClones) { + if (targetMap.get(clone.id) === clone) targetMap.delete(clone.id); + } + if (targetMap.size === 0) { + this.bySession.delete(targetChatSessionId); + } else { + this.bySession.set(targetChatSessionId, targetMap); + } + // The registry the clones were added to was within quota, so rolling + // them back is guaranteed to restore compliance; no further eviction + // pass runs here. + } // Copies still holding in-memory content (fresh or read-back) become // target-owned through the normal spill path, which re-writes a durable // record carrying the target's chat session id. Await the writes so the @@ -688,16 +699,19 @@ export class ToolOutputStore { } } - private enforceGlobalLimits(protect?: ReadonlySet): void { + private enforceGlobalLimits(protect?: ReadonlySet): boolean { + // Returns true when the loop ends with the registry within quota, and + // false when every remaining entry is protected and the registry is still + // over quota (the caller decides what to sacrifice, if anything). const allHandles = () => [...this.bySession.entries()].flatMap(([chatSessionId, sessionMap]) => ( [...sessionMap.values()].map(handle => ({ chatSessionId, sessionMap, handle })) )); while (true) { const entries = allHandles(); const totalChars = entries.reduce((sum, entry) => sum + entry.handle.storedChars, 0); - if (entries.length <= this.maxHandlesGlobal && totalChars <= this.maxCharsGlobal) break; + if (entries.length <= this.maxHandlesGlobal && totalChars <= this.maxCharsGlobal) return true; const oldest = this.pickEvictionEntry(entries, protect); - if (!oldest) break; + if (!oldest) return false; oldest.sessionMap.delete(oldest.handle.id); this.evictHandle(oldest.handle); if (oldest.sessionMap.size === 0) this.bySession.delete(oldest.chatSessionId);