@remnic/core 9.69.33 → 9.69.35

package/src/recall-disclosure.test.ts

@@ -226,3 +226,23 @@ test("MCP engram.recall inputSchema advertises the `disclosure` enum", () => {
   assert.ok(props && "disclosure" in props, "engram.recall inputSchema must declare 'disclosure'");
   assert.deepStrictEqual(props?.disclosure?.enum, ["chunk", "section", "raw"]);
 });
+
+test("recallRequestSchema and MCP inputSchema carry the #1952 stateView boolean", () => {
+  const base = { query: "when did the job change?", sessionKey: "s" };
+  const ok = recallRequestSchema.safeParse({ ...base, stateView: true });
+  assert.equal(ok.success, true, "stateView: true must validate");
+  assert.equal(ok.success && ok.data.stateView, true);
+  const off = recallRequestSchema.safeParse({ ...base, stateView: false });
+  assert.equal(off.success && off.data.stateView, false);
+  const absent = recallRequestSchema.safeParse(base);
+  assert.equal(absent.success && absent.data.stateView, undefined);
+  const bad = recallRequestSchema.safeParse({ ...base, stateView: "yes" });
+  assert.equal(bad.success, false, "non-boolean stateView must be rejected");
+
+  const { service } = makeMcpRecallSpyService();
+  const server = new EngramMcpServer(service);
+  const tools = (server as unknown as { tools: Array<{ name: string; inputSchema: { properties?: Record<string, unknown> } }> }).tools;
+  const recallTool = tools.find((t) => t.name === "engram.recall");
+  const props = recallTool?.inputSchema?.properties as Record<string, { type?: string }> | undefined;
+  assert.ok(props && props.stateView?.type === "boolean", "engram.recall inputSchema must declare stateView: boolean");
+});

package/src/recall-state-view-admission.ts

