@remnic/core 9.3.704 → 9.3.706

package/src/access-operations.ts

@@ -549,6 +549,10 @@ export const codegraphIngestTracesOperation = defineOperation<
   },
 });
 
+// Batch-migrated operations (issue #1525): registers all remaining
+// handlers through the boundary as a side effect of importing this module.
+import "./access-operations-batch.js";
+
 export const REGISTERED_OPERATIONS = [
   memoryGetOperation.spec.name,
   memorySearchOperation.spec.name,

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

@@ -44,7 +44,7 @@ import {
 // 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.
-const UNMIGRATED_HANDLER_BASELINE = 134;
+const UNMIGRATED_HANDLER_BASELINE = 80;
 
 // Keep the import live — `getOperation` is the call surfaces use at dispatch
 // time; referencing it here pins the registry's lookup contract.
@@ -187,6 +187,7 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
   const lines = source.split("\n");
   const routeOps = new Map<string, Set<string>>();
   let currentKey: string | null = null;
+  let lastSeenPathname: string | null = null;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]!;
@@ -217,6 +218,7 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
     }
 
     if (pathname) {
+      lastSeenPathname = pathname;
       // Determine the HTTP method: same line first, then backward for
       // exact-match routes, forward for dynamic routes. Check both positive
       // (===) and negated (!==) method patterns — `req.method !== "GET"` as
@@ -253,6 +255,20 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
       continue;
     }
 
