@remnic/core 9.69.38 → 9.69.39

package/src/orchestration/recall-search-pipeline.ts

@@ -45,6 +45,7 @@ import {
 } from "./recall-search-prefilter.js";
 import { shouldFilterSupersededFromRecall } from "../temporal-supersession.js";
 import { isValidAsOf, isValidityExpiredNow } from "../temporal-validity.js";
+import { StateViewAnchorTracker, stateViewPacketActive } from "../recall-state-view-anchors.js";
 import type { TrustStageResultItem } from "../trust-score-stage.js";
 import type { MemoryFile, PluginConfig, QmdSearchResult, RecallPlanMode } from "../types.js";
 import {
@@ -987,17 +988,22 @@ export class RecallSearchPipelineCoordinator {
         options.recallResultLimit,
         options.prompt,
         caps,
+        // #2859: packet semantics are off under a historical asOf pin.
+        stateViewPacketActive(options.stateViewActive, options.asOfMs),
       );
       options.resultPartitionSink.partition = partition;
       return partition.appliedResults;
     }
-    return this.deps.diversifyAndLimitRecallResults(
-      "memories",
-      results,
-      options.recallResultLimit,
-      options.prompt,
-      caps,
-    );
+    return this.deps.recallRerankCoordinator
+      .diversifyRecallResultsWithHeadroom(
+        "memories",
+        results,
+        options.recallResultLimit,
+        options.prompt,
+        caps,
+        stateViewPacketActive(options.stateViewActive, options.asOfMs),
+      )
+      .appliedResults;
   }
 
   async loadSearchResultMemoryMap(
@@ -1132,10 +1138,11 @@ export class RecallSearchPipelineCoordinator {
     // when its successor SURVIVES this filter — a successor rejected by
     // the connector/lifecycle/validity/dedicated-surface/status gates
     // must never anchor (or spend a result slot on) its superseded row.
-    // Anchors are therefore collected from rows that survive the pass
-    // below; superseded rows defer admission to the post-pass fixpoint.
+    // #2859: anchors are namespace-qualified and include the successor
+    // `supersedes` back-pointer (see StateViewAnchorTracker); superseded
+    // rows defer admission to the post-pass fixpoint.
     const stateViewActive = options?.stateViewActive === true;
-    const stateViewSurvivorIds = stateViewActive ? new Set<string>() : null;
+    const stateViewAnchors = stateViewActive ? new StateViewAnchorTracker() : null;
     const stateViewDeferred: number[] = [];
     const stateViewBuilt: (QmdSearchResult | null)[] | null = stateViewActive
       ? new Array<QmdSearchResult | null>(results.length).fill(null)
@@ -1150,8 +1157,11 @@ export class RecallSearchPipelineCoordinator {
         ? {
             id: memory.frontmatter.id,
             status: memory.frontmatter.status,
+            supersedes: memory.frontmatter.supersedes,
             supersededBy: memory.frontmatter.supersededBy,
             supersededAt: memory.frontmatter.supersededAt,
+            validAt: memory.frontmatter.valid_at,
+            invalidAt: memory.frontmatter.invalid_at,
           }
         : {}),
     });
@@ -1307,10 +1317,7 @@ export class RecallSearchPipelineCoordinator {
       const builtRow = buildRecallRow(r, memory);
       if (stateViewBuilt !== null) {
         stateViewBuilt[resultIdx] = builtRow;
-        if (memory) {
-          const id = memory.frontmatter.id;
-          if (typeof id === "string" && id.length > 0) stateViewSurvivorIds!.add(id);
-        }
+        if (memory && stateViewAnchors) stateViewAnchors.admit(r.namespace, memory.frontmatter);
       }
       filtered.push(builtRow);
     }
