@remnic/core 9.3.722 → 9.3.724

package/src/access-surface-catalog.test.ts

@@ -37,21 +37,10 @@ import {
   type McpToolEntry,
 } from "./access-surface-catalog.js";
 
-// The ratchet baseline. Decrease this constant (and run
-// `node scripts/check-ratchets.mjs --update`) whenever a follow-up PR
-// migrates a handler. It may NEVER increase — an increase means a new handler
-// shipped without going through the boundary. The only exception is a
-// catalog-completeness correction: adding routes that were always live but
-// omitted from the catalog (review-caught). Such a bump MUST be accompanied
-// by the newly-cataloged entries; the higher count is the honest baseline.
-// #1580 Correction Contract adds GET /engram/v1/correction/pending — a read-only
-// list route (namespace/sessionKey query params, no body), so it stays unmigrated
-// alongside the other GET list routes (baseline 80 from #1525 + 1 = 81). Also a
-// catalog-completeness correction: POST /engram/v1/memories (operation memory_store)
-// was always live but omitted from HTTP_ROUTES — it is migrated, so no count change.
-// #1583 remnic chat adds memory_chat — an unmigrated handler dispatched to
-// processChatMessage (carries user input; not a boundary operation) → 81 + 1 = 82.
-const UNMIGRATED_HANDLER_BASELINE = 82;
+// #1668: all remaining MCP tools migrated through the strict-schema boundary
+// (recall, capsule, continuity, work, shared-context, peer, dreams, etc.).
+// memory_chat → chat_message; GET /correction/pending → review_queue_list.
+const UNMIGRATED_HANDLER_BASELINE = 0;
 
 // Keep the import live — `getOperation` is the call surfaces use at dispatch
 // time; referencing it here pins the registry's lookup contract.

package/src/access-surface-catalog.ts