+    // Detect method changes within a shared route block (e.g. a single
+    // regex match with GET/PUT/DELETE branches). When a new method check
+    // appears after a route pattern was already detected, update currentKey
+    // to the new method + the same pathname so per-method getOperation
+    // calls are tracked against the right route key.
+    const methodChange = line.match(/req\.method\s*===\s*"(\w+)"/);
+    if (methodChange && lastSeenPathname) {
+      const newKey = methodChange[1]! + " " + lastSeenPathname;
+      if (!routeOps.has(newKey)) {
+        routeOps.set(newKey, new Set<string>());
+      }
+      currentKey = newKey;
+    }
+
     // Collect getOperation calls within the current route block.
     if (currentKey) {
       const opMatch = line.match(/getOperation\("(\w+)"\)/);

package/src/access-surface-catalog.ts

@@ -160,65 +160,68 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
 // (health, adapters, the /mcp delegate, admin console, SSE-only endpoints)
 // carry no user request envelope and are intentionally excluded.
 export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
-  { method: "POST", pathname: "/engram/v1/recall", operation: null },
-  { method: "POST", pathname: "/engram/v1/coding-context", operation: null },
-  { method: "POST", pathname: "/engram/v1/capsules/export", operation: null },
-  { method: "POST", pathname: "/engram/v1/capsules/import", operation: null },
-  { method: "GET", pathname: "/engram/v1/offline-sync/snapshot", operation: null },
-  { method: "GET", pathname: "/engram/v1/offline-sync/snapshot-stream", operation: null },
-  { method: "POST", pathname: "/engram/v1/offline-sync/snapshot", operation: null },
-  { method: "POST", pathname: "/engram/v1/offline-sync/files", operation: null },
-  { method: "POST", pathname: "/engram/v1/offline-sync/file-content", operation: null },
-  { method: "POST", pathname: "/engram/v1/offline-sync/apply-file-content", operation: null },
-  { method: "POST", pathname: "/engram/v1/offline-sync/apply", operation: null },
-  { method: "POST", pathname: "/engram/v1/recall/explain", operation: null },
-  { method: "POST", pathname: "/engram/v1/action-confidence", operation: null },
-  { method: "GET", pathname: "/engram/v1/recall/tier-explain", operation: null },
-  { method: "GET", pathname: "/engram/v1/recall/xray", operation: null },
-  { method: "GET", pathname: "/engram/v1/wearables/status", operation: null },
-  { method: "POST", pathname: "/engram/v1/wearables/sync", operation: null },
-  { method: "GET", pathname: "/engram/v1/wearables/transcript", operation: null },
-  { method: "GET", pathname: "/engram/v1/wearables/transcripts/search", operation: null },
-  { method: "GET", pathname: "/engram/v1/wearables/memories", operation: null },
-  { method: "POST", pathname: "/engram/v1/observe", operation: null },
-  { method: "POST", pathname: "/engram/v1/lcm/search", operation: null },
-  { method: "POST", pathname: "/engram/v1/lcm/compaction/flush", operation: null },
-  { method: "POST", pathname: "/engram/v1/lcm/compaction/record", operation: null },
-  { method: "GET", pathname: "/engram/v1/lcm/status", operation: null },
+  { method: "POST", pathname: "/engram/v1/recall", operation: "recall" },
+  { method: "POST", pathname: "/engram/v1/coding-context", operation: "set_coding_context" },
+  { method: "POST", pathname: "/engram/v1/capsules/export", operation: "capsule_export" },
+  { method: "POST", pathname: "/engram/v1/capsules/import", operation: "capsule_import" },
+  { method: "GET", pathname: "/engram/v1/offline-sync/snapshot", operation: "offline_sync_snapshot" },
+    { method: "POST", pathname: "/engram/v1/offline-sync/snapshot", operation: "offline_sync_snapshot" },
+  { method: "POST", pathname: "/engram/v1/offline-sync/files", operation: "offline_sync_files" },
+  { method: "POST", pathname: "/engram/v1/offline-sync/file-content", operation: "offline_sync_file_content" },
+  { method: "POST", pathname: "/engram/v1/offline-sync/apply-file-content", operation: "offline_sync_apply_file_content" },
+  { method: "POST", pathname: "/engram/v1/offline-sync/apply", operation: "offline_sync_apply" },
+  { method: "POST", pathname: "/engram/v1/recall/explain", operation: "recall_explain" },
+  { method: "POST", pathname: "/engram/v1/action-confidence", operation: "action_confidence" },
+  { method: "GET", pathname: "/engram/v1/recall/tier-explain", operation: "recall_tier_explain" },
+  { method: "GET", pathname: "/engram/v1/recall/xray", operation: "recall_xray" },
+  { method: "GET", pathname: "/engram/v1/wearables/status", operation: "wearables_status" },
+  { method: "POST", pathname: "/engram/v1/wearables/sync", operation: "wearables_sync" },
+  { method: "GET", pathname: "/engram/v1/wearables/transcript", operation: "transcript_day" },
+  { method: "GET", pathname: "/engram/v1/wearables/transcripts/search", operation: "transcript_search" },
+  { method: "GET", pathname: "/engram/v1/wearables/memories", operation: "transcript_memories" },
+  { method: "POST", pathname: "/engram/v1/observe", operation: "observe" },
+  { method: "POST", pathname: "/engram/v1/lcm/search", operation: "lcm_search" },
+  { method: "POST", pathname: "/engram/v1/lcm/compaction/flush", operation: "lcm_compaction_flush" },
+  { method: "POST", pathname: "/engram/v1/lcm/compaction/record", operation: "lcm_compaction_record" },
+  { method: "GET", pathname: "/engram/v1/lcm/status", operation: "lcm_status" },
   { 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" },
   { method: "POST", pathname: "/engram/v1/coding/delta", operation: "coding_delta" },
-  { method: "POST", pathname: "/engram/v1/suggestions", operation: null },
-  { method: "GET", pathname: "/engram/v1/memories", operation: null },
+  { method: "POST", pathname: "/engram/v1/suggestions", operation: "suggestion_submit" },
+  { method: "GET", pathname: "/engram/v1/memories", operation: "memory_list" },
   { method: "GET", pathname: "/engram/v1/memories/:id", operation: "memory_get" },
-  { method: "GET", pathname: "/engram/v1/memories/:id/timeline", operation: null },
-  { method: "GET", pathname: "/engram/v1/entities", operation: null },
-  { method: "GET", pathname: "/engram/v1/entities/:id", operation: null },
-  { method: "GET", pathname: "/engram/v1/review-queue", operation: null },
-  { method: "GET", pathname: "/engram/v1/maintenance", operation: null },
-  { method: "GET", pathname: "/engram/v1/quality", operation: null },
-  { method: "GET", pathname: "/engram/v1/trust-zones/status", operation: null },
-  { method: "GET", pathname: "/engram/v1/procedural/stats", operation: null },
-  { method: "GET", pathname: "/engram/v1/trust-zones/records", operation: null },
-  { method: "POST", pathname: "/engram/v1/review-disposition", operation: null },
-  { method: "POST", pathname: "/engram/v1/trust-zones/promote", operation: null },
-  { method: "POST", pathname: "/engram/v1/trust-zones/demo-seed", operation: null },
-  { method: "POST", pathname: "/v1/citations/observed", operation: null },
-  { method: "GET", pathname: "/engram/v1/review/contradictions", operation: null },
-  { method: "GET", pathname: "/engram/v1/review/contradictions/:id", operation: null },
-  { method: "POST", pathname: "/engram/v1/review/resolve", operation: null },
-  { method: "GET", pathname: "/engram/v1/graph/snapshot", operation: null },
-  { method: "POST", pathname: "/engram/v1/contradiction-scan", operation: null },
-  { method: "GET", pathname: "/engram/v1/graph/events", operation: null },
-  { method: "GET", pathname: "/engram/v1/console/state", operation: null },
-  { method: "GET", pathname: "/engram/v1/peers", operation: null },
-  { method: "GET", pathname: "/engram/v1/peers/:id/profile", operation: null },
-  { method: "GET", pathname: "/engram/v1/peers/:id", operation: null },
-  { method: "PUT", pathname: "/engram/v1/peers/:id", operation: null },
-  { method: "DELETE", pathname: "/engram/v1/peers/:id", operation: null },
-  { method: "GET", pathname: "/engram/v1/dreams/status", operation: null },
-  { method: "POST", pathname: "/engram/v1/dreams/run", operation: null },
+  { method: "GET", pathname: "/engram/v1/memories/:id/timeline", operation: "memory_timeline" },
+  { method: "GET", pathname: "/engram/v1/entities", operation: "entity_list" },
+  { method: "GET", pathname: "/engram/v1/entities/:id", operation: "entity_get" },
+  { method: "GET", pathname: "/engram/v1/review-queue", operation: "review_queue_list" },
+  { method: "GET", pathname: "/engram/v1/maintenance", operation: "maintenance_status" },
+  { method: "GET", pathname: "/engram/v1/quality", operation: "quality_status" },
+  { method: "GET", pathname: "/engram/v1/trust-zones/status", operation: "trust_zones_status" },
+  { method: "GET", pathname: "/engram/v1/procedural/stats", operation: "procedural_stats" },
+  { method: "GET", pathname: "/engram/v1/trust-zones/records", operation: "trust_zones_records" },
+  { method: "POST", pathname: "/engram/v1/review-disposition", operation: "review_disposition" },
+  { method: "POST", pathname: "/engram/v1/trust-zones/promote", operation: "trust_zones_promote" },
+  { method: "POST", pathname: "/engram/v1/trust-zones/demo-seed", operation: "trust_zones_demo_seed" },
+  { method: "POST", pathname: "/v1/citations/observed", operation: "citations_observed" },
+  { method: "GET", pathname: "/engram/v1/review/contradictions", operation: "review_list" },
+  { method: "GET", pathname: "/engram/v1/review/contradictions/:id", operation: "contradiction_detail" },
+  { method: "POST", pathname: "/engram/v1/review/resolve", operation: "review_resolve" },
+  { method: "GET", pathname: "/engram/v1/graph/snapshot", operation: "graph_snapshot" },
+  { method: "POST", pathname: "/engram/v1/contradiction-scan", operation: "contradiction_scan_run" },
+    { method: "GET", pathname: "/engram/v1/console/state", operation: "console_state" },
+  { method: "GET", pathname: "/engram/v1/peers", operation: "peer_list" },
+  { method: "GET", pathname: "/engram/v1/peers/:id/profile", operation: "peer_profile_get" },
+  { method: "GET", pathname: "/engram/v1/peers/:id", operation: "peer_get" },
+  { method: "PUT", pathname: "/engram/v1/peers/:id", operation: "peer_set" },
+  { method: "DELETE", pathname: "/engram/v1/peers/:id", operation: "peer_delete" },
+  { method: "GET", pathname: "/engram/v1/dreams/status", operation: "dreams_status" },
+  { method: "POST", pathname: "/engram/v1/dreams/run", operation: "dreams_run" },
+  // SSE-only endpoints: carried in the catalog for completeness tracking.
+  // The operation registration makes them visible to the boundary; the
+  // streaming lifecycle is owned by the HTTP transport (handleGraphEventsSSE).
+  { method: "GET", pathname: "/engram/v1/offline-sync/snapshot-stream", operation: "offline_sync_snapshot_stream" },
+  { method: "GET", pathname: "/engram/v1/graph/events", operation: "graph_events" },
 ];
 
 /**

package/src/event-time.ts

@@ -286,6 +286,14 @@ function resolveQuarter(
  */
 function resolveAbsolute(raw: string): number | null {
   const trimmed = raw.trim();
+  // YYYY-MM (ISO year-month, no day) → first day of that month, UTC
+  // (#1578 review r3: the prompt example "until 2025-06" must resolve, not
+  // fall back to "assumed").
+  const ym = /^(\d{4})-(\d{2})$/.exec(trimmed);
+  if (ym) {
+    const ms = buildDateMs(Number(ym[1]), Number(ym[2]), 1);
+    return ms === null ? null : startOfDayUtc(ms);
+  }
   const ms = parseFlexibleIsoTimestamp(trimmed);
   if (ms === null) return null;
   // Date-only inputs (no T) anchor to start-of-day UTC.
@@ -469,6 +477,17 @@ function resolveEndBound(anchorMs: number, period: string): number | null {
     return buildDateMs(Number(trimmed) + 1, 1, 1);
   }
 
+  // YYYY-MM (year-month) end bound: exclusive end = start of the FOLLOWING
+  // month, so "until 2025-06" spans all of June (#1578 review r3).
+  const ymEnd = /^(\d{4})-(\d{2})$/.exec(trimmed);
+  if (ymEnd) {
+    const startMs = buildDateMs(Number(ymEnd[1]), Number(ymEnd[2]), 1);
+    if (startMs === null) return null;
+    const nd = new Date(startMs);
+    nd.setUTCMonth(nd.getUTCMonth() + 1);
+    return startOfDayUtc(nd.getTime());
+  }
+
   // Absolute date/datetime end bound.
   const absMs = resolveAbsolute(trimmed);
   if (absMs !== null) {
@@ -546,3 +565,57 @@ function resolveEndBound(anchorMs: number, period: string): number | null {
   }
   return null;
 }
+
+/**
+ * Resolved bi-temporal fields for a single extracted fact (issue #1578 PR2).
+ *
+ * - `validFrom` / `validUntil` — the event-time `[from, until)` interval.
+ *   When `eventTimeSource === "assumed"`, `validFrom` is copied from
+ *   `observedAt` (the ingestion anchor) so every bi-temporal-on fact carries
+ *   at least a start bound.
+ * - `observedAt` — always the ingestion anchor (the source turn timestamp).
+ * - `eventTimeSource` — `"extracted"` when the expression resolved to a real
+ *   event-time interval; `"assumed"` when the expression was absent or
+ *   unresolvable.
+ *
+ * This is the single write-time helper every extraction entry path calls
+ * (rule 39). It is pure: (expression, anchor) in, interval out. Resolution
+ * never touches `Date.now()` — replay/import of old transcripts resolves
+ * against the old anchor.
+ */
+export interface FactEventTime {
+  validFrom?: string;
+  validUntil?: string;
+  observedAt: string;
+  eventTimeSource: "extracted" | "assumed";
+}
+
+/**
+ * Resolve a single fact's event-time expression against the ingestion anchor.
+ *
+ * Returns the bi-temporal interval to persist alongside the fact. When the
+ * expression is absent, empty, or unresolvable, falls back to
+ * `eventTimeSource: "assumed"` with `validFrom = observedAt` — per the
+ * #1578 frontmatter contract. When the expression resolves but only pins one
+ * bound ("since 2024" → validFrom only; "until 2025-06" → validUntil only),
+ * only the resolved bound is returned.
+ */
+export function resolveFactEventTime(
+  expression: string | undefined | null,
+  anchorIso: string,
+): FactEventTime {
+  const resolved = resolveEventTime(expression, anchorIso);
+  if (resolved.ok && (resolved.validFrom !== undefined || resolved.validUntil !== undefined)) {
+    return {
+      ...(resolved.validFrom !== undefined ? { validFrom: resolved.validFrom } : {}),
+      ...(resolved.validUntil !== undefined ? { validUntil: resolved.validUntil } : {}),
+      observedAt: anchorIso,
+      eventTimeSource: "extracted",
+    };
+  }
+  return {
+    validFrom: anchorIso,
+    observedAt: anchorIso,
+    eventTimeSource: "assumed",
+  };
+}

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

@@ -0,0 +1,269 @@
+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 { resolveFactEventTime } from "./event-time.js";
+import { ExtractionEngine } from "./extraction.js";
+import { ExtractedFactSchema } from "./schemas.js";
+import { StorageManager } from "./storage.js";
+
+/**
+ * Issue #1578 PR 2 — extraction event-time wiring.
+ *
+ * Proves three contracts:
+ *  1. resolveFactEventTime anchors to the SOURCE TURN timestamp, never
+ *     wall-clock — replay/import of an old transcript yields old-era event
+ *     times (the core bi-temporal invariant from the #1578 design).
+ *  2. Extraction normalization passes the per-fact `eventTime` expression
+ *     through from raw LLM JSON (camelCase and snake_case payloads) so the
+ *     persist path can resolve it at write time.
+ *  3. Storage round-trips `invalid_at` so the bi-temporal interval survives
+ *     write → read (complementing PR 1's observedAt/eventTimeSource test).
+ */
+
+// ── 1. Replay anchoring ──────────────────────────────────────────────────
+
+test("resolveFactEventTime: replay of a 2025 transcript anchors 'last March' to 2025-03, not today", () => {
+  // The anchor is the source turn timestamp from an old (2025) transcript.
+  const anchor2025 = "2025-04-10T12:00:00.000Z";
+  const result = resolveFactEventTime("last March", anchor2025);
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.ok(result.validFrom, "validFrom must be set for a resolvable expression");
+  // "last March" relative to April 2025 → March 2025.
+  assert.ok(result.validFrom!.startsWith("2025-03"), `expected 2025-03, got ${result.validFrom}`);
+  // Critical bi-temporal invariant: NOT anchored to today's wall-clock.
+  assert.ok(!result.validFrom!.startsWith("2026"), "must not anchor to wall-clock");
+  assert.equal(result.observedAt, anchor2025);
+});
+
+test("resolveFactEventTime: same expression, different anchors → different validFrom", () => {
+  // The identical phrase resolves differently depending on the anchor —
+  // proving the resolver is anchor-driven, not Date.now()-driven.
+  const old = resolveFactEventTime("yesterday", "2025-01-15T10:00:00.000Z");
+  const recent = resolveFactEventTime("yesterday", "2026-07-05T10:00:00.000Z");
+  assert.ok(old.validFrom!.startsWith("2025-01-14"), `got ${old.validFrom}`);
+  assert.ok(recent.validFrom!.startsWith("2026-07-04"), `got ${recent.validFrom}`);
+  assert.notEqual(old.validFrom, recent.validFrom);
+});
+
+test("resolveFactEventTime: absent expression → 'assumed' with validFrom = anchor", () => {
+  const anchor = "2025-06-01T00:00:00.000Z";
+  const result = resolveFactEventTime(undefined, anchor);
+  assert.equal(result.eventTimeSource, "assumed");
+  assert.equal(result.validFrom, anchor);
+  assert.equal(result.observedAt, anchor);
+  assert.equal(result.validUntil, undefined);
+});
+
+test("resolveFactEventTime: 'since 2024' → validFrom only (open-ended start)", () => {
+  const result = resolveFactEventTime("since 2024", "2025-06-01T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.ok(result.validFrom!.startsWith("2024-01-01"));
+  assert.equal(result.validUntil, undefined);
+});
+
+test("resolveFactEventTime: unresolvable garbage → 'assumed' fallback", () => {
+  const anchor = "2025-06-01T00:00:00.000Z";
+  const result = resolveFactEventTime("sometime maybe???", anchor);
+  assert.equal(result.eventTimeSource, "assumed");
+  assert.equal(result.validFrom, anchor);
+});
+
+// ── 2. Extraction normalization passes eventTime through ─────────────────
+
+function makeEngine(): ExtractionEngine {
+  // Minimal construction: the facts normalizer is a pure data transform
+  // (no LLM / I/O). Stub the optional deps so the constructor doesn't
+  // spin up real clients.
+  return new ExtractionEngine(
+    { memoryDir: "/tmp" } as any,
+    undefined, // profiler → safe default
+    {} as any, // localLlm stub
+    undefined, // gatewayConfig
+    {} as any, // modelRegistry stub
+  );
+}
+
+test("extraction normalization: camelCase 'eventTime' passes through to ExtractedFact", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [
+      { content: "We moved offices in March.", category: "fact", eventTime: "last March" },
+    ],
+    entities: [],
+  });
+  assert.equal(result.facts.length, 1);
+  assert.equal(result.facts[0].eventTime, "last March");
+});
+
+test("extraction normalization: snake_case 'event_time' also captured", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [
+      { content: "Switched to PostgreSQL.", category: "fact", event_time: "2025-01-15" },
+    ],
+    entities: [],
+  });
+  assert.equal(result.facts[0].eventTime, "2025-01-15");
+});
+
+test("extraction normalization: absent eventTime → undefined (assumed deferred to write time)", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [{ content: "The sky is blue.", category: "fact" }],
+    entities: [],
+  });
+  assert.equal(result.facts[0].eventTime, undefined);
+});
+
+// ── 2b. Schema preserves snake_case event_time (gateway fix, chatgpt-codex) ─
+
+test("ExtractedFactSchema: snake_case event_time survives schema parse (gateway strip-unknown fix)", () => {
+  // Zod .object() strips unknown keys by default. Before the event_time alias
+  // was added, the gateway fallback path (parseWithSchemaDetailed → schema.parse)
+  // silently dropped event_time, losing the temporal bound (#1578).
+  const parsed = ExtractedFactSchema.parse({
+    content: "Switched to PostgreSQL.",
+    category: "fact",
+    confidence: 0.9,
+    tags: [],
+    event_time: "2025-01-15",
+  });
+  assert.equal(parsed.event_time, "2025-01-15");
+});
+
+test("ExtractedFactSchema: camelCase eventTime also survives schema parse (no regression)", () => {
+  const parsed = ExtractedFactSchema.parse({
+    content: "We moved offices in March.",
+    category: "fact",
+    confidence: 0.8,
+    tags: [],
+    eventTime: "2025-03",
+  });
+  assert.equal(parsed.eventTime, "2025-03");
+});
+
+// ── 3. Storage round-trips invalid_at ────────────────────────────────────
+
+test("storage: invalid_at round-trips through writeMemoryFrontmatter → readAllMemories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-invalidAt-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const id = await storage.writeMemory("fact", "Old stack was Node 18.", {
+      validAt: "2025-01-01T00:00:00.000Z",
+      observedAt: "2025-06-01T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+
+    const before = await storage.readAllMemories();
+    const mem = before.find((m) => m.frontmatter.id === id);
+    assert.ok(mem);
+
+    const ok = await storage.writeMemoryFrontmatter(mem!, {
+      invalid_at: "2025-06-15T00:00:00.000Z",
+    });
+    assert.equal(ok, true);
+
+    const after = await storage.readAllMemories();
+    const patched = after.find((m) => m.frontmatter.id === id);
+    assert.ok(patched, "patched fact must be readable");
+    assert.equal(patched!.frontmatter.invalid_at, "2025-06-15T00:00:00.000Z");
+    // Bi-temporal provenance preserved through the frontmatter patch.
+    assert.equal(patched!.frontmatter.observedAt, "2025-06-01T00:00:00.000Z");
+    assert.equal(patched!.frontmatter.eventTimeSource, "extracted");
+    assert.equal(patched!.frontmatter.valid_at, "2025-01-01T00:00:00.000Z");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("storage: writeMemory accepts invalidAt directly (end-bound at extraction write time)", async () => {
+  // Proves Fix C: writeMemory now accepts invalidAt so "until X" expressions
+  // persist invalid_at at write time without a separate updateMemoryFrontmatter call.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-writeMem-invalid-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const id = await storage.writeMemory("fact", "We used MongoDB until June 2025.", {
+      validAt: "2024-01-01T00:00:00.000Z",
+      invalidAt: "2025-06-01T00:00:00.000Z",
+      observedAt: "2025-06-20T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    const mems = await storage.readAllMemories();
+    const mem = mems.find((m) => m.frontmatter.id === id);
+    assert.ok(mem);
+    assert.equal(mem!.frontmatter.valid_at, "2024-01-01T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.invalid_at, "2025-06-01T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("resolveFactEventTime: 'through 2026' → validUntil only (open-ended end bound)", () => {
+  const result = resolveFactEventTime("through 2026", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, undefined);
+  assert.ok(result.validUntil, "validUntil must be set for an end-bound expression");
+  // "through 2026" → exclusive end = start of 2027.
+  assert.equal(result.validUntil, "2027-01-01T00:00:00.000Z");
+});
+test("storage: writeChunk propagates invalidAt/observedAt/eventTimeSource from the parent fact (#1578 PR2)", async () => {
+  // Proves the cursor-bugbot fix: an independently-surfaced chunk expires at the
+  // same invalid_at window as its parent so recall's isValidityExpiredNow check
+  // fires on chunks too, not just the chunked parent write.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-chunk-invalid-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const parentId = await storage.writeMemory("fact", "We used MongoDB until June 2025.", {
+      validAt: "2024-01-01T00:00:00.000Z",
+      invalidAt: "2025-06-01T00:00:00.000Z",
+      observedAt: "2025-06-20T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    const chunkId = await storage.writeChunk(
+      parentId,
+      0,
+      1,
+      "fact",
+      "We used MongoDB until June 2025.",
+      {
+        validAt: "2024-01-01T00:00:00.000Z",
+        invalidAt: "2025-06-01T00:00:00.000Z",
+        observedAt: "2025-06-20T00:00:00.000Z",
+        eventTimeSource: "extracted",
+      },
+    );
+    const mems = await storage.readAllMemories();
+    const chunk = mems.find((m) => m.frontmatter.id === chunkId);
+    assert.ok(chunk, "chunk must be readable");
+    assert.equal(chunk!.frontmatter.valid_at, "2024-01-01T00:00:00.000Z");
+    assert.equal(chunk!.frontmatter.invalid_at, "2025-06-01T00:00:00.000Z",
+      "chunk must carry the parent's end bound so it expires independently");
+    assert.equal(chunk!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(chunk!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+test("resolveFactEventTime: 'until 2025-06' (YYYY-MM) → invalidAt = start of following month (#1578 r3)", () => {
+  const result = resolveFactEventTime("until 2025-06", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, undefined);
+  assert.equal(result.validUntil, "2025-07-01T00:00:00.000Z",
+    "YYYY-MM end bound must span the whole month, not fall back to assumed");
+});
+
+test("resolveFactEventTime: bare '2025-03' (YYYY-MM) → validFrom = first of month (#1578 r3)", () => {
+  const result = resolveFactEventTime("2025-03", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, "2025-03-01T00:00:00.000Z");
+  assert.equal(result.validUntil, undefined);
+});

package/src/extraction.ts

@@ -279,6 +279,12 @@ export class ExtractionEngine {
               typeof f?.quote === "string" && f.quote.trim().length > 0
                 ? f.quote
                 : undefined,
+            eventTime:
+              typeof f?.eventTime === "string" && f.eventTime.trim().length > 0
+                ? f.eventTime.trim()
+                : typeof f?.event_time === "string" && f.event_time.trim().length > 0
+                  ? f.event_time.trim()
+                  : undefined,
           }))
           .filter((f: any) => f.content.length > 0)
       : [];
@@ -750,6 +756,11 @@ export class ExtractionEngine {
       this.config.provenance?.enabled
         ? '- Source quotes: For each fact, include a "quote" field with the EXACT verbatim words from the conversation that support the fact (a contiguous span from a single turn, not a paraphrase). Cap at ~300 chars.'
         : "",
+      // #1578: emit the same event-time guidance as the primary extraction
+      // paths so proactive-recovered facts also carry an optional eventTime
+      // (chatgpt-codex thread on extraction.ts:1607). Returns "" when the
+      // bi-temporal gate is off, keeping the prompt unchanged by default.
+      this.eventTimePromptInstruction(),
       "",
       "Base extracted facts (do not repeat):",
       factsPreview || "(none)",
@@ -1250,10 +1261,23 @@ export class ExtractionEngine {
         // reasoningTrace through normalizeReasoningTrace before passing it on so
         // gateway output matches the shape local/direct-client paths produce.
         const normalizedFacts = result.facts.map((f: any) => {
-          if (!f?.reasoningTrace) return f;
+          if (!f) return f;
+          // Gateway tolerance: collapse snake_case event_time → camelCase
+          // eventTime so the gateway path matches the local/direct/proactive
+          // normalization (#1578 r3 — cursor bugbot).
+          const eventTime =
+            typeof f.eventTime === "string" && f.eventTime.trim().length > 0
+              ? f.eventTime.trim()
+              : typeof f.event_time === "string" && f.event_time.trim().length > 0
+                ? f.event_time.trim()
+                : undefined;
+          if (!f.reasoningTrace && eventTime === undefined) return f;
           return {
             ...f,
-            reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? undefined,
+            ...(f.reasoningTrace
+              ? { reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? undefined }
+              : {}),
+            ...(eventTime !== undefined ? { eventTime } : {}),
           };
         });
         const sanitized = this.sanitizeExtractionResult({
@@ -1394,7 +1418,7 @@ Examples of when to add structuredAttributes:
 - Decisions: {"chosen": "PostgreSQL", "rejected": "MongoDB", "reason": "ACID compliance"}
 - Quantities/measurements: {"budget": "50000", "team_size": "5", "deadline": "2024-06-01"}
 Only add structuredAttributes when there are concrete values. Skip for abstract or narrative facts.
-
+${this.eventTimePromptInstruction()}
 Also generate:
 1. 1-3 genuine questions you're curious about from this conversation
 2. Profile updates about user patterns/behaviors (if any)
@@ -1595,6 +1619,28 @@ ${truncatedConversation}`;
     return { facts, entities, profileUpdates: [], questions: [] };
   }
 
+  /**
+   * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on
+   * every extraction entry path when `temporal.biTemporal` is on so the LLM
+   * emits an optional per-fact `eventTime` expression. The expression is
+   * resolved against the source turn timestamp at write time — never
+   * wall-clock — so replay/import of old transcripts anchors correctly.
+   * Returns an empty string when the gate is off (byte-identical prompt).
+   */
+  private eventTimePromptInstruction(): string {
+    if (!this.config.temporalBiTemporal) return "";
+    return `
+=== Event Time (bi-temporal) ===
+When a fact has an explicit temporal anchor — a date, month, season, or relative time expression stating WHEN the fact became (or stopped being) true — capture it verbatim in an "eventTime" field on that fact. Examples:
+- "We moved offices in March" → "eventTime": "last March"
+- "The API has been rate-limited since 2024" → "eventTime": "since 2024"
+- "I switched to PostgreSQL on 2025-01-15" → "eventTime": "2025-01-15"
+- "We used MongoDB until June 2025" → "eventTime": "until 2025-06"
+Accepted forms: ISO dates ("2025-03-01"), year-month ("2025-03"), month/season + year ("March 2025", "summer 2024"), relative ("yesterday", "last week", "this month", "next year", "last December"), and open-ended ("since 2024", "until 2025-06").
+Omit "eventTime" when the fact has no explicit temporal anchor — do NOT guess or infer dates. The system resolves the expression against the conversation's own timestamp, not today's date.
+`;
+  }
+
   /**
    * Build extraction instructions shared between local and cloud LLM.
    */
@@ -1663,6 +1709,7 @@ ${existingEntities.join(", ")}
 
 When you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.
 ` : ""}
+${this.eventTimePromptInstruction()}
 Also extract relationships between entities mentioned in the conversation.
 - Format: {source: "entity-name", target: "entity-name", label: "relationship description"}
 - Max 5 relationships per extraction