@remnic/core 9.3.705 → 9.3.706

package/src/orchestrator.ts

@@ -121,6 +121,7 @@ import {
   shouldFilterSupersededFromRecall,
 } from "./temporal-supersession.js";
 import { isValidAsOf, isValidityExpiredNow } from "./temporal-validity.js";
+import { resolveFactEventTime } from "./event-time.js";
 import { RelevanceStore } from "./relevance.js";
 import { NegativeExampleStore } from "./negative.js";
 import {
@@ -12150,10 +12151,16 @@ export class Orchestrator {
         : typeof sessionKey === "string" && sessionKey.length > 0
           ? sessionKey
           : "default";
+    const captureTimestamp = new Date().toISOString();
     const turn: BufferTurn = {
       role,
       content,
-      timestamp: new Date().toISOString(),
+      timestamp: captureTimestamp,
+      // #1578: anchor live-capture turns to wall-clock when bi-temporal is on;
+      // replay/import turns carry sourceValidAt explicitly (codex P1).
+      ...(this.config.temporalBiTemporal
+        ? { sourceValidAt: captureTimestamp }
+        : {}),
       sessionKey,
       logicalSessionKey: options.logicalSessionKey ?? bufferKey,
       providerThreadId: options.providerThreadId ?? null,
@@ -13922,6 +13929,11 @@ export class Orchestrator {
       intentEntityTypes?: string[];
       memoryKind?: MemoryFrontmatter["memoryKind"];
       validAt?: string;
+      // #1578 — bi-temporal bounds + ingestion provenance forwarded to profile-
+      // target copies (same defect class as shared promotion; cursor bugbot).
+      invalidAt?: string;
+      observedAt?: string;
+      eventTimeSource?: "extracted" | "assumed";
       source: string;
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
@@ -13980,6 +13992,10 @@ export class Orchestrator {
               intentEntityTypes: options.intentEntityTypes,
               memoryKind: options.memoryKind,
               validAt: options.validAt,
+              // #1578 — forward bi-temporal bounds + ingestion provenance.
+              ...(options.invalidAt ? { invalidAt: options.invalidAt } : {}),
+              ...(options.observedAt ? { observedAt: options.observedAt } : {}),
+              ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
               contentHashSource: options.category === "fact" ? dedupContent : rawContent,
               ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
               ...(options.provenance ? { provenance: options.provenance } : {}),
@@ -13999,7 +14015,7 @@ export class Orchestrator {
                 entityRef: options.entityRef,
                 structuredAttributes: options.structuredAttributes,
                 createdAt: supersessionOrderingAt(options.validAt),
-                enabled: true,
+                enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
               });
             } catch (profileSupersessionErr) {
               log.warn(
@@ -14042,6 +14058,12 @@ export class Orchestrator {
       intentEntityTypes?: string[];
       memoryKind?: MemoryFrontmatter["memoryKind"];
       validAt?: string;
+      // #1578 — bi-temporal bounds + ingestion provenance forwarded to the
+      // shared-namespace copy so shared recall honours the same invalid_at
+      // window as the source fact (cursor bugbot).
+      invalidAt?: string;
+      observedAt?: string;
+      eventTimeSource?: "extracted" | "assumed";
       source: string;
       /** Claim-level provenance spans (issue #1575 PR 2). */
       sources?: ProvenanceSource[];
@@ -14196,7 +14218,7 @@ export class Orchestrator {
                   entityRef: options.entityRef,
                   structuredAttributes: options.structuredAttributes,
                   createdAt: supersessionOrderingAt(options.validAt),
-                  enabled: true,
+                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
                   useCallerTimestamp: true,
                 });
                 // Catalog touch (issue #1499 — codex P2 NElSf): this dedup branch
@@ -14271,6 +14293,10 @@ export class Orchestrator {
             intentEntityTypes: options.intentEntityTypes,
             memoryKind: options.memoryKind,
             validAt: options.validAt,
+            // #1578 — forward bi-temporal bounds + ingestion provenance.
+            ...(options.invalidAt ? { invalidAt: options.invalidAt } : {}),
+            ...(options.observedAt ? { observedAt: options.observedAt } : {}),
+            ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
             contentHashSource: options.category === "fact" ? dedupContent : rawContent,
             // Claim-level provenance spans (issue #1575 PR 2).
             ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
@@ -14296,7 +14322,7 @@ export class Orchestrator {
               entityRef: options.entityRef,
               structuredAttributes: options.structuredAttributes,
               createdAt: supersessionOrderingAt(options.validAt),
-              enabled: true,
+              enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
             });
           } catch (sharedSupersessionErr) {
             log.warn(
@@ -14677,7 +14703,7 @@ export class Orchestrator {
         typeof (fact as any).confidence === "number"
           ? (fact as any).confidence
           : 0.7;
-
+      const biTemporal = this.config.temporalBiTemporal && sourceContext?.validAt ? resolveFactEventTime(fact.eventTime, sourceContext.validAt) : undefined;
       // Content-hash dedup check (v6.0)
       //
       // Canonicalize pre-tagged facts before hashing (Codex P2 — issue #369).
@@ -15159,7 +15185,6 @@ export class Orchestrator {
           // back, leaving a dangling deindex with no replacement reference.
           // Child chunks intentionally do NOT carry supersedes; only the
           // parent represents the logical memory unit.
-          //
           // Canonicalize contentHashSource before writing (Thread 3 — Codex P2,
           // issue #369). If fact.content already carries an inline citation
           // (e.g. re-processed or relayed fact), strip it so contentHashSource
@@ -15187,7 +15212,8 @@ export class Orchestrator {
               intentEntityTypes: inferredIntent?.entityTypes,
               memoryKind,
               structuredAttributes: fact.structuredAttributes,
-              validAt: sourceContext?.validAt,
+              validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+              ...(biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}) } : {}),
               contentHashSource: rawChunkedContent,
               // Faithfulness gate (issue #1576).
               ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
@@ -15229,7 +15255,17 @@ export class Orchestrator {
                   intentActionType: inferredIntent?.actionType,
                   intentEntityTypes: inferredIntent?.entityTypes,
                   memoryKind,
-                  validAt: sourceContext?.validAt,
+                  validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+                  // #1578: propagate end bound + provenance to chunks (cursor bugbot).
+                  ...(biTemporal
+                    ? {
+                        observedAt: biTemporal.observedAt,
+                        eventTimeSource: biTemporal.eventTimeSource,
+                        ...(biTemporal.validUntil
+                          ? { invalidAt: biTemporal.validUntil }
+                          : {}),
+                      }
+                    : {}),
                   // Faithfulness gate (issue #1576): propagate the parent
                   // fact's verdict + enforce status so a pending_review fact
                   // is not indexed as active through its chunks (chatgpt P2).
@@ -15287,8 +15323,12 @@ export class Orchestrator {
                 newMemoryId: parentId,
                 entityRef: supersessionEntityRef,
                 structuredAttributes: fact.structuredAttributes,
-                createdAt: supersessionOrderingAt(sourceContext?.validAt),
-                enabled: this.config.temporalSupersessionEnabled,
+                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
+                // #1578 r3: an extracted end-only bound (validFrom absent) is
+                // historical, not a new authoritative state — never let it
+                // supersede a later active fact (codex P1 on :15534).
+                enabled: this.config.temporalSupersessionEnabled &&
+                  !(biTemporal && !biTemporal.validFrom),
               });
             } catch (err) {
               log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
@@ -15311,7 +15351,14 @@ export class Orchestrator {
             intentActionType: inferredIntent?.actionType,
             intentEntityTypes: inferredIntent?.entityTypes,
             memoryKind,
-            validAt: sourceContext?.validAt,
+            validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+            ...(biTemporal
+              ? {
+                  observedAt: biTemporal.observedAt,
+                  eventTimeSource: biTemporal.eventTimeSource,
+                  ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}),
+                }
+              : {}),
             source: extractionWriteSource,
             ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
             ...(fact.provenance ? { provenance: fact.provenance } : {}),
@@ -15444,13 +15491,11 @@ export class Orchestrator {
             : undefined;
 
       // Normal write (no chunking)
-      //
       // Compute the cited content once so that writeMemory and writeArtifact
       // (when verbatim artifacts are enabled) share the same citation timestamp.
       // Calling applyInlineCitation twice on the same raw content would produce
       // two different timestamps, creating duplicate citations with divergent
       // provenance metadata on the memory and artifact copies of the same fact.
-      //
       // Pass the RAW (pre-citation) fact as `contentHashSource` so the
       // fact-content hash index records the hash of the canonical fact text
       // rather than the citation-annotated variant. When inline attribution is
@@ -15483,7 +15528,8 @@ export class Orchestrator {
           intentEntityTypes: inferredIntent?.entityTypes,
           memoryKind,
           structuredAttributes: fact.structuredAttributes,
-          validAt: sourceContext?.validAt,
+          validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+          ...(biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}) } : {}),
           contentHashSource: writeCategory === "fact" ? fact.content : undefined,
           // Faithfulness gate (issue #1576).
           ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
@@ -15516,8 +15562,9 @@ export class Orchestrator {
             newMemoryId: memoryId,
             entityRef: supersessionEntityRef,
             structuredAttributes: fact.structuredAttributes,
-            createdAt: supersessionOrderingAt(sourceContext?.validAt),
-            enabled: this.config.temporalSupersessionEnabled,
+            createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
+            enabled: this.config.temporalSupersessionEnabled &&
+              !(biTemporal && !biTemporal.validFrom),
           });
         } catch (err) {
           log.warn(`temporal-supersession: unexpected error: ${err}`);
@@ -15564,7 +15611,14 @@ export class Orchestrator {
           intentActionType: inferredIntent?.actionType,
           intentEntityTypes: inferredIntent?.entityTypes,
           memoryKind,
-          validAt: sourceContext?.validAt,
+          validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+          ...(biTemporal
+            ? {
+                observedAt: biTemporal.observedAt,
+                eventTimeSource: biTemporal.eventTimeSource,
+                ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}),
+              }
+            : {}),
           source: extractionWriteSource,
           ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
           ...(fact.provenance ? { provenance: fact.provenance } : {}),

package/src/schemas.ts

@@ -166,6 +166,18 @@ export const ExtractedFactSchema = z.object({
     .describe(
       'For category "reasoning_trace" only: a stored solution chain with ordered steps, a final answer, and an optional observed outcome. Require at least two steps.',
     ),
+  eventTime: z
+    .string()
+    .optional()
+    .nullable()
+    .describe(
+      'Optional event-time expression for bi-temporal validity (#1578). An ISO date ("2025-03-01") or a relative expression verbatim ("last March", "yesterday", "since 2024", "until 2025-06-01"). Resolved against the source turn timestamp at write time — NOT wall-clock. Omit when the fact has no explicit temporal anchor.',
+    ),
+  event_time: z
+    .string()
+    .optional()
+    .nullable()
+    .describe("Alias for eventTime (snake_case). Gateway-tolerance shim (#1578)."),
 }).superRefine((value, ctx) => {
   if (value.category === "procedure" && (!Array.isArray(value.procedureSteps) || value.procedureSteps.length < 2)) {
     ctx.addIssue({

package/src/storage.ts

@@ -3580,6 +3580,7 @@ export class StorageManager {
       // or assumed from the ingestion anchor.  Both validate on serialize.
       observedAt?: string;
       eventTimeSource?: "extracted" | "assumed";
+      invalidAt?: string;
       structuredAttributes?: Record<string, string>;
       /**
        * When provided, this string is used as the source for the fact-content
@@ -3665,6 +3666,7 @@ export class StorageManager {
       valid_at: validAt,
       observedAt,
       eventTimeSource: options.eventTimeSource,
+      invalid_at: normalizeMemoryWriteTimestamp("invalidAt", options.invalidAt),
       structuredAttributes: options.structuredAttributes,
     };
     if (options.status !== undefined) {
@@ -4504,12 +4506,10 @@ export class StorageManager {
     // is disabled, missing, or unhealthy. RECALL_FALLBACK_DIRS is the single
     // source of truth derived from ALL_CATEGORY_DIRS (shared with
     // ensureDirectories() and the write routing in utils/category-dir.ts).
-    //
     // These paths resolve identically to the legacy this.factsDir /
     // this.correctionsDir / this.proceduresDir / this.reasoningTracesDir
     // getters (all `path.join(this.baseDir, <dir>)`), so the scan stays
     // namespace-aware: this.baseDir is per-namespace, set by the storage router.
-    //
     // Deliberately EXCLUDED (issue #1497 + PR #1503 review): the non-category
     // content dirs that ensureDirectories() also creates — entities/, state/,
     // artifacts/, identity/, config/ — plus the root profile.md, AND the
@@ -7359,6 +7359,12 @@ export class StorageManager {
       sources?: ProvenanceSource[];
       /** Coarse provenance tag (issue #1575 PR 2), propagated from the parent. */
       provenance?: "verified" | "unverified" | "none";
+      // Issue #1578 — bi-temporal bounds + ingestion provenance propagated from
+      // the parent fact so an independently-surfaced chunk expires at the same
+      // invalid_at window and carries the same observed-at anchor.
+      invalidAt?: string;
+      observedAt?: string;
+      eventTimeSource?: "extracted" | "assumed";
     } = {},
   ): Promise<string> {
     await this.ensureDirectories();
@@ -7368,6 +7374,8 @@ export class StorageManager {
     const conf = options.confidence ?? 0.8;
     const tier = confidenceTier(conf);
     const validAt = normalizeMemoryWriteTimestamp("validAt", options.validAt);
+    const chunkInvalidAt = normalizeMemoryWriteTimestamp("invalidAt", options.invalidAt);
+    const chunkObservedAt = normalizeMemoryWriteTimestamp("observedAt", options.observedAt);
 
     const fm: MemoryFrontmatter = {
       id,
@@ -7388,6 +7396,9 @@ export class StorageManager {
       intentEntityTypes: options.intentEntityTypes,
       memoryKind: options.memoryKind,
       valid_at: validAt,
+      invalid_at: chunkInvalidAt,
+      observedAt: chunkObservedAt,
+      eventTimeSource: options.eventTimeSource,
       ...(options.status ? { status: options.status } : {}),
       ...(options.faithfulness ? { faithfulness: options.faithfulness } : {}),
       ...(options.sources ? { sources: options.sources } : {}),

package/src/temporal-validity.test.ts

@@ -410,6 +410,39 @@ test("isValidAsOf: half-open interval [valid_at, invalid_at)", () => {
   assert.equal(isValidAsOf(fm, Date.parse("2026-01-01T00:00:00.000Z")), false);
 });
 
+test("isValidAsOf: extracted end-only bound is open-start (-inf, invalid_at] (#1578 r3)", () => {
+  // An extracted fact like "we used MongoDB until June 2025" resolves to
+  // validUntil only (no validFrom); valid_at is absent, eventTimeSource is
+  // "extracted". The interval must be open-start so historical as_of queries
+  // before ingestion still see it, rather than defaulting valid_at to created.
+  const fm = {
+    invalid_at: "2025-07-01T00:00:00.000Z",
+    created: "2025-08-15T00:00:00.000Z",
+    eventTimeSource: "extracted" as const,
+  };
+  // Well before ingestion/created — still authoritative (open start).
+  assert.equal(isValidAsOf(fm, Date.parse("2024-01-01T00:00:00.000Z")), true);
+  // Mid-window — authoritative.
+  assert.equal(isValidAsOf(fm, Date.parse("2025-06-15T00:00:00.000Z")), true);
+  // Exactly at invalid_at — NOT authoritative (exclusive upper bound).
+  assert.equal(isValidAsOf(fm, Date.parse("2025-07-01T00:00:00.000Z")), false);
+  // After invalid_at — not authoritative.
+  assert.equal(isValidAsOf(fm, Date.parse("2026-01-01T00:00:00.000Z")), false);
+});
+
+test("isValidAsOf: legacy memory without eventTimeSource keeps created fallback (#1578 r3)", () => {
+  // A legacy memory with invalid_at but no eventTimeSource must NOT become
+  // open-start — it keeps the pre-#1578 [created, invalid_at) behaviour so
+  // supersession/backfill semantics are unchanged.
+  const fm = {
+    invalid_at: "2025-12-31T00:00:00.000Z",
+    created: "2025-06-01T00:00:00.000Z",
+  };
+  // Before created — not authoritative (legacy behaviour preserved).
+  assert.equal(isValidAsOf(fm, Date.parse("2025-05-01T00:00:00.000Z")), false);
+  assert.equal(isValidAsOf(fm, Date.parse("2025-09-01T00:00:00.000Z")), true);
+});
+
 test("isValidAsOf: timezone-suffixed ISO strings compare via Date.parse, not lexicographic", () => {
   // Two strings that order differently lexicographically vs as Dates.
   // 2025-01-01T00:00:00+02:00 == 2024-12-31T22:00:00Z

package/src/temporal-validity.ts

@@ -82,11 +82,34 @@ export function effectiveInvalidAt(
 export function isValidAsOf(
   fm: Pick<
     MemoryFrontmatter,
-    "valid_at" | "invalid_at" | "created" | "supersededAt" | "status"
+    | "valid_at"
+    | "invalid_at"
+    | "created"
+    | "supersededAt"
+    | "status"
+    | "eventTimeSource"
   >,
   asOfMs: number,
 ): boolean {
   if (!Number.isFinite(asOfMs)) return true;
+  // Open-start bi-temporal interval (#1578 r3): an extracted end-only bound
+  // (eventTimeSource "extracted", no valid_at, has invalid_at) is true from
+  // the indefinite past. Without this, effectiveValidAt falls back to
+  // `created` and a historical as_of before ingestion hides a fact that was
+  // actually true up until invalid_at (chatgpt-codex thread on
+  // orchestrator.ts:15533). Gated on eventTimeSource so legacy memories
+  // (no bi-temporal provenance) keep the created-anchor fallback.
+  const explicitValidAt = fm.valid_at?.trim();
+  if (
+    (!explicitValidAt || explicitValidAt.length === 0) &&
+    fm.eventTimeSource === "extracted"
+  ) {
+    const invalidAt = effectiveInvalidAt(fm);
+    if (invalidAt !== undefined) {
+      const invalidAtMs = Date.parse(invalidAt);
+      if (Number.isFinite(invalidAtMs)) return invalidAtMs > asOfMs;
+    }
+  }
   const validAtMs = Date.parse(effectiveValidAt(fm));
   if (!Number.isFinite(validAtMs)) return false;
   if (validAtMs > asOfMs) return false;

package/src/types.ts

@@ -810,8 +810,9 @@ export 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;
   /**
@@ -2893,6 +2894,15 @@ export 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;
 }
 
 export interface ExtractedReasoningTraceStep {