moving

packages/agent/tests/w41-temporal-recall.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { MindDB } from '@waggle/core';
+import { TEMPORAL_GUIDANCE } from '@waggle/hive-mind-core';
+import { Orchestrator } from '../src/orchestrator.js';
+import { MockEmbedder } from '../../hive-mind-core/tests/mind/helpers/mock-embedder.js';
+
+/**
+ * W4.1a — production port of the benchmark-proven temporal recall surface
+ * (W4-PRODUCTION-PORT-PLAN-2026-06-11.md §5, components #1 + #2).
+ *
+ *  #1 Date rendering + TEMPORAL_GUIDANCE: recallMemory's rendered block carries
+ *     a reference-date anchor line and the W1-grade temporal guidance fragment
+ *     (granularity clause — the #1 LoCoMo temporal lever, 84.7 final).
+ *  #2 Unconditional importance lane: critical/important frames reach recall on
+ *     EVERY query (benchmark fetchImportantFrames K=5), not only on catch-up
+ *     regex matches.
+ */
+
+describe('W4.1a — temporal recall surface + unconditional importance lane', () => {
+  let db: MindDB;
+  let orchestrator: Orchestrator;
+
+  beforeEach(() => {
+    db = new MindDB(':memory:');
+    orchestrator = new Orchestrator({
+      db,
+      embedder: new MockEmbedder(),
+    });
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe('#1 TEMPORAL_GUIDANCE upgraded to W1 wording', () => {
+    it('carries the granularity clause and relative-date worked example', () => {
+      // W1 failure mining: 22 ours-only temporal fails emitted a confident exact
+      // ISO day 1-7 days off where a coarse answer would have been judged correct.
+      expect(TEMPORAL_GUIDANCE).toMatch(/granularit/i);
+      expect(TEMPORAL_GUIDANCE).toMatch(/confidently wrong exact day/i);
+      // Worked relative-date arithmetic example (Memori instruction 5 lineage)
+      expect(TEMPORAL_GUIDANCE).toMatch(/last year/i);
+      // Latest-wins contradiction clause preserved from the shipped version
+      expect(TEMPORAL_GUIDANCE).toMatch(/most recent version is correct/i);
+    });
+  });
+
+  describe('#1 recallMemory renders anchor line + guidance', () => {
+    it('includes the reference-date anchor and temporal guidance in the block', async () => {
+      await orchestrator.executeTool('save_memory', {
+        content: 'User preference: weekly report goes out on Fridays',
+        importance: 'important',
+      });
+
+      const result = await orchestrator.recallMemory('weekly report');
+      expect(result.count).toBeGreaterThan(0);
+      expect(result.text).toContain('Reference date (most recent memory):');
+      // The guidance fragment rides with the recalled block (not the global prompt)
+      expect(result.text).toContain('timestamped [YYYY-MM-DD]');
+    });
+
+    it('anchor date equals the most recent rendered frame date', async () => {
+      await orchestrator.executeTool('save_memory', {
+        content: 'User preference: weekly report goes out on Fridays',
+        importance: 'important',
+      });
+      const today = new Date().toISOString().slice(0, 10);
+      const result = await orchestrator.recallMemory('weekly report');
+      expect(result.text).toContain(`Reference date (most recent memory): ${today}`);
+    });
+  });
+
+  describe('#2 unconditional importance lane', () => {
+    it('recalls a critical frame on a semantically unrelated query', async () => {
+      // Disjoint vocabulary: no keyword overlap with the query, so FTS cannot
+      // surface it and MockEmbedder similarity is meaningless — only the
+      // unconditional importance lane can deliver this frame.
+      await orchestrator.executeTool('save_memory', {
+        content: 'Production launch is locked for June 20',
+        importance: 'critical',
+      });
+
+      const result = await orchestrator.recallMemory('favorite painting colors');
+      expect(result.text).toContain('Production launch is locked for June 20');
+    });
+
+    it('does not duplicate a frame surfaced by both semantic and importance lanes', async () => {
+      await orchestrator.executeTool('save_memory', {
+        content: 'Production launch is locked for June 20',
+        importance: 'critical',
+      });
+
+      const result = await orchestrator.recallMemory('production launch');
+      const occurrences = result.text.split('Production launch is locked for June 20').length - 1;
+      expect(occurrences).toBe(1);
+    });
+
+    it('date-windowed query with no in-window frames falls back to unwindowed recall', async () => {
+      // W4.1b graceful degradation: "in May 2019" parses to a window that
+      // matches nothing (frame was created today) — recall must fall back
+      // rather than return empty.
+      await orchestrator.executeTool('save_memory', {
+        content: 'User preference: weekly report goes out on Fridays',
+        importance: 'important',
+      });
+
+      const result = await orchestrator.recallMemory('what did the weekly report say in May 2019');
+      expect(result.text).toContain('weekly report goes out on Fridays');
+    });
+
+    it('importance lane respects the temporary/deprecated exclusion', async () => {
+      // temporary frames must never re-enter the prompt as authoritative recall
+      // (R2 sign-gate) — the lane SQL only selects critical/important, so a
+      // temporary frame stays out even on unrelated queries.
+      await orchestrator.executeTool('save_memory', {
+        content: 'Scratch note: half-finished thought',
+        importance: 'temporary',
+      });
+
+      const result = await orchestrator.recallMemory('favorite painting colors');
+      expect(result.text).not.toContain('Scratch note');
+    });
+  });
+});