@remnic/core 9.3.705 → 9.3.706

package/dist/temporal-supersession.d.ts

@@ -1,4 +1,4 @@
-import { k as MemoryFrontmatter } from './types-CJrvHJjx.js';
+import { k as MemoryFrontmatter } from './types-Couvz-L3.js';
 import { StorageManager } from './storage.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';

package/dist/temporal-supersession.js

@@ -6,8 +6,8 @@ import {
   shouldFilterSupersededFromRecall,
   shouldSupersedeExisting,
   supersessionKeysForFact
-} from "./chunk-OMNTQPZO.js";
-import "./chunk-IREVVFTM.js";
+} from "./chunk-TKZ3AL5V.js";
+import "./chunk-6CIAGZ6X.js";
 import "./chunk-NU3CSQ4H.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/temporal-validity.d.ts

@@ -1,4 +1,4 @@
-import { k as MemoryFrontmatter } from './types-CJrvHJjx.js';
+import { k as MemoryFrontmatter } from './types-Couvz-L3.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
 
@@ -42,7 +42,7 @@ declare function effectiveInvalidAt(fm: Pick<MemoryFrontmatter, "invalid_at" | "
  * the historical filter (CLAUDE.md gotcha #34: distinguish empty from
  * malformed).
  */
-declare function isValidAsOf(fm: Pick<MemoryFrontmatter, "valid_at" | "invalid_at" | "created" | "supersededAt" | "status">, asOfMs: number): boolean;
+declare function isValidAsOf(fm: Pick<MemoryFrontmatter, "valid_at" | "invalid_at" | "created" | "supersededAt" | "status" | "eventTimeSource">, asOfMs: number): boolean;
 /**
  * Bi-temporal injection filter (issue #1578).
  *

package/dist/temporal-validity.js

@@ -4,7 +4,7 @@ import {
   isValidAsOf,
   isValidityExpiredNow,
   parseAsOfTimestamp
-} from "./chunk-IREVVFTM.js";
+} from "./chunk-6CIAGZ6X.js";
 import "./chunk-PZ5AY32C.js";
 export {
   effectiveInvalidAt,

package/dist/threading.d.ts

@@ -1,4 +1,4 @@
-import { u as BufferTurn, am as ConversationThread } from './types-CJrvHJjx.js';
+import { u as BufferTurn, am as ConversationThread } from './types-Couvz-L3.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
 

package/dist/tier-migration.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile } from './types-CJrvHJjx.js';
+import { g as MemoryFile } from './types-Couvz-L3.js';
 import { StorageManager } from './storage.js';
 import { MemoryTier } from './tier-routing.js';
 import { SearchBackend } from './search/port.js';

package/dist/tier-routing.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile } from './types-CJrvHJjx.js';
+import { g as MemoryFile } from './types-Couvz-L3.js';
 import { LifecycleSignals } from './lifecycle.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';

package/dist/topics.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile, an as TopicScore } from './types-CJrvHJjx.js';
+import { g as MemoryFile, an as TopicScore } from './types-Couvz-L3.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
 

package/dist/transcript.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig, T as TranscriptEntry, v as Checkpoint } from './types-CJrvHJjx.js';
+import { P as PluginConfig, T as TranscriptEntry, v as Checkpoint } from './types-Couvz-L3.js';
 import { SessionIntegrityReport } from './session-integrity.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';

package/dist/{types-CJrvHJjx.d.ts → types-Couvz-L3.d.ts}

@@ -1084,8 +1084,9 @@ interface PluginConfig {
      * Turn on to exclude validity-expired facts from default injection
      * candidates (they remain findable by explicit search and `as_of`
      * queries). Storage round-trips `observedAt`/`eventTimeSource`; the
-     * extraction prompt → `resolveEventTime` write-time wiring lands in a
-     * follow-on PR, so new extractions are not yet event-time-resolved.
+     * extraction prompt emits an optional per-fact `eventTime` expression
+     * and `resolveFactEventTime` resolves it against the source turn
+     * timestamp at write time (#1578 PR2).
      */
     temporalBiTemporal: boolean;
     /**
@@ -2987,6 +2988,15 @@ interface ExtractedFact {
      * walked through. Persisted under reasoning-traces/.
      */
     reasoningTrace?: ExtractedReasoningTrace;
+    /**
+     * Optional event-time expression for bi-temporal validity (#1578 PR2).
+     * Verbatim temporal anchor extracted from the conversation ("2025-03-01",
+     * "last March", "since 2024", "until 2025-06-01"). Resolved against the
+     * source turn timestamp at write time by `resolveFactEventTime` — never
+     * re-resolved at read. Absent when the fact carries no temporal anchor or
+     * when `temporal.biTemporal` is off.
+     */
+    eventTime?: string;
 }
 interface ExtractedReasoningTraceStep {
     order: number;

package/dist/types.d.ts

@@ -1,3 +1,3 @@
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
-export { au as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, J as AgentAccessAuthToken, b8 as AgentAccessHttpConfig, b9 as AgentDefaultsConfig, ba as AgentPersona, f as AgentPersonaModelConfig, bb as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, bc as BehaviorSignalDirection, B as BehaviorSignalEvent, bd as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, r as BriefingActiveThread, be as BriefingCalendarSourceError, aU as BriefingConfig, p as BriefingFocus, o as BriefingFollowup, aV as BriefingOpenCommitment, t as BriefingRecentEntity, s as BriefingResult, n as BriefingSections, aW as BriefingWindow, bf as BufferEntryState, ap as BufferState, z as BufferSurpriseEvent, u as BufferTurn, q as CalendarEvent, C as CalendarSource, bg as CaptureMode, v as Checkpoint, bh as CodexCliReasoningEffort, bi as CodexCompactionFlushMode, aX as CodexCompatConfig, bj as CodexConnectorConfig, aG as CodingContext, bk as CodingKnowledgeConfig, aR as CodingModeConfig, bl as CompressionGuidelineActivationState, N as CompressionGuidelineOptimizerActionSummary, K as CompressionGuidelineOptimizerEventCounts, O as CompressionGuidelineOptimizerRuleUpdate, bm as CompressionGuidelineOptimizerSourceWindow, X as CompressionGuidelineOptimizerState, bn as ConfidenceTier, bo as ConsolidationAction, bp as ConsolidationItem, aJ as ConsolidationObservation, a1 as ConsolidationResult, a6 as ContinuityImprovementLoop, a4 as ContinuityIncidentCloseInput, a5 as ContinuityIncidentOpenInput, a3 as ContinuityIncidentRecord, bq as ContinuityIncidentState, br as ContinuityLoopCadence, a7 as ContinuityLoopReviewInput, bs as ContinuityLoopStatus, a8 as ContinuityLoopUpsertInput, bt as ContradictionScanConfig, am as ConversationThread, bu as CronConversationRecallMode, bv as CronRecallMode, aY as DEFAULT_RECALL_DISCLOSURE, a2 as DaySummaryResult, bw as DreamingConfig, bx as DreamingNarrativePromptStyle, by as DreamsDeepSleepConfig, bz as DreamsLightSleepConfig, aP as DreamsPhase, bA as DreamsPhaseStatus, bB as DreamsPhasesConfig, bC as DreamsRemConfig, aQ as DreamsRunResult, aO as DreamsStatusResult, bD as EngramTraceEvent, at as EntityActivityEntry, E as EntityFile, Y as EntityMention, as as EntityRelationship, Z as EntitySchemaDefinition, _ as EntitySchemaSectionDefinition, $ as EntityStructuredSection, aK as EntityTimelineEntry, aZ as ExtractedFact, bE as ExtractedProcedureStep, bF as ExtractedQuestion, bG as ExtractedReasoningTrace, bH as ExtractedReasoningTraceStep, bI as ExtractedRelationship, bJ as ExtractionPassSource, a0 as ExtractionResult, F as FaithfulnessFrontmatter, ar as FileHygieneConfig, G as GatewayConfig, bK as GitHubLiveConnectorConfig, bL as GmailLiveConnectorConfig, bM as GoogleDriveLiveConnectorConfig, bN as HeartbeatConfig, bO as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, y as ImportanceLevel, a9 as ImportanceScore, w as LifecycleState, L as LiveConnectorsConfig, bP as LlmTraceCallback, bQ as LlmTraceEvent, ac as MemoryActionEligibilityContext, a_ as MemoryActionEligibilitySource, W as MemoryActionEvent, bR as MemoryActionOutcome, bS as MemoryActionPolicyDecision, ad as MemoryActionPolicyResult, bT as MemoryActionStatus, U as MemoryActionType, M as MemoryCategory, g as MemoryFile, k as MemoryFrontmatter, aa as MemoryIntent, m as MemoryLifecycleEvent, ae as MemoryLifecycleEventType, af as MemoryLifecycleStateSummary, ao as MemoryLink, bU as MemoryLinkType, a$ as MemoryObservation, bV as MemoryOsPresetName, l as MemoryProjectionCurrentState, b0 as MemoryScope, h as MemoryStatus, av as MemorySummary, aq as MetaState, bW as ModelApi, bX as ModelDefinitionConfig, bY as ModelProviderAuthMode, ag as ModelProviderConfig, bZ as NamespacePolicy, ah as NativeKnowledgeConfig, b_ as NativeKnowledgeFolderRuleConfig, b$ as NativeKnowledgeObsidianVaultConfig, c0 as NativeKnowledgeOpenClawWorkspaceConfig, c1 as NotionLiveConnectorConfig, P as PluginConfig, x as PolicyClass, c2 as PrincipalFromSessionKeyMode, c3 as PrincipalRule, c4 as ProceduralConfig, aj as ProvenanceConfig, ai as ProvenanceSource, ab as QmdSearchExplain, Q as QmdSearchResult, c5 as QuestionEntry, b1 as RECALL_DISCLOSURE_LEVELS, c6 as ReasoningEffort, j as RecallDisclosure, c7 as RecallPipelineConfig, i as RecallPlanMode, c8 as RecallSectionConfig, R as RecallTierExplain, c9 as RecallTraceEvent, ca as RelevanceFeedback, ak as RetrievalTier, cb as SPECULATIVE_TTL_DAYS, cc as ScopeProfileAutoPromoteConfig, aN as ScopeProfileConfig, aL as ScopeProfileLayerId, aM as ScopeProfilePromotionTarget, cd as ScopeProfileTeamProjectConfig, ce as ScopeTeamConfig, cf as ScoredEntity, D as SecretRef, cg as SemanticChunkingConfigShape, S as SessionObserverBandConfig, ch as SignalLevel, al as SignalScanResult, ci as SlotBehaviorConfig, cj as SlotMismatchMode, an as TopicScore, T as TranscriptEntry, ck as TriggerMode, V as VerificationState, cl as confidenceTier, b7 as isRecallDisclosure } from './types-CJrvHJjx.js';
+export { au as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, J as AgentAccessAuthToken, b8 as AgentAccessHttpConfig, b9 as AgentDefaultsConfig, ba as AgentPersona, f as AgentPersonaModelConfig, bb as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, bc as BehaviorSignalDirection, B as BehaviorSignalEvent, bd as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, r as BriefingActiveThread, be as BriefingCalendarSourceError, aU as BriefingConfig, p as BriefingFocus, o as BriefingFollowup, aV as BriefingOpenCommitment, t as BriefingRecentEntity, s as BriefingResult, n as BriefingSections, aW as BriefingWindow, bf as BufferEntryState, ap as BufferState, z as BufferSurpriseEvent, u as BufferTurn, q as CalendarEvent, C as CalendarSource, bg as CaptureMode, v as Checkpoint, bh as CodexCliReasoningEffort, bi as CodexCompactionFlushMode, aX as CodexCompatConfig, bj as CodexConnectorConfig, aG as CodingContext, bk as CodingKnowledgeConfig, aR as CodingModeConfig, bl as CompressionGuidelineActivationState, N as CompressionGuidelineOptimizerActionSummary, K as CompressionGuidelineOptimizerEventCounts, O as CompressionGuidelineOptimizerRuleUpdate, bm as CompressionGuidelineOptimizerSourceWindow, X as CompressionGuidelineOptimizerState, bn as ConfidenceTier, bo as ConsolidationAction, bp as ConsolidationItem, aJ as ConsolidationObservation, a1 as ConsolidationResult, a6 as ContinuityImprovementLoop, a4 as ContinuityIncidentCloseInput, a5 as ContinuityIncidentOpenInput, a3 as ContinuityIncidentRecord, bq as ContinuityIncidentState, br as ContinuityLoopCadence, a7 as ContinuityLoopReviewInput, bs as ContinuityLoopStatus, a8 as ContinuityLoopUpsertInput, bt as ContradictionScanConfig, am as ConversationThread, bu as CronConversationRecallMode, bv as CronRecallMode, aY as DEFAULT_RECALL_DISCLOSURE, a2 as DaySummaryResult, bw as DreamingConfig, bx as DreamingNarrativePromptStyle, by as DreamsDeepSleepConfig, bz as DreamsLightSleepConfig, aP as DreamsPhase, bA as DreamsPhaseStatus, bB as DreamsPhasesConfig, bC as DreamsRemConfig, aQ as DreamsRunResult, aO as DreamsStatusResult, bD as EngramTraceEvent, at as EntityActivityEntry, E as EntityFile, Y as EntityMention, as as EntityRelationship, Z as EntitySchemaDefinition, _ as EntitySchemaSectionDefinition, $ as EntityStructuredSection, aK as EntityTimelineEntry, aZ as ExtractedFact, bE as ExtractedProcedureStep, bF as ExtractedQuestion, bG as ExtractedReasoningTrace, bH as ExtractedReasoningTraceStep, bI as ExtractedRelationship, bJ as ExtractionPassSource, a0 as ExtractionResult, F as FaithfulnessFrontmatter, ar as FileHygieneConfig, G as GatewayConfig, bK as GitHubLiveConnectorConfig, bL as GmailLiveConnectorConfig, bM as GoogleDriveLiveConnectorConfig, bN as HeartbeatConfig, bO as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, y as ImportanceLevel, a9 as ImportanceScore, w as LifecycleState, L as LiveConnectorsConfig, bP as LlmTraceCallback, bQ as LlmTraceEvent, ac as MemoryActionEligibilityContext, a_ as MemoryActionEligibilitySource, W as MemoryActionEvent, bR as MemoryActionOutcome, bS as MemoryActionPolicyDecision, ad as MemoryActionPolicyResult, bT as MemoryActionStatus, U as MemoryActionType, M as MemoryCategory, g as MemoryFile, k as MemoryFrontmatter, aa as MemoryIntent, m as MemoryLifecycleEvent, ae as MemoryLifecycleEventType, af as MemoryLifecycleStateSummary, ao as MemoryLink, bU as MemoryLinkType, a$ as MemoryObservation, bV as MemoryOsPresetName, l as MemoryProjectionCurrentState, b0 as MemoryScope, h as MemoryStatus, av as MemorySummary, aq as MetaState, bW as ModelApi, bX as ModelDefinitionConfig, bY as ModelProviderAuthMode, ag as ModelProviderConfig, bZ as NamespacePolicy, ah as NativeKnowledgeConfig, b_ as NativeKnowledgeFolderRuleConfig, b$ as NativeKnowledgeObsidianVaultConfig, c0 as NativeKnowledgeOpenClawWorkspaceConfig, c1 as NotionLiveConnectorConfig, P as PluginConfig, x as PolicyClass, c2 as PrincipalFromSessionKeyMode, c3 as PrincipalRule, c4 as ProceduralConfig, aj as ProvenanceConfig, ai as ProvenanceSource, ab as QmdSearchExplain, Q as QmdSearchResult, c5 as QuestionEntry, b1 as RECALL_DISCLOSURE_LEVELS, c6 as ReasoningEffort, j as RecallDisclosure, c7 as RecallPipelineConfig, i as RecallPlanMode, c8 as RecallSectionConfig, R as RecallTierExplain, c9 as RecallTraceEvent, ca as RelevanceFeedback, ak as RetrievalTier, cb as SPECULATIVE_TTL_DAYS, cc as ScopeProfileAutoPromoteConfig, aN as ScopeProfileConfig, aL as ScopeProfileLayerId, aM as ScopeProfilePromotionTarget, cd as ScopeProfileTeamProjectConfig, ce as ScopeTeamConfig, cf as ScoredEntity, D as SecretRef, cg as SemanticChunkingConfigShape, S as SessionObserverBandConfig, ch as SignalLevel, al as SignalScanResult, ci as SlotBehaviorConfig, cj as SlotMismatchMode, an as TopicScore, T as TranscriptEntry, ck as TriggerMode, V as VerificationState, cl as confidenceTier, b7 as isRecallDisclosure } from './types-Couvz-L3.js';

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-IX3UQT4H.js";
+} from "./chunk-MLLTU5FX.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-CJrvHJjx.js';
+import './types-Couvz-L3.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
 import './lifecycle.js';

package/dist/verified-recall.js

@@ -1,20 +1,20 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-NFGJBEPT.js";
+} from "./chunk-MRX6ZXHZ.js";
 import "./chunk-7FL4CNPV.js";
 import "./chunk-ZBJMUXZH.js";
-import "./chunk-C2EHWNP2.js";
+import "./chunk-2VQYHHWB.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-3JJWNZTT.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
-import "./chunk-OMNTQPZO.js";
-import "./chunk-IREVVFTM.js";
+import "./chunk-TKZ3AL5V.js";
+import "./chunk-6CIAGZ6X.js";
 import "./chunk-SVOZFLIQ.js";
 import "./chunk-LTJAMRGI.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-IX3UQT4H.js";
+import "./chunk-MLLTU5FX.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.705",
+  "version": "9.3.706",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2966,7 +2966,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.705"
+    "@remnic/coding-graph": "^9.3.706"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

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