@remnic/core 9.65.5 → 9.65.6

package/dist/support-passport/index.js

@@ -4,7 +4,7 @@ import {
   SUPPORT_PASSPORT_MODEL_RESULT_PATH,
   SupportPassportModelBridge,
   parseSupportPassportModelJob
-} from "../chunk-4JSF7UUP.js";
+} from "../chunk-X2DWBWOX.js";
 import {
   DEFAULT_SUPPORT_PASSPORT_CONFIG,
   parseSupportPassportConfig
@@ -14,8 +14,8 @@ import {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers,
   normalizeSupportPassportNetworkAddress
-} from "../chunk-NH6LC57D.js";
-import "../chunk-OWQNJJY2.js";
+} from "../chunk-AYAZWXJI.js";
+import "../chunk-7OZSHBWK.js";
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES,
@@ -56,16 +56,16 @@ import {
   notifySupportPassportCommitted,
   resolveSupportPassportModelRoutePlan,
   syncDirectoryForDurability
-} from "../chunk-CV3GNPOE.js";
+} from "../chunk-PNAGNVGK.js";
 import "../chunk-GDASG7NC.js";
 import "../chunk-GDB4J2H3.js";
-import "../chunk-6433HV72.js";
+import "../chunk-MVIYRRVJ.js";
 import "../chunk-VQ7B2Q6M.js";
-import "../chunk-KFIOPZ25.js";
+import "../chunk-ZXUZ54Z5.js";
 import "../chunk-PJSK6OJM.js";
+import "../chunk-5QZR2RA3.js";
 import "../chunk-GNVZQ5JN.js";
 import "../chunk-YN2UN7N3.js";
-import "../chunk-5QZR2RA3.js";
 import "../chunk-P5FPO2BR.js";
 import "../chunk-S4DDLTPX.js";
 import "../chunk-ZVZHG7AI.js";
@@ -73,7 +73,7 @@ import "../chunk-H7XKCNR6.js";
 import "../chunk-YOXVZJFM.js";
 import "../chunk-SOBJ6NEY.js";
 import "../chunk-MFOSZUIT.js";
-import "../chunk-2MVTAIL3.js";
+import "../chunk-XAWIL7TC.js";
 import "../chunk-CVILPI77.js";
 import "../chunk-2HIJHXB3.js";
 import "../chunk-AQEJKOKI.js";
@@ -95,10 +95,10 @@ import "../chunk-7BEPVIH3.js";
 import "../chunk-7ZNJN5WZ.js";
 import "../chunk-C37ZRXX7.js";
 import "../chunk-UFGFMWAD.js";
-import "../chunk-KOO37E4Y.js";
-import "../chunk-WDXD6ITO.js";
-import "../chunk-OZDFB22S.js";
-import "../chunk-CQBIN77D.js";
+import "../chunk-DYO24BNB.js";
+import "../chunk-BXXOPKT5.js";
+import "../chunk-IDQ6DKXC.js";
+import "../chunk-7SSRXEZJ.js";
 import "../chunk-BIJAWZYW.js";
 import "../chunk-LXY5VVGM.js";
 import "../chunk-2LSZVONP.js";
@@ -108,32 +108,32 @@ import "../chunk-CSAKJVXW.js";
 import "../chunk-K2XUWZBM.js";
 import "../chunk-OD4FM2U7.js";
 import "../chunk-ZY2MNJR6.js";
-import "../chunk-TJFI3K2O.js";
+import "../chunk-O4BAGJDN.js";
 import "../chunk-ZXBTTMGZ.js";
-import "../chunk-IURMJBGP.js";
-import "../chunk-THVI4Y7X.js";
+import "../chunk-HWVNYNIV.js";
+import "../chunk-6LS5OX3U.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-46WM6JX2.js";
 import "../chunk-SXIMQLGV.js";