@@ -0,0 +1,114 @@
+/**
+ * Recall-internal state-view admission (issue #1952).
+ *
+ * Flag resolution, recent-scan successor-anchor admission, and the X-ray
+ * inject-seam annotation live here so recall-internal.ts stays under its
+ * ratchet ceiling. Callers keep one-line sites.
+ */
+
+import { isGenericRecallExcludedPath, type GenericRecallPathPolicy } from "./orchestration/generic-recall-paths.js";
+import { isChangeOrientedQuery, type StateViewResult } from "./recall-state-view.js";
+import { applyRecallStateViews } from "./recall-state-view-wire.js";
+import { shouldFilterSupersededFromRecall } from "./temporal-supersession.js";
+import type { MemoryFile } from "./types.js";
+
+/** Config flag OR per-call override, gated on change intent; computed once for all branches. */
+export function resolveRecallStateViewActive(
+  options: { stateView?: boolean },
+  config: { recallStateViews?: boolean },
+  query: string,
+): boolean {
+  return (options.stateView === true || config.recallStateViews === true) && isChangeOrientedQuery(query);
+}
+
+/**
+ * Superseded-status filtering delegates to shouldFilterSupersededFromRecall
+ * so recent-scan and the QMD safety filter share semantics (kill switch,
+ * audit mode, PR #402).
+ *
+ * #1952: an active state view admits a superseded memory whose successor
+ * ALSO survives this admission filter — a successor excluded by status or
+ * path can never anchor (mirrors the filterSearchResultsByRecallSafety
+ * fixpoint). Anchors grow through admitted chain links, so iterate to a
+ * fixpoint.
+ *
+ * PR #713: when `as_of` is active, pass superseded candidates through here
+ * — boostSearchResults's `[valid_at, invalid_at)` evaluation is the
+ * authoritative historical gate. Other non-active statuses stay excluded.
+ */
+export function filterRecentScanMemoriesForStateView(
+  memories: readonly MemoryFile[],
+  config: GenericRecallPathPolicy,
+  supersessionOptions: { enabled: boolean; includeInRecall: boolean },
+  stateViewActive: boolean,
+  asOfMs: number | undefined,
+): MemoryFile[] {
+  const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
+  let stateViewAdmittedIds: Set<string> | null = null;
+  if (stateViewActive && !asOfActive) {
+    stateViewAdmittedIds = new Set(
+      memories
+        .filter(
+          (m) =>
+            !isGenericRecallExcludedPath(m.path, config) &&
+            m.frontmatter.status !== "superseded" &&
+            !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions),
+        )
+        .map((m) => m.frontmatter.id)
+        .filter((id): id is string => typeof id === "string" && id.length > 0),
+    );
+    for (let progress = true; progress; ) {
+      progress = false;
+      for (const m of memories) {
+        const id = m.frontmatter.id;
+        if (typeof id !== "string" || id.length === 0) continue;
+        if (stateViewAdmittedIds.has(id)) continue;
+        if (isGenericRecallExcludedPath(m.path, config)) continue;
+        if (m.frontmatter.status !== "superseded") continue;
+        if (!shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions)) continue;
+        if (stateViewAdmittedIds.has(m.frontmatter.supersededBy ?? "")) {
+          stateViewAdmittedIds.add(id);
+          progress = true;
+        }
+      }
+    }
+  }
+  return memories.filter((m) => {
+    if (isGenericRecallExcludedPath(m.path, config)) return false;
+    const status = m.frontmatter.status;
+    if (!status || status === "active") return true;
+    if (status === "superseded") {
+      if (asOfActive) return true;
+      const id = m.frontmatter.id;
+      if (
+        stateViewAdmittedIds !== null &&
+        typeof id === "string" &&
+        stateViewAdmittedIds.has(id)
+      ) {
+        return true;
+      }
+      // Include superseded memory only if the canonical gate says
+      // NOT to filter it (kill switch off or audit mode on).
+      return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
+    }
+    // Other non-active statuses (archived, retired, etc.) are
+    // excluded from the recent-scan path by default.
+    return false;
+  });
+}
+
+/** Label the captured X-ray branch through the same inject-seam annotator. */
+export function indexStateViewAnnotatedResults<T extends StateViewResult & { path: string; namespace?: string }>(
+  results: T[],
+  query: string,
+  config: unknown,
+  stateViewActive?: boolean,
+  asOfMs?: number,
+): Map<string, T> {
+  return new Map(
+    applyRecallStateViews(results, query, config, stateViewActive, asOfMs).map((xr) => [
+      `${xr.namespace ?? ""}\0${xr.path}`,
+      xr,
+    ]),
+  );
+}

package/src/recall-state-view-asof.test.ts