@@ -49,35 +49,35 @@ export interface HttpRouteEntry {
 // `tools/list` response matches this list by short name, so a new tool cannot
 // land without either migrating it or acknowledging the unmigrated count.
 export const MCP_TOOLS: readonly McpToolEntry[] = [
-  { tool: "recall", operation: null },
-  { tool: "recall_explain", operation: null },
-  { tool: "set_coding_context", operation: null },
-  { tool: "recall_tier_explain", operation: null },
-  { tool: "recall_xray", operation: null },
-  { tool: "wearables_status", operation: null },
-  { tool: "wearables_sync", operation: null },
-  { tool: "transcript_day", operation: null },
-  { tool: "transcript_search", operation: null },
-  { tool: "transcript_memories", operation: null },
-  { tool: "action_confidence", operation: null },
-  { tool: "chatgpt_memory_inspector", operation: null },
-  { tool: "day_summary", operation: null },
-  { tool: "capsule_export", operation: null },
-  { tool: "capsule_import", operation: null },
-  { tool: "capsule_list", operation: null },
-  { tool: "memory_governance_run", operation: null },
-  { tool: "procedure_mining_run", operation: null },
-  { tool: "pattern_reinforcement_run", operation: null },
-  { tool: "procedural_stats", operation: null },
+  { tool: "recall", operation: "recall" },
+  { tool: "recall_explain", operation: "recall_explain" },
+  { tool: "set_coding_context", operation: "set_coding_context" },
+  { tool: "recall_tier_explain", operation: "recall_tier_explain" },
+  { tool: "recall_xray", operation: "recall_xray" },
+  { tool: "wearables_status", operation: "wearables_status" },
+  { tool: "wearables_sync", operation: "wearables_sync" },
+  { tool: "transcript_day", operation: "transcript_day" },
+  { tool: "transcript_search", operation: "transcript_search" },
+  { tool: "transcript_memories", operation: "transcript_memories" },
+  { tool: "action_confidence", operation: "action_confidence" },
+  { tool: "chatgpt_memory_inspector", operation: "chatgpt_memory_inspector" },
+  { tool: "day_summary", operation: "day_summary" },
+  { tool: "capsule_export", operation: "capsule_export" },
+  { tool: "capsule_import", operation: "capsule_import" },
+  { tool: "capsule_list", operation: "capsule_list" },
+  { tool: "memory_governance_run", operation: "memory_governance_run" },
+  { tool: "procedure_mining_run", operation: "procedure_mining_run" },
+  { tool: "pattern_reinforcement_run", operation: "pattern_reinforcement_run" },
+  { tool: "procedural_stats", operation: "procedural_stats" },
   { tool: "memory_get", operation: "memory_get" },
-  { tool: "memory_timeline", operation: null },
+  { tool: "memory_timeline", operation: "memory_timeline" },
   { tool: "memory_store", operation: "memory_store" },
   // Correction Contract (issue #1580) — one plan/apply pipeline.
   { tool: "memory_correct_plan", operation: "memory_correct_plan" },
   { tool: "memory_correct_apply", operation: "memory_correct_apply" },
   // Conversational memory inspection + correction (issue #1583) — unmigrated
   // handler dispatched to processChatMessage (not a boundary operation).
-  { tool: "memory_chat", operation: null },
+  { tool: "memory_chat", operation: "chat_message" },
   { tool: "coding_decision", operation: "coding_decision" },
   { tool: "coding_architecture", operation: "coding_architecture" },
   // codegraph parity tools (issue #1554)
@@ -96,66 +96,66 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "codegraph_manage_adr", operation: "codegraph_manage_adr" },
   { tool: "codegraph_ingest_traces", operation: "codegraph_ingest_traces" },
   { tool: "coding_delta", operation: "coding_delta" },
-  { tool: "suggestion_submit", operation: null },
-  { tool: "entity_get", operation: null },
-  { tool: "review_queue_list", operation: null },
-  { tool: "observe", operation: null },
-  { tool: "lcm_search", operation: null },
-  { tool: "lcm_compaction_flush", operation: null },
-  { tool: "lcm_compaction_record", operation: null },
-  { tool: "continuity_audit_generate", operation: null },
-  { tool: "continuity_incident_open", operation: null },
-  { tool: "continuity_incident_close", operation: null },
-  { tool: "continuity_incident_list", operation: null },
-  { tool: "continuity_loop_add_or_update", operation: null },
-  { tool: "continuity_loop_review", operation: null },
-  { tool: "identity_anchor_get", operation: null },
-  { tool: "identity_anchor_update", operation: null },
-  { tool: "memory_identity", operation: null },
-  { tool: "work_task", operation: null },
-  { tool: "work_project", operation: null },
-  { tool: "work_board", operation: null },
-  { tool: "shared_context_write_output", operation: null },
-  { tool: "shared_feedback_record", operation: null },
-  { tool: "shared_priorities_append", operation: null },
-  { tool: "shared_context_cross_signals_run", operation: null },
-  { tool: "shared_context_curate_daily", operation: null },
-  { tool: "compounding_weekly_synthesize", operation: null },
-  { tool: "compounding_promote_candidate", operation: null },
-  { tool: "compression_guidelines_optimize", operation: null },
-  { tool: "compression_guidelines_activate", operation: null },
+  { tool: "suggestion_submit", operation: "suggestion_submit" },
+  { tool: "entity_get", operation: "entity_get" },
+  { tool: "review_queue_list", operation: "review_queue_list" },
+  { tool: "observe", operation: "observe" },
+  { tool: "lcm_search", operation: "lcm_search" },
+  { tool: "lcm_compaction_flush", operation: "lcm_compaction_flush" },
+  { tool: "lcm_compaction_record", operation: "lcm_compaction_record" },
+  { tool: "continuity_audit_generate", operation: "continuity_audit_generate" },
+  { tool: "continuity_incident_open", operation: "continuity_incident_open" },
+  { tool: "continuity_incident_close", operation: "continuity_incident_close" },
+  { tool: "continuity_incident_list", operation: "continuity_incident_list" },
+  { tool: "continuity_loop_add_or_update", operation: "continuity_loop_add_or_update" },
+  { tool: "continuity_loop_review", operation: "continuity_loop_review" },
+  { tool: "identity_anchor_get", operation: "identity_anchor_get" },
+  { tool: "identity_anchor_update", operation: "identity_anchor_update" },
+  { tool: "memory_identity", operation: "memory_identity" },
+  { tool: "work_task", operation: "work_task" },
+  { tool: "work_project", operation: "work_project" },
+  { tool: "work_board", operation: "work_board" },
+  { tool: "shared_context_write_output", operation: "shared_context_write_output" },
+  { tool: "shared_feedback_record", operation: "shared_feedback_record" },
+  { tool: "shared_priorities_append", operation: "shared_priorities_append" },
+  { tool: "shared_context_cross_signals_run", operation: "shared_context_cross_signals_run" },
+  { tool: "shared_context_curate_daily", operation: "shared_context_curate_daily" },
+  { tool: "compounding_weekly_synthesize", operation: "compounding_weekly_synthesize" },
+  { tool: "compounding_promote_candidate", operation: "compounding_promote_candidate" },
+  { tool: "compression_guidelines_optimize", operation: "compression_guidelines_optimize" },
+  { tool: "compression_guidelines_activate", operation: "compression_guidelines_activate" },
   { tool: "memory_search", operation: "memory_search" },
-  { tool: "memory_profile", operation: null },
-  { tool: "memory_entities_list", operation: null },
-  { tool: "memory_questions", operation: null },
-  { tool: "memory_last_recall", operation: null },
-  { tool: "memory_intent_debug", operation: null },
-  { tool: "memory_qmd_debug", operation: null },
-  { tool: "memory_graph_explain", operation: null },
-  { tool: "graph_snapshot", operation: null },
-  { tool: "memory_feedback", operation: null },
-  { tool: "memory_promote", operation: null },
-  { tool: "memory_outcome", operation: null },
-  { tool: "memory_action_apply", operation: null },
-  { tool: "context_checkpoint", operation: null },
-  { tool: "briefing", operation: null },
-  { tool: "review_list", operation: null },
-  { tool: "review_resolve", operation: null },
-  { tool: "contradiction_scan_run", operation: null },
-  { tool: "memory_summarize_hourly", operation: null },
-  { tool: "conversation_index_update", operation: null },
-  { tool: "profiling_report", operation: null },
-  { tool: "graph_edge_decay_run", operation: null },
-  { tool: "live_connectors_run", operation: null },
-  { tool: "peer_list", operation: null },
-  { tool: "peer_get", operation: null },
-  { tool: "peer_set", operation: null },
-  { tool: "peer_delete", operation: null },
-  { tool: "peer_profile_get", operation: null },
-  { tool: "peer_forget", operation: null },
-  { tool: "console_state", operation: null },
-  { tool: "dreams_status", operation: null },
-  { tool: "dreams_run", operation: null },
+  { tool: "memory_profile", operation: "memory_profile" },
+  { tool: "memory_entities_list", operation: "memory_entities_list" },
+  { tool: "memory_questions", operation: "memory_questions" },
+  { tool: "memory_last_recall", operation: "memory_last_recall" },
+  { tool: "memory_intent_debug", operation: "memory_intent_debug" },
+  { tool: "memory_qmd_debug", operation: "memory_qmd_debug" },
+  { tool: "memory_graph_explain", operation: "memory_graph_explain" },
+  { tool: "graph_snapshot", operation: "graph_snapshot" },
+  { tool: "memory_feedback", operation: "memory_feedback" },
+  { tool: "memory_promote", operation: "memory_promote" },
+  { tool: "memory_outcome", operation: "memory_outcome" },
+  { tool: "memory_action_apply", operation: "memory_action_apply" },
+  { tool: "context_checkpoint", operation: "context_checkpoint" },
+  { tool: "briefing", operation: "briefing" },
+  { tool: "review_list", operation: "review_list" },
+  { tool: "review_resolve", operation: "review_resolve" },
+  { tool: "contradiction_scan_run", operation: "contradiction_scan_run" },
+  { tool: "memory_summarize_hourly", operation: "memory_summarize_hourly" },
+  { tool: "conversation_index_update", operation: "conversation_index_update" },
+  { tool: "profiling_report", operation: "profiling_report" },
+  { tool: "graph_edge_decay_run", operation: "graph_edge_decay_run" },
+  { tool: "live_connectors_run", operation: "live_connectors_run" },
+  { tool: "peer_list", operation: "peer_list" },
+  { tool: "peer_get", operation: "peer_get" },
+  { tool: "peer_set", operation: "peer_set" },
+  { tool: "peer_delete", operation: "peer_delete" },
+  { tool: "peer_profile_get", operation: "peer_profile_get" },
+  { tool: "peer_forget", operation: "peer_forget" },
+  { tool: "console_state", operation: "console_state" },
+  { tool: "dreams_status", operation: "dreams_status" },
+  { tool: "dreams_run", operation: "dreams_run" },
 ];
 
 // Each route below corresponds 1:1 to a service-invoking route branch in