-import "../chunk-YHCBJULX.js";
-import "../chunk-DJZWNKFO.js";
-import "../chunk-N37X5RU7.js";
-import "../chunk-NNBZS3DY.js";
-import "../chunk-CYEPCZN5.js";
-import "../chunk-GIC6BASP.js";
+import "../chunk-6FUMA6AA.js";
+import "../chunk-D35XLYQ7.js";
 import "../chunk-YQNNHLCG.js";
-import "../chunk-W7IGLX4G.js";
 import "../chunk-6KTXE6A3.js";
+import "../chunk-RACZB5HT.js";
+import "../chunk-AG46P24C.js";
+import "../chunk-CYEPCZN5.js";
+import "../chunk-XZBXINXZ.js";
 import "../chunk-GUMZC2BO.js";
+import "../chunk-W7IGLX4G.js";
 import "../chunk-227UFSEQ.js";
 import "../chunk-ET356KSB.js";
 import "../chunk-72A4L5JJ.js";
 import "../chunk-A7Q43EUZ.js";
 import "../chunk-S2V7RUCL.js";
 import "../chunk-LBFFNDFM.js";
+import "../chunk-S2HLHAZ4.js";
 import "../chunk-SCU65EZI.js";
 import "../chunk-PO7NXBG2.js";
-import "../chunk-S2HLHAZ4.js";
 import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
 import "../chunk-UG6VXIOK.js";
@@ -188,9 +188,9 @@ import "../chunk-Z7L72ZHL.js";
 import "../chunk-4O4TKIXQ.js";
 import "../chunk-TBBDFYXW.js";
 import "../chunk-YCVB7X56.js";
-import "../chunk-VDX2J7OX.js";
+import "../chunk-5W7CTZ2E.js";
+import "../chunk-UVYI6VIX.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-DQEMWVMT.js";
 import "../chunk-J4EB7DNW.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
@@ -275,9 +275,9 @@ import "../chunk-2Z24E5W2.js";
 import "../chunk-BTTPKDIL.js";
 import "../chunk-A2IYSXDQ.js";
 import "../chunk-P77QX3ID.js";
-import "../chunk-TVVEYCNW.js";
-import "../chunk-RFYAYKTD.js";
+import "../chunk-7K5Q6COX.js";
 import "../chunk-LBLXEFWK.js";
+import "../chunk-RFYAYKTD.js";
 import "../chunk-JIYDRBVZ.js";
 import "../chunk-FF4KLI5W.js";
 import "../chunk-XQ3HXAQH.js";

package/dist/transfer/backup.js

@@ -1,8 +1,8 @@
 import {
   backupMemoryDir
-} from "../chunk-BXLOS5AJ.js";
+} from "../chunk-OWHERGF2.js";
 import "../chunk-765K3SAT.js";
-import "../chunk-DQEMWVMT.js";
+import "../chunk-UVYI6VIX.js";
 import "../chunk-J4EB7DNW.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";

package/dist/transfer/capsule-export.js

@@ -1,9 +1,9 @@
 import {
   exportCapsule,
   isValidCapsuleSince
-} from "../chunk-VDX2J7OX.js";
+} from "../chunk-5W7CTZ2E.js";
+import "../chunk-UVYI6VIX.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-DQEMWVMT.js";
 import "../chunk-J4EB7DNW.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";

package/dist/transfer/capsule-import.js

@@ -1,6 +1,6 @@
 import {
   importCapsule
-} from "../chunk-6433HV72.js";
+} from "../chunk-MVIYRRVJ.js";
 import "../chunk-UFKPQBXH.js";
 import "../chunk-XCB6QDL6.js";
 import "../chunk-RBOJCG4T.js";
@@ -9,8 +9,8 @@ import "../chunk-5WITETWU.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-C64XATK7.js";
 import "../chunk-42JKGUFJ.js";
+import "../chunk-UVYI6VIX.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-DQEMWVMT.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";

package/dist/verified-recall.js