@@ -1324,12 +1331,12 @@ export class RecallSearchPipelineCoordinator {
         progress = false;
         for (const deferredIdx of stateViewDeferred) {
           if (admitted.has(deferredIdx)) continue;
-          const deferredMemory = memoryForResult(memoryByPath, results[deferredIdx]!);
+          const deferredRow = results[deferredIdx]!;
+          const deferredMemory = memoryForResult(memoryByPath, deferredRow);
           if (!deferredMemory) continue;
-          if (stateViewSurvivorIds!.has(deferredMemory.frontmatter.supersededBy ?? "")) {
+          if (stateViewAnchors!.anchored(deferredRow.namespace, deferredMemory.frontmatter)) {
             admitted.add(deferredIdx);
-            const id = deferredMemory.frontmatter.id;
-            if (typeof id === "string" && id.length > 0) stateViewSurvivorIds!.add(id);
+            stateViewAnchors!.admit(deferredRow.namespace, deferredMemory.frontmatter);
             progress = true;
           }
         }

package/src/orchestration/recall-state-view-pipeline.test.ts

@@ -209,3 +209,92 @@ test("an anchored predecessor keeps its rank position when admitted", async () =
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("#2859 namespace fanout collision: a same-id successor in another namespace cannot anchor", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-fanout-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const A_OLD = "facts/a-old.md";
+    const B_NEW = "facts/b-new.md";
+    // ns-a: superseded predecessor whose successor id m-1 is NOT in the
+    // candidate set. ns-b: an unrelated active row that reuses id m-1.
+    // Bare-id matching (pre-#2859) admitted the ns-a predecessor on the
+    // ns-b anchor; qualified keys must not.
+    const results: QmdSearchResult[] = [
+      { ...result(B_NEW, 0.9), namespace: "ns-b" },
+      { ...result(A_OLD, 0.7), namespace: "ns-a" },
+    ];
+    const memories = new Map<string, MemoryFile>([
+      [`ns-b\0${B_NEW}`, memory(B_NEW, { id: "m-1", status: "active" })],
+      [
+        `ns-a\0${A_OLD}`,
+        memory(A_OLD, {
+          id: "m-0",
+          status: "superseded",
+          supersededBy: "m-1",
+          supersededAt: "2026-08-01",
+        }),
+      ],
+    ]);
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      safe.map((r) => r.path),
+      [B_NEW],
+      "a foreign-namespace successor must never anchor the superseded row"
+    );
+
+    // Positive control: ns-a's own m-1 present → the pair is admitted.
+    const A_NEW = "facts/a-new.md";
+    const pairResults: QmdSearchResult[] = [
+      { ...result(A_NEW, 0.9), namespace: "ns-a" },
+      { ...result(A_OLD, 0.7), namespace: "ns-a" },
+    ];
+    const pairMemories = new Map<string, MemoryFile>([
+      [`ns-a\0${A_NEW}`, memory(A_NEW, { id: "m-1", status: "active" })],
+      [`ns-a\0${A_OLD}`, memories.get(`ns-a\0${A_OLD}`)!],
+    ]);
+    const pair = coordinator.filterSearchResultsByRecallSafety(pairResults, pairMemories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      pair.map((r) => r.path),
+      [A_NEW, A_OLD],
+      "the same-namespace successor anchors the pair as before"
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("#2859 back-pointer anchors a deferred row whose supersededBy is absent", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-backptr-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const results = [result(NEW, 0.9), result(OLD, 0.7)];
+    const memories = new Map<string, MemoryFile>([
+      [NEW, memory(NEW, { id: "m-new", status: "active", supersedes: "m-old" })],
+      [
+        OLD,
+        memory(OLD, {
+          id: "m-old",
+          status: "superseded",
+          supersededAt: "2026-08-01",
+        }),
+      ],
+    ]);
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      safe.map((r) => r.path),
+      [NEW, OLD],
+      "the successor's supersedes back-pointer must admit its predecessor"
+    );
+    assert.equal(safe[1]?.supersedes, undefined, "the admitted row itself has no back-pointer");
+    assert.equal(safe[0]?.supersedes, "m-old", "the survivor carries its supersedes back-pointer");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/recall-rerank-coordinator.test.ts

@@ -567,3 +567,156 @@ test("trust rerank preserves duplicate paths owned by different namespaces (#202
   );
   assert.equal(outcome.trustByPath?.size, 2, "trust metadata must have one entry per namespaced result");
 });
+
+test("#2859 state-view cap: pairs reconcile before cap/MMR and count as one evidence packet", () => {
+  // MMR off so the ordered pool equals the input order — the packet
+  // semantics under test are then fully deterministic.
+  const config = parseConfig({ recallMmrEnabled: false });
+  const corpus = makeFakes([]);
+  const coordinator = new RecallRerankCoordinator({
+    getConfig: () => config,
+    getStorage: corpus.getStorage,
+    readQmdResultMemory: async () => null,
+  });
+  const sv = (
+    id: string,
+    score: number,
+    chain: Partial<QmdSearchResult> = {},
+  ): QmdSearchResult => ({ ...result(id, score), id, status: "active", ...chain });
+  const rows: QmdSearchResult[] = [
+    sv("p1", 0.95, { status: "superseded", supersededBy: "s1" }),
+    sv("orphan", 0.9, { status: "superseded", supersededBy: "absent" }),
+    sv("s1", 0.85),
+    sv("f1", 0.8),
+    sv("f2", 0.75),
+  ];
+  const caps = resolveCapabilities(config);
+
+  // Packet view: [p1+s1], [f1], [f2] — the orphan is reconciled away
+  // BEFORE the cap, and the admitted pair consumes a single slot.
+  const partition = coordinator.diversifyRecallResultsWithHeadroom(
+    "memories",
+    rows,
+    2,
+    undefined,
+    caps,
+    true,
+  );
+  assert.deepEqual(
+    partition.appliedResults.map((r) => r.id),
+    ["p1", "s1", "f1"],
+    "a complete pair is one packet: pred+succ plus one filler for limit 2",
+  );
+  assert.deepEqual(
+    partition.headroomResults.map((r) => r.id),
+    ["f2"],
+    "headroom is the remainder of the reconciled pool",
+  );
+
+  // The slice never splits a packet at the boundary: even with the
+  // successor ranked LAST, the pair is admitted together.
+  const splitRisk: QmdSearchResult[] = [
+    sv("p1", 0.95, { status: "superseded", supersededBy: "s1" }),
+    sv("f1", 0.9),
+    sv("f2", 0.85),
+    sv("s1", 0.8),
+  ];
+  const applied = coordinator.diversifyAndLimitRecallResults(
+    "memories",
+    splitRisk,
+    2,
+    undefined,
+    caps,
+    true,
+  );
+  assert.deepEqual(
+    applied.map((r) => r.id),
+    ["p1", "f1", "s1"],
+    "no underfill: the boundary keeps the evidence packet complete",
+  );
+
+  // Flag absent → the legacy row slice, byte-identical (zero-diff default).
+  const legacy = coordinator.diversifyAndLimitRecallResults(
+    "memories",
+    rows,
+    2,
+    undefined,
+    caps,
+  );
+  assert.deepEqual(
+    legacy.map((r) => r.id),
+    ["p1", "orphan"],
+    "without the state view the cap stays the plain top-N row slice",
+  );
+});
+
+test("#2859 packet cap after filter: a quarantined successor does not consume budget", () => {
+  const config = parseConfig({ recallMmrEnabled: false });
+  const corpus = makeFakes([]);
+  const coordinator = new RecallRerankCoordinator({
+    getConfig: () => config,
+    getStorage: corpus.getStorage,
+    readQmdResultMemory: async () => null,
+  });
+  const sv = (
+    id: string,
+    score: number,
+    chain: Partial<QmdSearchResult> = {},
+  ): QmdSearchResult => ({ ...result(id, score), id, status: "active", ...chain });
+  // Trust already removed s1. Cap-after-filter must drop the orphaned
+  // predecessor and promote the next live packet instead of returning empty.
+  const afterTrust: QmdSearchResult[] = [
+    sv("p1", 0.95, { status: "superseded", supersededBy: "s1" }),
+    sv("f1", 0.8),
+    sv("f2", 0.75),
+  ];
+  const partition = coordinator.diversifyRecallResultsWithHeadroom(
+    "memories",
+    afterTrust,
+    1,
+    undefined,
+    resolveCapabilities(config),
+    true,
+  );
+  assert.deepEqual(
+    partition.appliedResults.map((row) => row.id),
+    ["f1"],
+    "disallowed pair must not occupy the only packet slot",
+  );
+  assert.deepEqual(
+    partition.headroomResults.map((row) => row.id),
+    ["f2"],
+  );
+});
+
+test("#2859 linkless superseded status does not consume a packet slot", () => {
+  const config = parseConfig({ recallMmrEnabled: false });
+  const corpus = makeFakes([]);
+  const coordinator = new RecallRerankCoordinator({
+    getConfig: () => config,
+    getStorage: corpus.getStorage,
+    readQmdResultMemory: async () => null,
+  });
+  const sv = (
+    id: string,
+    score: number,
+    chain: Partial<QmdSearchResult> = {},
+  ): QmdSearchResult => ({ ...result(id, score), id, status: "active", ...chain });
+  const rows: QmdSearchResult[] = [
+    sv("legacy", 0.99, { status: "superseded" }),
+    sv("live", 0.5),
+  ];
+  const applied = coordinator.diversifyAndLimitRecallResults(
+    "memories",
+    rows,
+    1,
+    undefined,
+    resolveCapabilities(config),
+    true,
+  );
+  assert.deepEqual(
+    applied.map((row) => row.id),
+    ["live"],
+    "status-only superseded rows are rejected before the packet cap",
+  );
+});

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

@@ -0,0 +1,163 @@
+import { isChangeOrientedQuery, stateViewKey } from "./recall-state-view.js";
+/**
+ * State-view anchor admission (#2859).
+ *
+ * Shared namespace-qualified admission tracker for the recall safety
+ * filter (QMD/embedding/cold paths) and the recent-scan path. A deferred
+ * superseded row is admitted only when an in-set successor anchors it —
+ * through the row's own `supersededBy` or through an admitted successor's
+ * `supersedes` back-pointer. Identities are `namespace\0id`, so identical
+ * ids across namespace fanout never cross-anchor.
+ */
+import { shouldFilterSupersededFromRecall } from "./temporal-supersession.js";
+import type { MemoryFile } from "./types.js";
+
+export interface StateViewAnchorFrontmatter {
+  id?: string;
+  supersedes?: string;
+  supersededBy?: string;
+}
+
+/**
+ * #2859 — pair reconciliation and packet-counting caps apply only WITHOUT
+ * a historical pin: under asOf the validity filter legitimately orphans
+ * predecessors (see annotateStateView's asOf mode).
+ */
+export function stateViewPacketActive(stateViewActive: boolean | undefined, asOfMs: number | undefined): boolean {
+  return stateViewActive === true && !(typeof asOfMs === "number" && Number.isFinite(asOfMs));
+}
+
+/**
+ * #1952/#2859 — config flag OR per-call override, gated on change intent.
+ * Packet semantics are off under a historical asOf pin (see stateViewPacketActive).
+ */
+export function resolveRecallStateViewFlags(
+  optionFlag: boolean | undefined,
+  configFlag: boolean | undefined,
+  retrievalQuery: string,
+  asOfMs: number | undefined,
+): { stateViewActive: boolean; stateViewPacketActive: boolean } {
+  const stateViewActive =
+    (optionFlag === true || configFlag === true) && isChangeOrientedQuery(retrievalQuery);
+  return { stateViewActive, stateViewPacketActive: stateViewPacketActive(stateViewActive, asOfMs) };
+}
+
+export class StateViewAnchorTracker {
+  private readonly admitted = new Set<string>();
+  private readonly supersedesAnchors = new Set<string>();
+
+  has(namespace: string | undefined, frontmatter: StateViewAnchorFrontmatter): boolean {
+    const id = frontmatter.id;
+    return typeof id === "string" && id.length > 0 ? this.admitted.has(stateViewKey(namespace, id)) : false;
+  }
+
+  /**
+   * Register a row as admitted (a survivor of every gate, or a deferred
+   * row whose successor anchored it). The row's `supersedes` back-pointer
+   * then anchors its own predecessor.
+   */
+  admit(namespace: string | undefined, frontmatter: StateViewAnchorFrontmatter): void {
+    const id = frontmatter.id;
+    if (typeof id !== "string" || id.length === 0) return;
+    this.admitted.add(stateViewKey(namespace, id));
+    if (frontmatter.supersedes) {
+      this.supersedesAnchors.add(stateViewKey(namespace, frontmatter.supersedes));
+    }
+  }
+
+  /** True when an admitted successor anchors this superseded row. */
+  anchored(namespace: string | undefined, frontmatter: StateViewAnchorFrontmatter): boolean {
+    const id = frontmatter.id;
+    if (typeof id !== "string" || id.length === 0) return false;
+    const successorId = frontmatter.supersededBy;
+    return (
+      (typeof successorId === "string" && this.admitted.has(stateViewKey(namespace, successorId))) ||
+      this.supersedesAnchors.has(stateViewKey(namespace, id))
+    );
+  }
+}
+
+export interface StateViewRecentAdmissionDeps {
+  namespaceOf: (path: string) => string;
+  isExcluded: (path: string) => boolean;
+  supersessionOptions: { enabled: boolean; includeInRecall: boolean };
+}
+
+/**
+ * #2859 — recent-scan admission: seed the tracker with every memory that
+ * survives the supersession gate, then admit superseded rows anchored by
+ * an in-set successor (fixpoint — an admitted link anchors the next).
+ */
+export function admitStateViewRecentMemories(
+  memories: readonly MemoryFile[],
+  deps: StateViewRecentAdmissionDeps
+): StateViewAnchorTracker {
+  const tracker = new StateViewAnchorTracker();
+  for (const m of memories) {
+    if (deps.isExcluded(m.path)) continue;
+    if (m.frontmatter.status === "superseded") continue;
+    if (shouldFilterSupersededFromRecall(m.frontmatter, deps.supersessionOptions)) continue;
+    tracker.admit(deps.namespaceOf(m.path), m.frontmatter);
+  }
+  for (let progress = true; progress; ) {
+    progress = false;
+    for (const m of memories) {
+      const namespace = deps.namespaceOf(m.path);
+      if (tracker.has(namespace, m.frontmatter)) continue;
+      if (deps.isExcluded(m.path)) continue;
+      if (m.frontmatter.status !== "superseded") continue;
+      if (!shouldFilterSupersededFromRecall(m.frontmatter, deps.supersessionOptions)) continue;
+      if (tracker.anchored(namespace, m.frontmatter)) {
+        tracker.admit(namespace, m.frontmatter);
+        progress = true;
+      }
+    }
+  }
+  return tracker;
+}
+
+export interface RecentScanMemoryFilterDeps extends StateViewRecentAdmissionDeps {
+  stateViewActive: boolean;
+  asOfMs: number | undefined;
+}
+
+/**
+ * Recent-scan admission for the fallback path.
+ *
+ * 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 (fixpoint below).
+ * 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.
+ * #2859: namespace-qualified anchors with the supersedes
+ * back-pointer — mirrors the safety-filter fixpoint.
+ */
+export function filterRecentScanMemories(
+  memories: readonly MemoryFile[],
+  deps: RecentScanMemoryFilterDeps,
+): MemoryFile[] {
+  const asOfActive = typeof deps.asOfMs === "number" && Number.isFinite(deps.asOfMs);
+  const stateViewAnchors =
+    deps.stateViewActive && !asOfActive ? admitStateViewRecentMemories(memories, deps) : null;
+  return memories.filter((m) => {
+    if (deps.isExcluded(m.path)) return false;
+    const status = m.frontmatter.status;
+    if (!status || status === "active") return true;
+    if (status === "superseded") {
+      if (asOfActive) return true;
+      if (stateViewAnchors?.has(deps.namespaceOf(m.path), m.frontmatter)) {
+        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, deps.supersessionOptions);
+    }
+    // Other non-active statuses (archived, retired, etc.) are
+    // excluded from the recent-scan path by default.
+    return false;
+  });
+}

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

@@ -9,8 +9,9 @@ import {
   annotateStateView,
   isChangeOrientedQuery,
   parseRecallStateViews,
-  resultStateViewId,
+  resultStateViewKey,
   shouldWidenSuperseded,
+  stateViewKey,
   type StateViewResult,
 } from "./recall-state-view.js";
 
@@ -45,21 +46,34 @@ export function widenRecallStateViews<T extends StateViewResult>(
   if (!enabled || !isChangeOrientedQuery(query)) return results;
   const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
 
+  // #2859: matches are namespace-qualified, and a successor's `supersedes`
+  // back-pointer anchors its predecessor even when the predecessor's own
+  // `supersededBy` is absent.
   const candidateIds = new Set<string>();
+  const supersedesAnchors = new Set<string>();
   for (const result of results) {
-    const id = resultStateViewId(result);
-    if (id) candidateIds.add(id);
+    const key = resultStateViewKey(result);
+    if (!key) continue;
+    candidateIds.add(key);
+    if (result.supersedes) {
+      supersedesAnchors.add(stateViewKey(result.namespace, result.supersedes));
+    }
   }
 
   const seen = new Set(candidateIds);
   const extra: T[] = [];
   if (!asOfActive) {
     for (const item of pool) {
-      const id = resultStateViewId(item);
-      if (!id || seen.has(id)) continue;
-      if (!shouldWidenSuperseded(item.supersededBy, candidateIds)) continue;
+      const key = resultStateViewKey(item);
+      if (!key || seen.has(key)) continue;
+      const successorKey = item.supersededBy
+        ? stateViewKey(item.namespace, item.supersededBy)
+        : undefined;
+      if (!shouldWidenSuperseded(successorKey, candidateIds) && !supersedesAnchors.has(key)) {
+        continue;
+      }
       extra.push(item);
-      seen.add(id);
+      seen.add(key);
     }
   }
 

package/src/recall-state-view-zero-diff.test.ts

@@ -143,6 +143,7 @@ type LiveFixtureRow = StateViewLine & {
   score: number;
   supersededAt?: string;
   supersededBy?: string;
+  supersedes?: string;
 };
 
 // Review round 2: the earlier follow-up ran `injectStateViewLines`, which has
@@ -176,6 +177,7 @@ function liveEntries(
     stateLabel: result.stateLabel,
     ...(result.supersededAt ? { supersededAt: result.supersededAt } : {}),
     ...(result.supersededBy ? { supersededBy: result.supersededBy } : {}),
+    ...(result.supersedes ? { supersedes: result.supersedes } : {}),
   }));
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- test fixture
   const widened = applyRecallStateViews(qmdResults as any[], query, config);
@@ -289,3 +291,31 @@ test("the live route still renders every current entry it was given", () => {
   assert.match(entries[0]!, /the API limit is 100\/min/);
   assert.match(entries[1]!, /we chose SQLite/);
 });
+
+test("the enabled route renders history for a supersedes-only pair", () => {
+  const results = [
+    {
+      memoryId: "m-1",
+      text: "we use PostgreSQL",
+      stateLabel: "current" as const,
+      score: 0.9,
+      supersedes: "m-0",
+    },
+    {
+      memoryId: "m-0",
+      text: "we use SQLite",
+      stateLabel: "current" as const,
+      supersededAt: "2026-08-01",
+      score: 0.7,
+    },
+  ];
+  const query = "what changed about the database?";
+  const enabled = liveEntries(results, query, true);
+  const old = enabled.entries.find((entry) => entry.includes("we use SQLite"));
+  assert.equal(
+    enabled.widened.find((row) => row.id === "m-0")?.stateLabel,
+    "historical",
+  );
+  assert.ok(old, "enabled render includes the predecessor");
+  assert.match(old!, /\[superseded 2026-08-01 by m-1\] we use SQLite/);
+});