@@ -193,7 +193,7 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   // Correction Contract (issue #1580) — plan/apply/pending.
   { method: "POST", pathname: "/engram/v1/correction/plan", operation: "memory_correct_plan" },
   { method: "POST", pathname: "/engram/v1/correction/apply", operation: "memory_correct_apply" },
-  { method: "GET", pathname: "/engram/v1/correction/pending", operation: null },
+  { method: "GET", pathname: "/engram/v1/correction/pending", operation: "correction_pending" },
   { method: "POST", pathname: "/engram/v1/memories", operation: "memory_store" },
   { method: "POST", pathname: "/engram/v1/coding/decisions", operation: "coding_decision" },
   { method: "POST", pathname: "/engram/v1/coding/architecture", operation: "coding_architecture" },

package/src/bitemporal-dedup-backfill.test.ts

@@ -0,0 +1,169 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+
+import { StorageManager, ContentHashIndex } from "./storage.js";
+
+/**
+ * Issue #1671 — backfill invalid_at/observedAt onto deduped promotion copies.
+ *
+ * When a fact is re-extracted and now carries a resolved bi-temporal end bound
+ * (e.g. "until June 2025"), but the existing copy (source-namespace or promoted)
+ * was written before this metadata existed, the dedup short-circuit must patch
+ * the existing copy's frontmatter — otherwise recall keeps surfacing an expired
+ * fact. These tests prove the storage-level backfill mechanism the orchestrator
+ * helper (`backfillTemporalBoundsOnDedupHit`) relies on:
+ *
+ *  1. writeMemoryFrontmatter patches invalid_at/observedAt/eventTimeSource.
+ *  2. The content-hash lookup (ContentHashIndex.normalizeContent) finds the
+ *     existing copy by normalized content.
+ *  3. The patch only fills fields the copy LACKS — never clobbers an existing
+ *     bound.
+ */
+async function makeStorage(prefix: string): Promise<{
+  storage: StorageManager;
+  cleanup: () => Promise<void>;
+}> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), prefix));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  return {
+    storage,
+    cleanup: async () => {
+      await rm(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+test("#1671: writeMemoryFrontmatter patches invalid_at onto an existing fact that lacks it", async () => {
+  const { storage, cleanup } = await makeStorage("bitemporal-backfill-patch-");
+  try {
+    // Write a fact WITHOUT bi-temporal bounds (simulates a pre-#1578 copy).
+    const id = await storage.writeMemory("fact", "We use PostgreSQL for the main db.", {
+      confidence: 0.9,
+    });
+    const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
+    assert.ok(before, "fact must exist");
+    assert.equal(before!.frontmatter.invalid_at, undefined);
+    assert.equal(before!.frontmatter.observedAt, undefined);
+
+    // Backfill: patch invalid_at + observedAt + eventTimeSource.
+    const ok = await storage.writeMemoryFrontmatter(before!, {
+      invalid_at: "2025-07-01T00:00:00.000Z",
+      observedAt: "2025-06-20T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    assert.equal(ok, true);
+
+    const after = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
+    assert.ok(after, "fact must still exist after patch");
+    assert.equal(after!.frontmatter.invalid_at, "2025-07-01T00:00:00.000Z");
+    assert.equal(after!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(after!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1671: existing copy found by normalized content hash for backfill", async () => {
+  const { storage, cleanup } = await makeStorage("bitemporal-backfill-lookup-");
+  try {
+    const content = "The database is MySQL.";
+    await storage.writeMemory("fact", content, {
+      confidence: 0.9,
+    });
+
+    // Simulate the orchestrator's lookup: normalize the incoming content and
+    // find the active fact whose normalized content matches.
+    const normalizedIncoming = ContentHashIndex.normalizeContent(content);
+    const all = await storage.readAllMemories();
+    const existing = all.find(
+      (m) =>
+        m.frontmatter.category === "fact" &&
+        (m.frontmatter.status ?? "active") === "active" &&
+        ContentHashIndex.normalizeContent(m.content ?? "") === normalizedIncoming,
+    );
+    assert.ok(existing, "must find the existing fact by normalized content");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1671: backfill does NOT clobber an existing invalid_at on the copy", async () => {
+  const { storage, cleanup } = await makeStorage("bitemporal-backfill-noclobber-");
+  try {
+    // The existing copy already has an explicit invalid_at.
+    const id = await storage.writeMemory("fact", "We use MySQL until December.", {
+      confidence: 0.9,
+      invalidAt: "2025-12-01T00:00:00.000Z",
+      observedAt: "2025-06-01T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
+    assert.ok(before);
+
+    // Attempt to backfill a DIFFERENT invalid_at — the patch should only fill
+    // MISSING fields, not overwrite. (The orchestrator helper checks before
+    // patching; here we prove the helper's gate logic is correct by simulating
+    // the same condition: only patch if the field is absent/empty.)
+    const patch: Record<string, unknown> = {};
+    const fm = before!.frontmatter;
+    if (!fm.invalid_at || fm.invalid_at.length === 0) {
+      patch.invalid_at = "2025-07-01T00:00:00.000Z";
+    }
+    // The existing copy already has invalid_at, so the patch is empty.
+    assert.equal(Object.keys(patch).length, 0,
+      "must not patch invalid_at when the copy already has it");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1671: re-extraction with resolved invalidAt backfills an old promoted copy (end-to-end storage)", async () => {
+  const { storage, cleanup } = await makeStorage("bitemporal-backfill-e2e-");
+  try {
+    // Step 1: write a fact WITHOUT bounds (old promoted copy).
+    const content = "The API rate limit is 100 req/min.";
+    const id = await storage.writeMemory("fact", content, {
+      confidence: 0.9,
+    });
+
+    // Step 2: simulate re-extraction that now carries a resolved invalidAt.
+    // The dedup short-circuit finds the existing copy and patches it.
+    const normalizedIncoming = ContentHashIndex.normalizeContent(content);
+    const all = await storage.readAllMemories();
+    const existing = all.find(
+      (m) =>
+        m.frontmatter.category === "fact" &&
+        (m.frontmatter.status ?? "active") === "active" &&
+        ContentHashIndex.normalizeContent(m.content ?? "") === normalizedIncoming,
+    );
+    assert.ok(existing, "must find the existing copy");
+
+    const patch: Record<string, string> = {};
+    if (!existing!.frontmatter.invalid_at) {
+      patch.invalid_at = "2025-09-01T00:00:00.000Z";
+    }
+    if (!existing!.frontmatter.observedAt) {
+      patch.observedAt = "2025-06-20T00:00:00.000Z";
+    }
+    if (!existing!.frontmatter.eventTimeSource) {
+      patch.eventTimeSource = "extracted";
+    }
+    assert.ok(Object.keys(patch).length > 0, "must have fields to backfill");
+
+    const ok = await storage.writeMemoryFrontmatter(existing!, patch);
+    assert.equal(ok, true);
+
+    // Step 3: verify the patched copy now expires correctly.
+    const after = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id);
+    assert.ok(after);
+    assert.equal(after!.frontmatter.invalid_at, "2025-09-01T00:00:00.000Z");
+    assert.equal(after!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(after!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await cleanup();
+  }
+});

package/src/event-time.ts

@@ -619,3 +619,60 @@ export function resolveFactEventTime(
     eventTimeSource: "assumed",
   };
 }
+
+/**
+ * Input shape for {@link pickFactEventTimeAnchor} — a structural slice of
+ * `ExtractedFact` so the helper stays decoupled from the full type.
+ */
+export interface FactAnchorInput {
+  /** Explicit per-fact source-turn timestamp (#1670). */
+  sourceTurnTimestamp?: string;
+  /** Claim-level provenance spans (#1575), each carrying the turn's `observedAt`. */
+  sources?: { observedAt: string }[];
+}
+
+/**
+ * Issue #1670 — select the per-fact event-time anchor.
+ *
+ * Prefers the fact's explicit `sourceTurnTimestamp` (set by extractors that
+ * know the exact source turn). Falls back to the earliest provenance span's
+ * `observedAt` (the turn where the supporting quote was located). Finally
+ * falls back to the batch-wide anchor (latest source turn timestamp) when
+ * neither per-fact signal is present — preserving legacy behaviour for
+ * extractors that do not emit provenance.
+ *
+ * The earliest provenance span wins because a fact backed by quotes from
+ * multiple turns was *first* uttered at the earliest turn: a relative
+ * expression ("yesterday") on that fact should resolve against that turn,
+ * not a later turn that merely restated the claim.
+ *
+ * Returns `undefined` only when no signal is usable AND `batchAnchor` is
+ * absent — in which case the caller skips bi-temporal resolution entirely
+ * (identical to the pre-feature pipeline when biTemporal is off).
+ */
+export function pickFactEventTimeAnchor(
+  fact: FactAnchorInput,
+  batchAnchor: string | undefined,
+): string | undefined {
+  // 1. Explicit per-fact source-turn timestamp (highest priority).
+  if (
+    typeof fact.sourceTurnTimestamp === "string" &&
+    fact.sourceTurnTimestamp.trim().length > 0
+  ) {
+    const ms = parseFlexibleIsoTimestamp(fact.sourceTurnTimestamp.trim());
+    if (ms !== null) return new Date(ms).toISOString();
+  }
+  // 2. Earliest provenance span turn timestamp.
+  if (fact.sources && fact.sources.length > 0) {
+    let earliestMs: number | null = null;
+    for (const src of fact.sources) {
+      if (typeof src.observedAt !== "string") continue;
+      const ms = parseFlexibleIsoTimestamp(src.observedAt.trim());
+      if (ms === null) continue;
+      if (earliestMs === null || ms < earliestMs) earliestMs = ms;
+    }
+    if (earliestMs !== null) return new Date(earliestMs).toISOString();
+  }
+  // 3. Batch-wide anchor (legacy fallback).
+  return batchAnchor;
+}

package/src/extraction-eventtime-wiring.test.ts

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { mkdtemp, rm } from "node:fs/promises";
 
-import { resolveFactEventTime } from "./event-time.js";
+import { pickFactEventTimeAnchor, resolveFactEventTime } from "./event-time.js";
 import { ExtractionEngine } from "./extraction.js";
 import { ExtractedFactSchema } from "./schemas.js";
 import { StorageManager } from "./storage.js";
@@ -267,3 +267,103 @@ test("resolveFactEventTime: bare '2025-03' (YYYY-MM) → validFrom = first of mo
   assert.equal(result.validFrom, "2025-03-01T00:00:00.000Z");
   assert.equal(result.validUntil, undefined);
 });
+
+// ── #1670: per-fact source-turn anchor selection ─────────────────────────
+
+test("pickFactEventTimeAnchor: explicit sourceTurnTimestamp wins over batch anchor", () => {
+  // A buffered batch's latest turn is 2025-04-12, but the fact was extracted
+  // from an earlier turn on 2025-04-10. The per-fact timestamp must win.
+  const anchor = pickFactEventTimeAnchor(
+    { sourceTurnTimestamp: "2025-04-10T12:00:00.000Z" },
+    "2025-04-12T12:00:00.000Z",
+  );
+  assert.equal(anchor, "2025-04-10T12:00:00.000Z");
+});
+
+test("pickFactEventTimeAnchor: earliest provenance span observedAt used when no sourceTurnTimestamp", () => {
+  // A fact backed by spans from two turns: the EARLIEST span's observedAt is
+  // the turn where the claim was first uttered — the correct anchor for a
+  // relative expression like "yesterday".
+  const anchor = pickFactEventTimeAnchor(
+    {
+      sources: [
+        { observedAt: "2025-04-11T08:00:00.000Z" },
+        { observedAt: "2025-04-10T08:00:00.000Z" },
+        { observedAt: "2025-04-12T08:00:00.000Z" },
+      ],
+    },
+    "2025-04-12T08:00:00.000Z",
+  );
+  assert.equal(anchor, "2025-04-10T08:00:00.000Z");
+});
+
+test("pickFactEventTimeAnchor: sourceTurnTimestamp takes precedence over provenance spans", () => {
+  const anchor = pickFactEventTimeAnchor(
+    {
+      sourceTurnTimestamp: "2025-04-09T00:00:00.000Z",
+      sources: [{ observedAt: "2025-04-11T00:00:00.000Z" }],
+    },
+    "2025-04-12T00:00:00.000Z",
+  );
+  assert.equal(anchor, "2025-04-09T00:00:00.000Z");
+});
+
+test("pickFactEventTimeAnchor: falls back to batch anchor when no per-fact signal", () => {
+  const anchor = pickFactEventTimeAnchor({}, "2025-04-12T12:00:00.000Z");
+  assert.equal(anchor, "2025-04-12T12:00:00.000Z");
+});
+
+test("pickFactEventTimeAnchor: returns undefined when no signal and no batch anchor", () => {
+  const anchor = pickFactEventTimeAnchor({}, undefined);
+  assert.equal(anchor, undefined);
+});
+
+test("pickFactEventTimeAnchor: ignores corrupt sourceTurnTimestamp, falls through to provenance", () => {
+  const anchor = pickFactEventTimeAnchor(
+    {
+      sourceTurnTimestamp: "not-a-timestamp",
+      sources: [{ observedAt: "2025-04-10T08:00:00.000Z" }],
+    },
+    "2025-04-12T08:00:00.000Z",
+  );
+  assert.equal(anchor, "2025-04-10T08:00:00.000Z");
+});
+
+test("pickFactEventTimeAnchor: ignores corrupt provenance observedAt entries, falls through to batch", () => {
+  const anchor = pickFactEventTimeAnchor(
+    { sources: [{ observedAt: "garbage" }, { observedAt: "also-bad" }] },
+    "2025-04-12T08:00:00.000Z",
+  );
+  assert.equal(anchor, "2025-04-12T08:00:00.000Z");
+});
+
+test("#1670 integration: 'yesterday' on an early-turn fact resolves against the early turn, not the batch", () => {
+  // Simulates the exact scenario from the issue: a buffered conversation
+  // spanning a date boundary. The fact carries provenance from the early turn.
+  const earlyAnchor = pickFactEventTimeAnchor(
+    { sources: [{ observedAt: "2025-01-15T10:00:00.000Z" }] },
+    "2025-01-17T10:00:00.000Z", // batch latest = 3 days later
+  );
+  assert.ok(earlyAnchor, "anchor must resolve from provenance");
+  const result = resolveFactEventTime("yesterday", earlyAnchor);
+  assert.ok(result.validFrom!.startsWith("2025-01-14"),
+    `yesterday relative to early turn should be 2025-01-14, got ${result.validFrom}`);
+});
+
+test("#1670 integration: same expression, batch vs source-turn anchor → different validFrom", () => {
+  // Without per-fact provenance, "yesterday" resolves against the batch
+  // (latest turn = 2025-01-17 → 2025-01-16). With provenance from the early
+  // turn (2025-01-15), it resolves to 2025-01-14. The two must differ.
+  const batchAnchor = pickFactEventTimeAnchor({}, "2025-01-17T10:00:00.000Z");
+  assert.ok(batchAnchor);
+  const batchResult = resolveFactEventTime("yesterday", batchAnchor);
+  const provenanceAnchor = pickFactEventTimeAnchor(
+    { sources: [{ observedAt: "2025-01-15T10:00:00.000Z" }] },
+    "2025-01-17T10:00:00.000Z",
+  );
+  assert.ok(provenanceAnchor);
+  const provenanceResult = resolveFactEventTime("yesterday", provenanceAnchor);
+  assert.notEqual(batchResult.validFrom, provenanceResult.validFrom);
+  assert.ok(batchResult.validFrom!.startsWith("2025-01-16"));
+  assert.ok(provenanceResult.validFrom!.startsWith("2025-01-14"));
+});