@@ -1,31 +1,31 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-ECLJ4LA2.js";
+} from "./chunk-53MZQEBD.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-THVI4Y7X.js";
+import "./chunk-6LS5OX3U.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-SXIMQLGV.js";
-import "./chunk-YHCBJULX.js";
-import "./chunk-DJZWNKFO.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-W7IGLX4G.js";
 import "./chunk-227UFSEQ.js";
 import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-LBFFNDFM.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-PO7NXBG2.js";
-import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-UG6VXIOK.js";

package/dist/who-knows-cli.js

@@ -4,31 +4,31 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-2IXQSGCU.js";
-import "./chunk-KFIOPZ25.js";
-import "./chunk-THVI4Y7X.js";
+} from "./chunk-SR7JIRAR.js";
+import "./chunk-ZXUZ54Z5.js";
+import "./chunk-6LS5OX3U.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-SXIMQLGV.js";
-import "./chunk-YHCBJULX.js";
-import "./chunk-DJZWNKFO.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-W7IGLX4G.js";
 import "./chunk-227UFSEQ.js";
 import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-LBFFNDFM.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-PO7NXBG2.js";
-import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-UG6VXIOK.js";

package/dist/who-knows.js

@@ -9,30 +9,30 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-KFIOPZ25.js";
-import "./chunk-THVI4Y7X.js";
+} from "./chunk-ZXUZ54Z5.js";
+import "./chunk-6LS5OX3U.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-SXIMQLGV.js";
-import "./chunk-YHCBJULX.js";
-import "./chunk-DJZWNKFO.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-W7IGLX4G.js";
 import "./chunk-227UFSEQ.js";
 import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-LBFFNDFM.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-PO7NXBG2.js";
-import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-UG6VXIOK.js";

package/package.json

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

package/src/index.ts

@@ -1460,3 +1460,6 @@ export type {
 } from "./coding/coding-graph-types.js";
 export type { ResolvedScopeProfilePlan } from "./namespaces/scope-profiles.js";
 export * from "./maintenance/atomic-file.js";
+
+export { MemoryControllerCoordinator, chooseAction, computeEvidenceReportHash, controllerConfigHash, evaluateActiveGates, hashControllerState, verifyEvidenceReport } from "./memory-controller.js";
+export type { ActiveContextAdapter, ActiveContextMessage, ActiveContextPlan, MemoryControllerActionFamily, MemoryControllerChoice, MemoryControllerConfig, MemoryControllerDeps, MemoryControllerEvent, MemoryControllerEvidence, MemoryControllerEvidenceReport, MemoryControllerExecutors, MemoryControllerMode, MemoryControllerPairedSeedEvidence, MemoryControllerReceipt, MemoryControllerRecorder, MemoryControllerReportReader, MemoryControllerRunResult, MemoryControllerState } from "./memory-controller.js";

package/src/memory-controller.test.ts

