@remnic/core 9.69.38 → 9.69.40

package/src/recall-state-view-cron-intent.test.ts

@@ -0,0 +1,268 @@
+/**
+ * recall-state-view-cron-intent.test.ts — issue #2893.
+ *
+ * Cron recall policy (buildRecallQueryPolicy) normalizes the retrieval
+ * query: standard prompts are truncated at maxChars, instruction-heavy
+ * prompts are compacted with stop-word removal ("when", "before",
+ * "after") plus a token cap. Either path can erase the change-intent
+ * signal that gates state views. These regressions pin:
+ *
+ * 1. Change intent is classified from the ORIGINAL prompt at the recall
+ *    entry seam, so a long cron prompt whose intent phrase lies beyond
+ *    the normalization cutoff still activates state views.
+ * 2. Only the validated boolean flows downstream: retrieval keeps the
+ *    normalized query, and the inject seam does not re-classify intent
+ *    against it when the per-request flag is threaded.
+ * 3. Negative controls: non-change prompts, flag-less calls, and the
+ *    legacy config-only path (no threaded flag) keep prior behavior.
+ */
+
+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 { buildRecallQueryPolicy, type RecallQueryPolicyConfig } from "./recall-query-policy.js";
+import { resolveRecallStateViewActive } from "./recall-state-view-admission.js";
+import { annotateStateView, isChangeOrientedQuery, type StateViewResult } from "./recall-state-view.js";
+import { widenRecallStateViews } from "./recall-state-view-widen.js";
+import { applyRecallStateViews } from "./recall-state-view-wire.js";
+import { Orchestrator } from "./orchestrator.js";
+import type { PluginConfig } from "./types.js";
+
+// No change-intent tokens; comfortably longer than the 120-char cutoff.
+const FILLER =
+  "daily ops digest for platform delivery covering deploy notes on-call handoffs release cadence sprint board columns quota dashboards vendor invoices and rotating shift owners";
+const LONG_CHANGE = `${FILLER} plus tell me when did the job title change`;
+const LONG_NON_CHANGE = `${FILLER} plus confirm the current job title roster`;
+const CRON_KEY = "sess:cron:nightly-digest";
+const POLICY_CFG: RecallQueryPolicyConfig = {
+  cronRecallPolicyEnabled: true,
+  cronRecallNormalizedQueryMaxChars: 120,
+  cronRecallInstructionHeavyTokenCap: 8,
+  cronConversationRecallMode: "auto",
+};
+
+test("fixtures: filler carries no intent and outruns the cutoff", () => {
+  assert.ok(FILLER.length >= 120, `filler must exceed maxChars, got ${FILLER.length}`);
+  assert.equal(isChangeOrientedQuery(FILLER), false);
+  assert.equal(isChangeOrientedQuery(LONG_CHANGE), true);
+  assert.equal(isChangeOrientedQuery(LONG_NON_CHANGE), false);
+});
+
+test("standard cron truncation erases intent from the normalized query", () => {
+  const policy = buildRecallQueryPolicy(LONG_CHANGE, CRON_KEY, POLICY_CFG);
+  assert.equal(policy.promptShape, "standard");
+  assert.equal(isChangeOrientedQuery(policy.retrievalQuery), false);
+  assert.ok(!policy.retrievalQuery.includes("when did"));
+});
+
+test("instruction-heavy compaction erases intent from the normalized query", () => {
+  const lines = [
+    "GOAL: nightly infrastructure digest",
+    "OUTPUT FORMAT: markdown summary",
+    "TONE RULES: concise operator voice",
+    "GROUNDING RULES: cite memory ids",
+  ];
+  for (let i = 0; i < 10; i += 1) lines.push(`- item-${i} inventory cluster-${i}`);
+  for (let i = 0; i < 14; i += 1) lines.push(`vendor ledger panel review segment ${i}`);
+  lines.push("finally answer when did the job title change");
+  const prompt = lines.join("\n");
+
+  const policy = buildRecallQueryPolicy(prompt, CRON_KEY, POLICY_CFG);
+  assert.equal(policy.promptShape, "instruction_heavy");
+  assert.equal(isChangeOrientedQuery(prompt), true);
+  assert.equal(isChangeOrientedQuery(policy.retrievalQuery), false);
+  assert.ok(!policy.retrievalQuery.includes("change"));
+});
+
+test("entry seam classifies the ORIGINAL prompt, not the normalized query (#2893)", () => {
+  const policy = buildRecallQueryPolicy(LONG_CHANGE, CRON_KEY, POLICY_CFG);
+  // Pre-fix shape: classifying the normalized query disables the view.
+  assert.equal(resolveRecallStateViewActive({ stateView: true }, {}, policy.retrievalQuery), false);
+  // Post-fix contract: the original prompt carries the signal.
+  assert.equal(resolveRecallStateViewActive({ stateView: true }, { recallStateViews: false }, LONG_CHANGE), true);
+  assert.equal(resolveRecallStateViewActive({}, { recallStateViews: true }, LONG_CHANGE), true);
+});
+
+test("negative controls: non-change prompts and flag-less calls stay inactive", () => {
+  assert.equal(
+    resolveRecallStateViewActive({ stateView: true }, { recallStateViews: true }, LONG_NON_CHANGE),
+    false,
+  );
+  assert.equal(resolveRecallStateViewActive({}, {}, LONG_CHANGE), false);
+  assert.equal(
+    resolveRecallStateViewActive({ stateView: false }, { recallStateViews: false }, LONG_CHANGE),
+    false,
+  );
+});
+
+test("non-cron sessions keep the original prompt as the retrieval query", () => {
+  const policy = buildRecallQueryPolicy(LONG_CHANGE, "sess-interactive", POLICY_CFG);
+  assert.equal(policy.retrievalQuery, LONG_CHANGE);
+});
+
+function fact(id: string, extra: Partial<StateViewResult> = {}): StateViewResult {
+  return { id, ...extra };
+}
+
+const CURRENT = fact("new-job", { status: "active" });
+const HISTORICAL = fact("old-job", {
+  status: "superseded",
+  supersededBy: "new-job",
+  supersededAt: "2026-03-01",
+});
+
+test("threaded flag carries the decision past the normalized query at the inject seam (#2893)", () => {
+  const policy = buildRecallQueryPolicy(LONG_CHANGE, CRON_KEY, POLICY_CFG);
+  assert.equal(isChangeOrientedQuery(policy.retrievalQuery), false);
+
+  const labeled = widenRecallStateViews([CURRENT], policy.retrievalQuery, { recallStateViews: false }, [HISTORICAL], true);
+  assert.deepEqual(
+    labeled.map((row) => [row.id, row.stateLabel]),
+    [
+      ["new-job", "current"],
+      ["old-job", "historical"],
+    ],
+  );
+  assert.deepEqual(
+    applyRecallStateViews([CURRENT, HISTORICAL], policy.retrievalQuery, { recallStateViews: false }, true).map(
+      (row) => row.stateLabel,
+    ),
+    ["current", "historical"],
+  );
+  assert.deepEqual(
+    annotateStateView([CURRENT, HISTORICAL], policy.retrievalQuery, [], {
+      enabled: true,
+      changeIntent: true,
+    }).map((row) => row.stateLabel),
+    ["current", "historical"],
+  );
+});
+
+test("legacy config-only path still re-checks intent against the given query", () => {
+  const policy = buildRecallQueryPolicy(LONG_CHANGE, CRON_KEY, POLICY_CFG);
+  const input = [CURRENT, HISTORICAL];
+  // No threaded flag: config-on alone must not label a non-change query.
+  assert.equal(widenRecallStateViews(input, policy.retrievalQuery, { recallStateViews: true }), input);
+  assert.equal(applyRecallStateViews(input, policy.retrievalQuery, { recallStateViews: true }), input);
+  assert.equal(annotateStateView(input, policy.retrievalQuery, [], { enabled: true }), input);
+  assert.equal(input[0]?.stateLabel, undefined);
+});
+
+async function makeOrchestrator(
+  overrides: Partial<PluginConfig> = {},
+): Promise<{ orchestrator: Orchestrator; memoryDir: string }> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-cron-"));
+  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 };
+}
+
+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");
+}
+
+const CRON_E2E_CONFIG: Partial<PluginConfig> = {
+  cronRecallPolicyEnabled: true,
+  cronRecallNormalizedQueryMaxChars: 120,
+};
+
+test("long cron prompt keeps per-call stateView labels when truncation erases intent (#2893)", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator(CRON_E2E_CONFIG);
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(LONG_CHANGE, CRON_KEY, { stateView: true });
+    assert.ok(
+      out.includes("[superseded 2026-08-01 by sv-new]"),
+      `cron truncation must not erase the classified intent, got:\n${out}`,
+    );
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("e2e negative: long cron prompt without intent stays unlabeled even with the flag", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator(CRON_E2E_CONFIG);
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(LONG_NON_CHANGE, CRON_KEY, { stateView: true });
+    assert.ok(!out.includes("[superseded "), `non-change prompt must stay filtered, got:\n${out}`);
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("e2e negative: long cron prompt with intent stays zero-diff without flags", async () => {
+  const { orchestrator, memoryDir } = await makeOrchestrator(CRON_E2E_CONFIG);
+  try {
+    await writePair(memoryDir);
+    const out = await orchestrator.recall(LONG_CHANGE, CRON_KEY);
+    assert.ok(!out.includes("[superseded "), `no flags must keep the injection byte-identical, got:\n${out}`);
+  } finally {
+    await orchestrator.destroy();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

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

@@ -96,11 +96,20 @@ test("#1952 precedence is OR: per-call false never disables a global true", () =
   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("#2893 threaded stateViewActive is trusted: no intent re-check at the seam", () => {
+  // The threaded flag means change intent was already classified on the
+  // ORIGINAL prompt at recall entry (resolveRecallStateViewActive); the
+  // query reaching this seam is the cron-normalized retrievalQuery and
+  // can lack the intent signal. Non-change ORIGINAL prompts never thread
+  // a true flag — pinned in recall-state-view-cron-intent.test.ts.
+  const labeled = widenRecallStateViews([CURRENT], NON_CHANGE, { recallStateViews: false }, [HISTORICAL], true);
+  assert.deepEqual(
+    labeled.map((row) => [row.id, row.stateLabel]),
+    [
+      ["new-job", "current"],
+      ["old-job", "historical"],
+    ],
+  );
 });
 
 test("asOf mode keeps a pin-filtered predecessor and never widens the pool (#1952)", () => {

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";
 
@@ -42,29 +43,49 @@ export function widenRecallStateViews<T extends StateViewResult>(
       ? config.recallStateViews
       : undefined;
   const enabled = stateViewActive === true || parseRecallStateViews(raw);
-  if (!enabled || !isChangeOrientedQuery(query)) return results;
+  if (!enabled) return results;
+  // #2893 — a threaded stateViewActive was gated on change intent
+  // classified from the ORIGINAL prompt at recall entry; `query` here is
+  // the cron-normalized retrievalQuery and may have lost the intent
+  // signal (truncation / stop-word compaction), so do not re-check it.
+  // Only the legacy config-only path re-checks intent against this query.
+  if (stateViewActive !== true && !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);
     }
   }
 
   return annotateStateView(extra.length > 0 ? results.concat(extra) : results, query, [], {
     enabled: true,
+    ...(stateViewActive === true ? { changeIntent: true } : {}),
     ...(asOfActive ? { asOfMs } : {}),
   });
 }

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/);
+});

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

@@ -3,9 +3,11 @@ import test from "node:test";
 
 import {
   annotateStateView,
+  capStateViewPackets,
   formatSupersededPrefix,
   isChangeOrientedQuery,
   parseRecallStateViews,
+  reconcileStateViewPairs,
   shouldWidenSuperseded,
   type StateViewChain,
   type StateViewResult,
@@ -271,3 +273,162 @@ test("transitive orphan chains collapse: A→B→(C absent) drops both A and B",
     "the fixpoint must drop A once B is dropped, not render a dangling historical",
   );
 });
+
+test("#2859 reverse chain derives from the successor supersedes back-pointer when supersededBy is absent", () => {
+  const results = [
+    fact("new-job", { status: "active", supersedes: "old-job" }),
+    // Corrected row: no supersededBy, and even no "superseded" status —
+    // the ONLY link is the successor's back-pointer.
+    fact("old-job", {}),
+  ];
+  const labeled = annotateStateView(results, "when did the job title change", [], { enabled: true });
+  assert.deepEqual(
+    labeled.map((row) => [row.id, row.stateLabel, row.supersededBy]),
+    [
+      ["new-job", "current", undefined],
+      ["old-job", "historical", "new-job"],
+    ],
+    "the back-pointer must link the pair, admit the predecessor, and carry derived supersededBy",
+  );
+});
+
+test("#2859 back-pointer pair survives the orphan fixpoint in both directions", () => {
+  const results = [
+    fact("v3", { status: "active", supersedes: "v2" }),
+    fact("v2", { status: "superseded", supersedes: "v1" }),
+    fact("v1", {}),
+  ];
+  const labeled = annotateStateView(results, "what changed about the database", [], { enabled: true });
+  assert.deepEqual(
+    labeled.map((row) => [row.id, row.stateLabel]),
+    [
+      ["v3", "current"],
+      ["v2", "transition"],
+      ["v1", "historical"],
+    ],
+  );
+});
+
+test("#2859 asOf label uses the validity boundary, not the supersededAt write time", () => {
+  const pin = Date.parse("2026-08-05T00:00:00.000Z");
+  // Write time January, validity flip September: at an August pin the row
+  // was still the live fact even though supersededAt PREDATES the pin.
+  const predecessor = fact("old-job", {
+    status: "superseded",
+    supersededBy: "new-job",
+    supersededAt: "2026-01-01T00:00:00.000Z",
+    invalidAt: "2026-09-01T00:00:00.000Z",
+  });
+  const labeled = annotateStateView([predecessor], "when did the job title change", [], {
+    enabled: true,
+    asOfMs: pin,
+  });
+  assert.equal(
+    labeled[0]?.stateLabel,
+    "current",
+    "the boundary is invalidAt, so a pin before the flip labels the row current-at-snapshot",
+  );
+
+  // Past the boundary the same row labels historical (boundary <= pin).
+  const afterFlip = annotateStateView([predecessor], "when did the job title change", [], {
+    enabled: true,
+    asOfMs: Date.parse("2026-09-05T00:00:00.000Z"),
+  });
+  assert.equal(
+    afterFlip[0]?.stateLabel,
+    "historical",
+    "a pin past the validity flip labels the row historical",
+  );
+
+  // Legacy row without a validity window keeps the supersededAt fallback.
+  const legacy = fact("old-legacy", {
+    status: "superseded",
+    supersededBy: "new-legacy",
+    supersededAt: "2026-01-01T00:00:00.000Z",
+  });
+  const legacyLabel = annotateStateView([legacy], "when did the job title change", [], {
+    enabled: true,
+    asOfMs: pin,
+  });
+  assert.equal(
+    legacyLabel[0]?.stateLabel,
+    "historical",
+    "no invalidAt → the supersededAt write time is the only recorded boundary",
+  );
+});
+
+test("#2859 namespace-qualified identities: same id across namespaces never cross-anchors", () => {
+  // ns-a has the superseded predecessor; ns-b has an UNRELATED row that
+  // happens to reuse the successor id. Bare-id matching would admit the
+  // ns-a predecessor on the ns-b anchor.
+  const results = [
+    fact("m-1", { namespace: "ns-b", status: "active" }),
+    fact("m-0", { namespace: "ns-a", status: "superseded", supersededBy: "m-1" }),
+  ];
+  const labeled = annotateStateView(results, "when did this change", [], { enabled: true });
+  assert.deepEqual(
+    labeled.map((row) => row.id),
+    ["m-1"],
+    "a foreign-namespace successor must not anchor the superseded row",
+  );
+
+  // Positive control: the same-namespace successor anchors it.
+  const anchored = annotateStateView(
+    [
+      fact("m-1", { namespace: "ns-a", status: "active" }),
+      fact("m-0", { namespace: "ns-a", status: "superseded", supersededBy: "m-1" }),
+    ],
+    "when did this change",
+    [],
+    { enabled: true },
+  );
+  assert.deepEqual(
+    anchored.map((row) => [row.id, row.stateLabel]),
+    [
+      ["m-1", "current"],
+      ["m-0", "historical"],
+    ],
+  );
+});
+
+test("#2859 namespace-qualified chains: a chain link never crosses namespaces", () => {
+  const chains: StateViewChain[] = [
+    { predecessorId: "old", successorId: "new", namespace: "ns-a" },
+  ];
+  const results = [
+    fact("new", { namespace: "ns-b", status: "active" }),
+    fact("old", { namespace: "ns-a", status: "superseded", supersededAt: "2026-02-01" }),
+  ];
+  const labeled = annotateStateView(results, "before the correction what was it", chains, {
+    enabled: true,
+  });
+  assert.deepEqual(
+    labeled.map((row) => row.id),
+    ["new"],
+    "the ns-a chain link must not pair against the ns-b successor",
+  );
+});
+
+test("reconcile drops a linkless superseded row so it cannot consume a packet slot", () => {
+  const rows = [
+    fact("legacy", { status: "superseded", supersededAt: "2026-01-01" }),
+    fact("live", { status: "active" }),
+  ];
+  assert.deepEqual(
+    reconcileStateViewPairs(rows).map((row) => row.id),
+    ["live"],
+    "audit/kill-switch status-only rows have no successor and must leave before the cap",
+  );
+  assert.deepEqual(
+    capStateViewPackets(reconcileStateViewPairs(rows), 1).map((row) => row.id),
+    ["live"],
+  );
+});
+
+test("reconcile still keeps an unlinked active row", () => {
+  const rows = [fact("solo", { status: "active" })];
+  assert.deepEqual(
+    reconcileStateViewPairs(rows).map((row) => row.id),
+    ["solo"],
+  );
+});