@@ -0,0 +1,176 @@
+/**
+ * recall-state-view-asof.test.ts — issue #1952 historical-pinned state views.
+ *
+ * Proves an `asOf` recall before the successor's validity keeps the
+ * predecessor: the inject seam must not discard a predecessor merely
+ * because its successor is absent under the same pin, and a valid asOf
+ * result is never emptied. Pinned after the successor's validity, the
+ * same corpus returns the successor instead.
+ *
+ * Pre-fix bug: publishRecallResults annotated without the pin, so the
+ * "superseded never appears without its successor" contract dropped the
+ * predecessor at the seam and the valid historical snapshot rendered
+ * empty.
+ */
+
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import type { PluginConfig } from "./types.js";
+
+const QUERY = "when did the job title change";
+
+async function makeOrchestrator(
+  overrides: Partial<PluginConfig> = {},
+): Promise<{ orchestrator: Orchestrator; memoryDir: string }> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-asof-"));
+  const config = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: false,
+    embeddingFallbackEnabled: false,
+    multiGraphMemoryEnabled: false,
+    entityGraphEnabled: false,
+    timeGraphEnabled: false,
+    causalGraphEnabled: false,
+    extractionJudgeEnabled: false,
+    temporalSupersessionEnabled: true,
+    temporalSupersessionIncludeInRecall: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+    initGateTimeoutMs: 200,
+    ...overrides,
+  });
+  return { orchestrator: new Orchestrator(config), memoryDir };
+}
+
+/**
+ * Write the supersession pair with explicit validity windows: the
+ * successor (`sv-new`) becomes valid one hour after the pin, and the
+ * predecessor (`sv-old`) is superseded at that same instant. At the pin
+ * the predecessor is the live fact; the successor is not yet valid.
+ */
+async function writeTimedPair(memoryDir: string): Promise<{ pin: string; afterFlip: string }> {
+  const today = new Date().toISOString().slice(0, 10);
+  const factsDir = path.join(memoryDir, "facts", today);
+  await mkdir(factsDir, { recursive: true });
+  const now = Date.now();
+  const pin = new Date(now + 60_000).toISOString();
+  const flipAt = new Date(now + 3_600_000).toISOString();
+  const afterFlip = new Date(now + 3_660_000).toISOString();
+  const successor = [
+    "---",
+    "id: sv-new",
+    "category: fact",
+    `created: ${new Date(now).toISOString()}`,
+    `updated: ${new Date(now).toISOString()}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    "status: active",
+    `validAt: ${flipAt}`,
+    "---",
+    "",
+    "Current job title: Staff Engineer.",
+    "",
+  ];
+  const predecessor = [
+    "---",
+    "id: sv-old",
+    "category: fact",
+    `created: ${new Date(now).toISOString()}`,
+    `updated: ${new Date(now).toISOString()}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    "status: superseded",
+    "supersededBy: sv-new",
+    `supersededAt: ${flipAt}`,
+    "---",
+    "",
+    "Job title history: the job title used to be Senior Engineer.",
+    "",
+  ];
+  await writeFile(
+    path.join(factsDir, "sv-new.md"),
+    `${successor.join("\n")}\n`,
+    "utf-8",
+  );
+  await writeFile(
+    path.join(factsDir, "sv-old.md"),
+    `${predecessor.join("\n")}\n`,
+    "utf-8",
+  );
+  return { pin, afterFlip };
+}
+
+test("asOf before the successor's validity keeps the predecessor and never empties the snapshot (#1952)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    const { pin } = await writeTimedPair(memoryDir);
+    const out = await orchestrator.recall(QUERY, "sess-sv-asof-before", {
+      stateView: true,
+      asOf: pin,
+      xrayCapture: true,
+    });
+    assert.ok(out.length > 0, "a valid asOf result must never be emptied");
+    assert.ok(
+      out.includes("Senior Engineer"),
+      `the pin-valid predecessor must survive the state-view seam, got:\n${out}`,
+    );
+    assert.ok(
+      !out.includes("Staff Engineer"),
+      `the successor is not yet valid at the pin and must stay filtered, got:\n${out}`,
+    );
+    assert.ok(
+      !out.includes("[superseded "),
+      `a predecessor current at the snapshot renders unlabeled, got:\n${out}`,
+    );
+    const snapshot = orchestrator.getLastXraySnapshot();
+    assert.ok(snapshot, "X-ray snapshot must be captured");
+    const labels = (snapshot!.results ?? [])
+      .map((r) => r.stateView)
+      .filter((label) => label !== undefined);
+    assert.deepEqual(
+      labels,
+      ["current"],
+      `X-ray must label the pin-valid predecessor current-at-snapshot, got: ${JSON.stringify(labels)}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("asOf after the successor's validity returns the successor instead (#1952)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    const { afterFlip } = await writeTimedPair(memoryDir);
+    const out = await orchestrator.recall(QUERY, "sess-sv-asof-after", {
+      stateView: true,
+      asOf: afterFlip,
+    });
+    assert.ok(
+      out.includes("Staff Engineer"),
+      `after the flip the successor is the valid fact, got:\n${out}`,
+    );
+    assert.ok(
+      !out.includes("Senior Engineer"),
+      `after the flip the predecessor's interval has ended, got:\n${out}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/recall-state-view-call.test.ts

@@ -0,0 +1,175 @@
+/**
+ * recall-state-view-call.test.ts — issue #1952 per-call wiring.
+ *
+ * Proves the per-call `stateView` boolean carries through the FINAL
+ * annotation (publish inject seam + X-ray capture) on a fallback recall
+ * path, even when the global `recallStateViews` flag is false. QMD and
+ * embedding fallback are disabled so recall settles on the recent-scan
+ * branch — the same "every fallback path" guarantee the trust-map
+ * parity tests pin (#1577).
+ *
+ * Pre-fix bug: recallInternal computed an effective per-request flag
+ * (options.stateView OR config) for admission, but publishRecallResults
+ * and the X-ray annotator reread `config.recallStateViews` directly, so
+ * per-call true + global false admitted the superseded row upstream and
+ * then dropped its label/prefix at the inject seam.
+ */
+
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import type { PluginConfig } from "./types.js";
+
+const QUERY = "when did the job title change";
+const PREFIX = "[superseded 2026-08-01 by sv-new]";
+
+async function makeOrchestrator(
+  overrides: Partial<PluginConfig> = {},
+): Promise<{ orchestrator: Orchestrator; memoryDir: string }> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-call-"));
+  const config = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: false,
+    embeddingFallbackEnabled: false,
+    multiGraphMemoryEnabled: false,
+    entityGraphEnabled: false,
+    timeGraphEnabled: false,
+    causalGraphEnabled: false,
+    extractionJudgeEnabled: false,
+    temporalSupersessionEnabled: true,
+    temporalSupersessionIncludeInRecall: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+    initGateTimeoutMs: 200,
+    ...overrides,
+  });
+  return { orchestrator: new Orchestrator(config), memoryDir };
+}
+
+/**
+ * Write the supersession pair directly into the facts dir: an active
+ * successor (sv-new) and a superseded predecessor (sv-old) pointing at
+ * it. temporalSupersession is ON with includeInRecall=false, so sv-old
+ * reaches the candidate pool ONLY when a state view is active.
+ */
+async function writePair(memoryDir: string): Promise<void> {
+  const today = new Date().toISOString().slice(0, 10);
+  const factsDir = path.join(memoryDir, "facts", today);
+  await mkdir(factsDir, { recursive: true });
+  const now = new Date().toISOString();
+  const successor = [
+    "---",
+    "id: sv-new",
+    "category: fact",
+    `created: ${now}`,
+    `updated: ${now}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    "status: active",
+    "---",
+    "",
+    "Current job title: Staff Engineer.",
+    "",
+  ];
+  const predecessor = [
+    "---",
+    "id: sv-old",
+    "category: fact",
+    `created: ${now}`,
+    `updated: ${now}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    "status: superseded",
+    "supersededBy: sv-new",
+    "supersededAt: 2026-08-01",
+    "---",
+    "",
+    "Job title history: the job title used to be Senior Engineer.",
+    "",
+  ];
+  await writeFile(
+    path.join(factsDir, "sv-new.md"),
+    `${successor.join("\n")}\n`,
+    "utf-8",
+  );
+  await writeFile(
+    path.join(factsDir, "sv-old.md"),
+    `${predecessor.join("\n")}\n`,
+    "utf-8",
+  );
+}
+
+test("per-call stateView=true labels the fallback-path injection and X-ray even when the global flag is false (#1952)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(QUERY, "sess-sv-call-true", {
+      stateView: true,
+      xrayCapture: true,
+    });
+    assert.ok(
+      out.includes(PREFIX),
+      `per-call true + global false must render the historical prefix, got:\n${out}`,
+    );
+    const snapshot = orchestrator.getLastXraySnapshot();
+    assert.ok(snapshot, "X-ray snapshot must be captured");
+    const labels = (snapshot!.results ?? [])
+      .map((r) => r.stateView)
+      .filter((label) => label !== undefined);
+    assert.ok(
+      labels.includes("historical") && labels.includes("current"),
+      `X-ray must carry stateView labels through the per-call flag, got: ${JSON.stringify(labels)}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("precedence is OR: per-call stateView=false never disables a global recallStateViews=true (#1952)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator({
+    recallStateViews: true,
+  });
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(QUERY, "sess-sv-call-false", {
+      stateView: false,
+    });
+    assert.ok(
+      out.includes(PREFIX),
+      `call false + global true must still label (documented OR semantics), got:\n${out}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("default stays zero-diff: no flags, no labels, no prefix (#1952)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(QUERY, "sess-sv-call-off");
+    assert.ok(
+      !out.includes("[superseded "),
+      `no flags must keep the injection byte-identical (superseded row stays filtered), got:\n${out}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/recall-state-view-config.test.ts

@@ -0,0 +1,16 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+
+test("parseConfig: recallStateViews defaults false and honors exact disable values", () => {
+  const base = { memoryDir: "/tmp/remnic-sv-config-test" };
+  assert.equal(parseConfig(base).recallStateViews, false, "absent → false");
+  assert.equal(parseConfig({ ...base, recallStateViews: false }).recallStateViews, false);
+  assert.equal(parseConfig({ ...base, recallStateViews: 0 }).recallStateViews, false, "0 disables");
+  assert.equal(parseConfig({ ...base, recallStateViews: "false" }).recallStateViews, false, '"false" disables');
+  assert.equal(parseConfig({ ...base, recallStateViews: "0" }).recallStateViews, false, '"0" disables');
+  assert.equal(parseConfig({ ...base, recallStateViews: true }).recallStateViews, true);
+  assert.equal(parseConfig({ ...base, recallStateViews: 1 }).recallStateViews, true);
+  assert.equal(parseConfig({ ...base, recallStateViews: "true" }).recallStateViews, true, "CLI string 'true' enables");
+});

package/src/recall-state-view-widen.test.ts

@@ -64,3 +64,73 @@ test("superseded without successor is dropped", () => {
   ]);
   assert.deepEqual(applyRecallStateViews([ORPHAN], CHANGE, ON), []);
 });
+
+test("#1952 per-call override: stateViewActive=true labels even when config is false", () => {
+  const OFF = { recallStateViews: false } as const;
+  const labeled = widenRecallStateViews([CURRENT], CHANGE, OFF, [HISTORICAL], true);
+  assert.deepEqual(
+    labeled.map((row) => [row.id, row.stateLabel]),
+    [
+      ["new-job", "current"],
+      ["old-job", "historical"],
+    ],
+    "per-call true must widen and label against a global false",
+  );
+  assert.deepEqual(
+    applyRecallStateViews([CURRENT, HISTORICAL], CHANGE, OFF, true).map((row) => [
+      row.id,
+      row.stateLabel,
+    ]),
+    [
+      ["new-job", "current"],
+      ["old-job", "historical"],
+    ],
+    "inject seam must label on the threaded flag, not the config reread",
+  );
+});
+
+test("#1952 precedence is OR: per-call false never disables a global true", () => {
+  const input = [CURRENT];
+  const labeled = widenRecallStateViews(input, CHANGE, ON, [HISTORICAL], false);
+  assert.equal(labeled.length, 2, "config true + call false still widens");
+  assert.equal(labeled[1]?.stateLabel, "historical");
+});
+
+test("#1952 override true on a non-change query stays identity (change gate applies)", () => {
+  const input = [CURRENT, HISTORICAL];
+  assert.equal(widenRecallStateViews(input, NON_CHANGE, { recallStateViews: false }, [], true), input);
+  assert.equal(applyRecallStateViews(input, NON_CHANGE, { recallStateViews: false }, true), input);
+  assert.equal(input[0]?.stateLabel, undefined);
+});
+
+test("asOf mode keeps a pin-filtered predecessor and never widens the pool (#1952)", () => {
+  const pin = Date.parse("2026-08-05T00:00:00.000Z");
+  const predecessor = fact("old-job", {
+    status: "superseded",
+    supersededBy: "new-job",
+    supersededAt: "2026-08-10T00:00:00.000Z",
+  });
+  const labeled = widenRecallStateViews(
+    [predecessor],
+    CHANGE,
+    ON,
+    [CURRENT, HISTORICAL],
+    undefined,
+    pin,
+  );
+  assert.equal(labeled.length, 1, "pool rows must not enter a historical snapshot");
+  assert.equal(labeled[0]?.id, "old-job");
+  assert.equal(labeled[0]?.stateLabel, "current");
+});
+
+test("asOf mode threads through applyRecallStateViews without emptying the result (#1952)", () => {
+  const pin = Date.parse("2026-08-05T00:00:00.000Z");
+  const predecessor = fact("old-job", {
+    status: "superseded",
+    supersededBy: "new-job",
+    supersededAt: "2026-08-10T00:00:00.000Z",
+  });
+  const labeled = applyRecallStateViews([predecessor], CHANGE, ON, true, pin);
+  assert.equal(labeled.length, 1);
+  assert.equal(labeled[0]?.stateLabel, "current");
+});

package/src/recall-state-view-widen.ts

@@ -19,13 +19,31 @@ export function widenRecallStateViews<T extends StateViewResult>(
   query: string,
   config: unknown,
   pool: readonly T[] = [],
+  /**
+   * #1952 — per-request effective flag (per-call `stateView` OR config,
+   * gated on change intent), computed once at recall entry and threaded
+   * through. When `true` it wins over the config read so a per-call
+   * override survives a global `false` at the inject seam. Callers that
+   * omit it keep the legacy config-only behavior.
+   */
+  stateViewActive?: boolean,
+  /**
+   * #1952 — historical recall pin (epoch ms). When set, the pool is
+   * never widened (pool rows did not survive the asOf validity filter,
+   * so pulling a not-yet-valid successor into a historical snapshot
+   * would be wrong) and annotation runs in asOf mode: a predecessor is
+   * kept and labeled relative to the snapshot without requiring its
+   * successor.
+   */
+  asOfMs?: number,
 ): T[] {
   const raw =
     typeof config === "object" && config !== null && "recallStateViews" in config
       ? config.recallStateViews
       : undefined;
-  const enabled = parseRecallStateViews(raw);
+  const enabled = stateViewActive === true || parseRecallStateViews(raw);
   if (!enabled || !isChangeOrientedQuery(query)) return results;
+  const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
 
   const candidateIds = new Set<string>();
   for (const result of results) {
@@ -35,15 +53,18 @@ export function widenRecallStateViews<T extends StateViewResult>(
 
   const seen = new Set(candidateIds);
   const extra: T[] = [];
-  for (const item of pool) {
-    const id = resultStateViewId(item);
-    if (!id || seen.has(id)) continue;
-    if (!shouldWidenSuperseded(item.supersededBy, candidateIds)) continue;
-    extra.push(item);
-    seen.add(id);
+  if (!asOfActive) {
+    for (const item of pool) {
+      const id = resultStateViewId(item);
+      if (!id || seen.has(id)) continue;
+      if (!shouldWidenSuperseded(item.supersededBy, candidateIds)) continue;
+      extra.push(item);
+      seen.add(id);
+    }
   }
 
   return annotateStateView(extra.length > 0 ? results.concat(extra) : results, query, [], {
     enabled: true,
+    ...(asOfActive ? { asOfMs } : {}),
   });
 }

package/src/recall-state-view-wire.ts

@@ -13,6 +13,8 @@ export function applyRecallStateViews<T extends StateViewResult>(
   results: T[],
   query: string,
   config: unknown,
+  stateViewActive?: boolean,
+  asOfMs?: number,
 ): T[] {
-  return widenRecallStateViews(results, query, config);
+  return widenRecallStateViews(results, query, config, [], stateViewActive, asOfMs);
 }