@@ -0,0 +1,347 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  MemoryControllerCoordinator,
+  chooseAction,
+  computeEvidenceReportHash,
+  controllerConfigHash,
+  evaluateActiveGates,
+  hashControllerState,
+  type ActiveContextPlan,
+  type MemoryControllerConfig,
+  type MemoryControllerDeps,
+  type MemoryControllerEvent,
+  type MemoryControllerEvidence,
+  type MemoryControllerExecutors,
+  type MemoryControllerMode,
+} from "./memory-controller.js";
+
+const NOW = new Date("2026-08-18T12:00:00.000Z");
+
+function config(mode: MemoryControllerMode): MemoryControllerConfig {
+  return {
+    mode,
+    reportVersion: "2345-v1",
+    evidenceMaxAgeMs: 24 * 60 * 60 * 1000,
+    minPairedSeeds: 2,
+    shadowMinRecords: 3,
+  };
+}
+
+function evidence(overrides?: {
+  report?: Partial<MemoryControllerEvidence["report"]>;
+  pairedSeed?: Partial<MemoryControllerEvidence["pairedSeed"]>;
+}): MemoryControllerEvidence {
+  const report = {
+    status: "pass",
+    version: "2345-v1",
+    configHash: controllerConfigHash(config("active")),
+    generatedAt: NOW.toISOString(),
+    ...overrides?.report,
+  } as MemoryControllerEvidence["report"];
+  return {
+    report: { ...report, reportHash: computeEvidenceReportHash(report) },
+    pairedSeed: {
+      status: "pass",
+      seedCount: 3,
+      generatedAt: NOW.toISOString(),
+      ...overrides?.pairedSeed,
+    },
+  };
+}
+
+function echoReceipt(input: { decisionId: string }): { decisionId: string; ok: true } {
+  return { decisionId: input.decisionId, ok: true };
+}
+
+function harness(options?: {
+  mode?: MemoryControllerMode;
+  evidenceOverride?: MemoryControllerEvidence | null;
+  shadowRecords?: number;
+  recordThrows?: boolean;
+  executors?: MemoryControllerExecutors;
+  adapterPlan?: ActiveContextPlan | null;
+}) {
+  const events: MemoryControllerEvent[] = [];
+  const calls: string[] = [];
+  let dispatched = false;
+  const markDispatch =
+    <T>(label: string) =>
+    async (input: T & { decisionId: string }) => {
+      calls.push(label);
+      dispatched = true;
+      return echoReceipt(input);
+    };
+  const deps: MemoryControllerDeps = {
+    config: config(options?.mode ?? "active"),
+    reportReader: {
+      read: async () =>
+        options?.evidenceOverride === undefined || options.evidenceOverride !== null
+          ? (options?.evidenceOverride ?? evidence())
+          : null,
+    },
+    recorder: {
+      record: async (event) => {
+        if (options?.recordThrows) throw new Error("recorder down");
+        if (event.phase === "choice") {
+          // Gate proof: the choice record must precede any dispatch.
+          assert.ok(!dispatched, "choice event recorded after dispatch");
+        }
+        events.push(event);
+      },
+      countShadowRecords: async () => options?.shadowRecords ?? 10,
+    },
+    executors:
+      options?.executors ??
+      ({
+        executePersistentMemory: markDispatch("persistent"),
+        executeRecall: markDispatch("recall"),
+        executeActiveContext: markDispatch("context"),
+      } as MemoryControllerExecutors),
+    activeContextAdapter:
+      options?.adapterPlan === null
+        ? undefined
+        : {
+            plan: () => options?.adapterPlan ?? { transform: "FILTER", messageIds: ["m1"], planId: "p1" },
+          },
+    telemetry: (event) => calls.push(`telemetry:${event.phase}`),
+    clock: () => NOW,
+  };
+  return { deps, events, calls };
+}
+
+const RECALL_PROMPT = "what did we decide last time?";
+
+test("off mode makes no choice, no read, no write, no call", async () => {
+  const h = harness({ mode: "off" });
+  const explode = async () => {
+    throw new Error("touched in off mode");
+  };
+  h.deps.reportReader = { read: explode };
+  h.deps.recorder = { record: explode, countShadowRecords: explode };
+  h.deps.executors = { executeRecall: explode } as MemoryControllerExecutors;
+  h.deps.policyRuntime = { loadRuntimeValues: explode };
+  h.deps.readUtilityRuntime = explode;
+
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+
+  assert.equal(result.effectiveMode, "off");
+  assert.equal(result.executed, false);
+  assert.equal(result.recorded, false);
+  assert.deepEqual(h.events, []);
+  assert.deepEqual(h.calls, []);
+});
+
+test("shadow mode records the choice but calls no executor", async () => {
+  const h = harness({ mode: "shadow" });
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+
+  assert.equal(result.effectiveMode, "shadow");
+  assert.equal(result.recorded, true);
+  assert.equal(result.executed, false);
+  assert.deepEqual(h.calls, ["telemetry:choice"]);
+  assert.equal(h.events.length, 1);
+  assert.equal(h.events[0].phase, "choice");
+  assert.ok(h.events[0].stateHash.length > 0);
+});
+
+test("active mode with passing gates executes and links one id across events", async () => {
+  const h = harness();
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+
+  assert.equal(result.effectiveMode, "active");
+  assert.deepEqual(result.demotionReasons, []);
+  assert.equal(result.choice.family, "recall");
+  assert.ok(h.calls.includes("recall"));
+  const ids = new Set(h.events.map((event) => event.decisionId));
+  ids.add(result.decisionId);
+  if (result.receipt) ids.add(result.receipt.decisionId);
+  assert.equal(ids.size, 1, "one id joins each event");
+  assert.equal(result.executed, true);
+  const outcome = h.events.find((event) => event.phase === "outcome");
+  assert.equal(outcome?.receipt?.decisionId, result.decisionId);
+});
+
+test("bad or old evidence forces shadow: report gates", async () => {
+  const cases: { name: string; options: Parameters<typeof harness>[0] }[] = [
+    { name: "no evidence", options: { evidenceOverride: null } },
+    {
+      name: "report not passing",
+      options: { evidenceOverride: evidence({ report: { status: "fail" } }) },
+    },
+    {
+      name: "version mismatch",
+      options: { evidenceOverride: evidence({ report: { version: "2345-v0" } }) },
+    },
+    {
+      name: "config unbound",
+      options: {
+        evidenceOverride: evidence({
+          report: { configHash: controllerConfigHash({ ...config("active"), shadowMinRecords: 99 }) },
+        }),
+      },
+    },
+    {
+      name: "report hash invalid",
+      options: {
+        evidenceOverride: {
+          report: { ...evidence().report, reportHash: "0".repeat(64) },
+          pairedSeed: evidence().pairedSeed,
+        },
+      },
+    },
+    {
+      name: "report stale",
+      options: { evidenceOverride: evidence({ report: { generatedAt: "2020-01-01T00:00:00.000Z" } }) },
+    },
+  ];
+  for (const testCase of cases) {
+    const h = harness(testCase.options);
+    const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+    assert.equal(result.effectiveMode, "shadow", testCase.name);
+    assert.equal(result.executed, false, testCase.name);
+    assert.ok(!h.calls.some((c) => c !== "telemetry:choice"), testCase.name);
+  }
+});
+
+test("bad or old paired-seed evidence forces shadow", async () => {
+  const pairedSeeds = [
+    { status: "fail" as const, seedCount: 3, generatedAt: NOW.toISOString() },
+    { status: "pass" as const, seedCount: 1, generatedAt: NOW.toISOString() },
+    { status: "pass" as const, seedCount: 3, generatedAt: "2020-01-01T00:00:00.000Z" },
+  ];
+  for (const pairedSeed of pairedSeeds) {
+    const h = harness({ evidenceOverride: evidence({ pairedSeed }) });
+    const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+    assert.equal(result.effectiveMode, "shadow", JSON.stringify(pairedSeed));
+    assert.ok(result.demotionReasons.some((r) => r.startsWith("paired_seed")));
+    assert.equal(result.executed, false);
+  }
+});
+
+test("active promotion requires prior shadow records (shadow before active)", async () => {
+  const h = harness({ shadowRecords: 1 });
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+  assert.equal(result.effectiveMode, "shadow");
+  assert.ok(result.demotionReasons.includes("shadow_history_insufficient"));
+  assert.equal(result.executed, false);
+});
+
+test("failed receipt forces shadow on the next run", async () => {
+  const h = harness({
+    executors: {
+      executeRecall: async () => ({ decisionId: "wrong-id", ok: true }),
+    },
+  });
+  const coordinator = new MemoryControllerCoordinator(h.deps);
+  const first = await coordinator.run({ prompt: RECALL_PROMPT });
+  assert.equal(first.executed, false, "mismatched receipt id is a bad receipt");
+  assert.ok(h.events.find((event) => event.phase === "outcome")?.failureClass === "bad_receipt");
+
+  const second = await coordinator.run({ prompt: RECALL_PROMPT });
+  assert.equal(second.effectiveMode, "shadow");
+  assert.ok(second.demotionReasons.includes("recent_receipt_failures"));
+  assert.equal(second.executed, false);
+});
+
+test("executor error or missing executor records a failure class and demotes next run", async () => {
+  const h = harness({
+    executors: {
+      executeRecall: async () => Promise.reject(new Error("boom")),
+    },
+  });
+  const coordinator = new MemoryControllerCoordinator(h.deps);
+  const failed = await coordinator.run({ prompt: RECALL_PROMPT });
+  assert.equal(failed.executed, false);
+  assert.equal(h.events.find((event) => event.phase === "outcome")?.failureClass, "executor_error");
+  const next = await coordinator.run({ prompt: RECALL_PROMPT });
+  assert.equal(next.effectiveMode, "shadow");
+
+  const h2 = harness({ executors: {} });
+  const missing = await new MemoryControllerCoordinator(h2.deps).run({ prompt: RECALL_PROMPT });
+  assert.equal(missing.executed, false);
+  assert.equal(h2.events.find((event) => event.phase === "outcome")?.failureClass, "no_executor");
+});
+
+test("bad scores fail closed to no_op", () => {
+  const { choice, scores } = chooseAction({
+    state: {
+      prompt: RECALL_PROMPT,
+      persistentMemoryCandidate: {
+        action: "store_note",
+        eligibility: {
+          confidence: Number.NaN,
+          lifecycleState: "active",
+          importance: 0.5,
+          source: "extraction",
+        },
+      },
+    },
+  });
+  assert.deepEqual(choice, { family: "no_op" });
+  assert.ok(Number.isNaN(scores.persistent_memory));
+});
+
+test("discard stays review-only in active mode", async () => {
+  const h = harness();
+  const result = await new MemoryControllerCoordinator(h.deps).run({
+    prompt: "ok",
+    persistentMemoryCandidate: {
+      action: "discard",
+      eligibility: {
+        confidence: 0.9,
+        lifecycleState: "active",
+        importance: 0.1,
+        source: "extraction",
+      },
+    },
+  });
+  assert.equal(result.choice.family, "persistent_memory");
+  assert.equal(result.choice.action, "discard");
+  assert.equal(result.reviewOnly, true);
+  assert.equal(result.executed, false);
+  assert.deepEqual(h.calls, ["telemetry:choice", "telemetry:outcome"]);
+  assert.equal(h.events.find((event) => event.phase === "outcome")?.reviewOnly, true);
+});
+
+test("record failure stops work before dispatch", async () => {
+  const h = harness({ recordThrows: true });
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+  assert.equal(result.recorded, false);
+  assert.equal(result.executed, false);
+  assert.ok(result.demotionReasons.includes("record_failed"));
+  assert.deepEqual(h.calls, []);
+});
+
+test("one hash names each state", () => {
+  assert.equal(hashControllerState({ prompt: "same" }), hashControllerState({ prompt: "same" }));
+  assert.notEqual(hashControllerState({ prompt: "same" }), hashControllerState({ prompt: "other" }));
+});
+
+test("no counterfactual lift is claimed in events or results", async () => {
+  const h = harness();
+  const result = await new MemoryControllerCoordinator(h.deps).run({ prompt: RECALL_PROMPT });
+  const banned = /lift|counterfactual/i;
+  for (const event of h.events) {
+    for (const key of Object.keys(event)) assert.ok(!banned.test(key), `event key ${key}`);
+  }
+  for (const key of Object.keys(result)) assert.ok(!banned.test(key), `result key ${key}`);
+});
+
+test("evaluateActiveGates returns empty only when all gates pass", async () => {
+  const passing = await evaluateActiveGates({
+    config: config("active"),
+    reportReader: { read: async () => evidence() },
+    recorder: { record: async () => {}, countShadowRecords: async () => 5 },
+    consecutiveReceiptFailures: 0,
+    now: NOW,
+  });
+  assert.deepEqual(passing, []);
+  const noReader = await evaluateActiveGates({
+    config: config("active"),
+    consecutiveReceiptFailures: 0,
+    now: NOW,
+  });
+  assert.deepEqual(noReader, ["no_report_reader"]);
+});