@seanhogg/builderforce-memory 2026.10.25 → 2026.10.27

package/src/working/transcriptWindow.test.ts

@@ -0,0 +1,84 @@
+/**
+ * src/working/transcriptWindow.test.ts
+ * Drop-oldest windowing drops in CHUNKS with hysteresis, so the front of the request —
+ * the prefix a provider cache hashes — moves rarely instead of on every turn.
+ */
+import {
+  windowed,
+  HISTORY_WINDOW,
+  HISTORY_WINDOW_DROP_CHUNK,
+  HISTORY_TOKEN_BUDGET,
+  HISTORY_TOKEN_DROP_CHUNK,
+  transcriptTokens,
+} from './transcript.js';
+import type { TranscriptMessage } from './transcript.js';
+
+const msg = (role: TranscriptMessage['role'], content = 'x'): TranscriptMessage => ({ role, content });
+
+/** user/assistant pairs, `n` messages long, each message distinct. */
+function convoOf(n: number, content = (i: number) => `m${i}`): TranscriptMessage[] {
+  return Array.from({ length: n }, (_, i) => msg(i % 2 === 0 ? 'user' : 'assistant', content(i)));
+}
+
+describe('windowed — chunked message-count drops', () => {
+  it('keeps everything up to the window', () => {
+    const convo = convoOf(HISTORY_WINDOW);
+    expect(windowed(convo)).toEqual(convo);
+  });
+
+  it('drops a whole chunk once over, then holds the front while messages arrive', () => {
+    const fronts: unknown[] = [];
+    for (let n = HISTORY_WINDOW + 1; n <= HISTORY_WINDOW + HISTORY_WINDOW_DROP_CHUNK; n++) {
+      const w = windowed(convoOf(n));
+      expect(w.length).toBeLessThanOrEqual(HISTORY_WINDOW);
+      fronts.push(w[0]!.content);
+    }
+    // One front for the whole chunk: the prefix did not move turn to turn.
+    expect(new Set(fronts).size).toBe(1);
+    expect(fronts[0]).toBe(`m${HISTORY_WINDOW_DROP_CHUNK}`);
+    // The first drop leaves room: ~75% of the window, not exactly the window.
+    expect(windowed(convoOf(HISTORY_WINDOW + 1)).length).toBe(HISTORY_WINDOW + 1 - HISTORY_WINDOW_DROP_CHUNK);
+  });
+
+  it('moves the front by the next chunk only when the window fills again', () => {
+    const w = windowed(convoOf(HISTORY_WINDOW + HISTORY_WINDOW_DROP_CHUNK + 1));
+    expect(w[0]!.content).toBe(`m${2 * HISTORY_WINDOW_DROP_CHUNK}`);
+  });
+});
+
+describe('windowed — chunked token drops', () => {
+  // ~2k tokens per message (chars/4), so the budget holds ~32 of them.
+  const big = (i: number) => `${i}:${'y'.repeat(8_000)}`;
+
+  it('drops down to ~75% of the budget, not just under it', () => {
+    let n = 2;
+    while (transcriptTokens(convoOf(n, big)) <= HISTORY_TOKEN_BUDGET) n += 2;
+    const w = windowed(convoOf(n, big));
+    const kept = transcriptTokens(w);
+    expect(kept).toBeLessThanOrEqual(HISTORY_TOKEN_BUDGET);
+    expect(kept).toBeLessThanOrEqual(HISTORY_TOKEN_BUDGET - HISTORY_TOKEN_DROP_CHUNK + 4_100);
+    expect(w[0]!.role).toBe('user');
+  });
+
+  it('holds the front across turns until a whole chunk of new work arrives', () => {
+    let n = 2;
+    while (transcriptTokens(convoOf(n, big)) <= HISTORY_TOKEN_BUDGET) n += 2;
+    const first = windowed(convoOf(n, big))[0];
+    // A few more turns (< one chunk of tokens) — same front.
+    for (let extra = 2; extra <= 4; extra += 2) {
+      expect(windowed(convoOf(n + extra, big))[0]!.content).toBe(first!.content);
+    }
+  });
+
+  it('never drops the most recent user turn, however large', () => {
+    const convo = [msg('user', 'old'), msg('assistant', 'a'), msg('user', 'z'.repeat(HISTORY_TOKEN_BUDGET * 5))];
+    const w = windowed(convo);
+    expect(w[0]!.content).toBe(convo[2]!.content);
+  });
+
+  it('still starts on a user turn after a drop (strict vendors)', () => {
+    const convo: TranscriptMessage[] = [];
+    for (let i = 0; i < 40; i++) convo.push(msg('user', `u${i}`), msg('assistant', big(i)), msg('tool', big(i)));
+    expect(windowed(convo)[0]!.role).toBe('user');
+  });
+});

package/src/working/types.ts

@@ -29,4 +29,10 @@ export interface ConsolidateOptions {
   at?: Date;
   /** The workspace root — absolute paths under it are kept, made relative. */
   root?: string;
+  /**
+   * Distinct files (changed, deleted and read together) a run must touch for its map to
+   * be kept. Defaults to `MIN_CONSOLIDATED_FILES`; the same floor applies to a run that
+   * changed files as to one that only read.
+   */
+  minFiles?: number;
 }

package/src/working/working.test.ts

@@ -83,7 +83,10 @@ describe('consolidate', () => {
 
   it('skips a short lookup but keeps any change', () => {
     expect(consolidate(snap({ read: ['a/b/c.ts', 'a/b/d.ts'] }))).toBeNull();
-    expect(consolidate(snap({ edited: ['api/src/r/x.ts'] }))?.key).toBe('codemap:api/src/r');
+    // 2026.10.27: the 3-file floor now holds for a run that changed files too (it used to
+    // keep a one-file fix as a map). The kept-change half moved to `minFiles` below.
+    expect(consolidate(snap({ edited: ['api/src/r/x.ts'] }))).toBeNull();
+    expect(consolidate(snap({ edited: ['api/src/r/x.ts'] }), { minFiles: 1 })?.key).toBe('codemap:api/src/r');
   });
 });
 
@@ -91,7 +94,7 @@ describe('mergeConsolidated', () => {
   const prior = consolidate(snap({ read: ['w/s/a.ts', 'w/s/b.ts'], edited: ['w/s/c.ts'] }), { at: AT })!;
 
   it('adds a small run to the area map, restating the earlier run\'s edits', () => {
-    const next = consolidate(snap({ task: 'fix d', edited: ['w/s/d.ts'] }), { at: AT })!;
+    const next = consolidate(snap({ task: 'fix d', edited: ['w/s/d.ts'] }), { at: AT, minFiles: 1 })!;
     const merged = mergeConsolidated(next.key, prior.content, next.content);
     expect(merged).toContain('asked: "fix d"');
     const entries = merged.split('\n').filter((l) => l.startsWith('- '));
@@ -99,7 +102,7 @@ describe('mergeConsolidated', () => {
   });
 
   it('removes a file this run deleted and never stores the deletion line', () => {
-    const next = consolidate(snap({ deleted: ['w/s/a.ts'], edited: ['w/s/e.ts'] }), { at: AT })!;
+    const next = consolidate(snap({ deleted: ['w/s/a.ts'], edited: ['w/s/e.ts'] }), { at: AT, minFiles: 1 })!;
     const merged = mergeConsolidated(next.key, prior.content, next.content);
     expect(merged).not.toContain('w/s/a.ts');
     expect(merged).not.toContain('(deleted)');
@@ -108,7 +111,7 @@ describe('mergeConsolidated', () => {
 
   it('caps the map and says how many more', () => {
     const big = consolidate(snap({ read: Array.from({ length: 12 }, (_, i) => `w/s/f${i}.ts`) }), { at: AT })!;
-    const next = consolidate(snap({ edited: ['w/s/new.ts'] }), { at: AT })!;
+    const next = consolidate(snap({ edited: ['w/s/new.ts'] }), { at: AT, minFiles: 1 })!;
     const merged = mergeConsolidated(next.key, big.content, next.content);
     expect(merged.split('\n').filter((l) => l.startsWith('- '))).toHaveLength(12);
     expect(merged).toContain('(+1 more file(s) touched)');