@remnic/core 9.3.719 → 9.3.721

package/src/recall-xray.test.ts

@@ -501,3 +501,65 @@ test("RecallXrayBuilder produces unique snapshotId per build when no generator i
   assert.ok(typeof b.snapshotId === "string" && b.snapshotId.length > 0);
   assert.notEqual(a.snapshotId, b.snapshotId);
 });
+
+// ─── Issue #1577 — cloneResult preserves the trust projection (review Oqg_o) ─
+
+test("RecallXrayBuilder clones the trust projection so the snapshot surfaces it (#1577)", () => {
+  // Review Oqg_o: cloneResult was silently dropping the `trust` field, so a
+  // snapshot built via recordResult() lost trust score/band/quarantine reason
+  // even when the live capture had it. The clone must deep-copy the projection.
+  const builder = new RecallXrayBuilder({ query: "q" });
+  builder.recordResult({
+    memoryId: "mem-admitted",
+    path: "mems/a.md",
+    servedBy: "hybrid",
+    scoreDecomposition: { final: 0.9 },
+    admittedBy: [],
+    trust: {
+      score: 0.82,
+      band: "high",
+      components: { faithfulness: { value: 1, weight: 0.4 } },
+      multiplier: 1.15,
+      quarantined: false,
+    },
+  });
+  builder.recordResult({
+    memoryId: "mem-quarantined",
+    path: "mems/b.md",
+    servedBy: "hybrid",
+    scoreDecomposition: { final: 0 },
+    admittedBy: [],
+    rejectedBy: "trust-score:quarantine",
+    trust: {
+      score: 0,
+      band: "quarantine",
+      components: { faithfulness: { value: 0, weight: 0.4 } },
+      multiplier: 1,
+      quarantined: true,
+      quarantineReason: "faithfulness: contradicted",
+    },
+  });
+  const snap = builder.build();
+  const admitted = snap.results.find((r) => r.memoryId === "mem-admitted");
+  const quarantined = snap.results.find((r) => r.memoryId === "mem-quarantined");
+  assert.ok(admitted, "admitted result present in snapshot");
+  assert.ok(admitted!.trust, "admitted result keeps its trust projection through the clone");
+  assert.equal(admitted!.trust!.score, 0.82);
+  assert.equal(admitted!.trust!.band, "high");
+  assert.equal(admitted!.trust!.multiplier, 1.15);
+  assert.equal(admitted!.trust!.quarantined, false);
+  assert.deepEqual(
+    admitted!.trust!.components,
+    { faithfulness: { value: 1, weight: 0.4 } },
+    "components deep-copied",
+  );
+  assert.ok(quarantined, "quarantined result present in snapshot");
+  assert.ok(quarantined!.trust, "quarantined result keeps its trust projection through the clone");
+  assert.equal(quarantined!.trust!.band, "quarantine");
+  assert.equal(quarantined!.trust!.quarantined, true);
+  assert.equal(
+    quarantined!.trust!.quarantineReason,
+    "faithfulness: contradicted",
+    "quarantine reason preserved so exclusion never looks like 'no result' (rule 34)",
+  );
+});

package/src/recall-xray.ts

@@ -185,6 +185,20 @@ export interface RecallXrayResult {
     /** Coarse strength tag from the frontmatter. */
     provenance: "verified" | "unverified" | "none";
   };
+  /**
+   * Issue #1577 — per-result trust score, band, and components from the
+   * unified TrustScore recall stage. Present when `trustScoreEnabled` is on.
+   * Quarantined items appear here with `quarantined: true` and a reason so
+   * exclusion never looks like "no result" (rule 34).
+   */
+  trust?: {
+    score: number;
+    band: "high" | "medium" | "low" | "quarantine";
+    components: Record<string, { value: number; weight: number }>;
+    multiplier: number;
+    quarantined: boolean;
+    quarantineReason?: string;
+  };
 }
 
 /**
@@ -554,6 +568,26 @@ function cloneResult(result: RecallXrayResult): RecallXrayResult {
       provenance: ss.provenance,
     };
   }
+  // Issue #1577 — preserve the trust projection through the clone so
+  // getLastXraySnapshot surfaces trust score/band/quarantine reason (review
+  // Oqg_o: cloneResult was silently dropping the field). Deep-copy the scalar +
+  // record fields so the snapshot is independent of the caller's object,
+  // matching the structuredClone contract used for every other field above.
+  if (result.trust) {
+    const t = result.trust;
+    const components: Record<string, { value: number; weight: number }> = {};
+    for (const [k, v] of Object.entries(t.components)) {
+      components[k] = { value: v.value, weight: v.weight };
+    }
+    out.trust = {
+      score: t.score,
+      band: t.band,
+      components,
+      multiplier: t.multiplier,
+      quarantined: t.quarantined,
+      ...(t.quarantineReason ? { quarantineReason: t.quarantineReason } : {}),
+    };
+  }
   return out;
 }
 

package/src/trust-score-recall-paths.test.ts

@@ -0,0 +1,157 @@
+/**
+ * trust-score-recall-paths.test.ts — issue #1577 integration tests.
+ *
+ * Proves the rule-41 parity fix: TrustScore runs on EVERY recall path, not
+ * just the hot-QMD path. With QMD disabled (so recall falls through to the
+ * recent-memory-scan / embedding-fallback branch) and trustScoreEnabled ON,
+ * recall still produces a per-path trust map that reaches the X-ray snapshot.
+ *
+ * This pins the HIGH review gap: before the fix, the cold / embedding / recent
+ * paths skipped TrustScore entirely, so recallTrustByPath stayed null and the
+ * X-ray + publisher quarantine filtering never saw trust data on those paths.
+ */
+
+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 { StorageManager } from "./storage.js";
+import type { PluginConfig } from "./types.js";
+
+async function makeOrchestrator(
+  overrides: Partial<PluginConfig> = {},
+): Promise<{ orchestrator: Orchestrator; memoryDir: string }> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-trust-paths-"));
+  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: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+    trustScoreEnabled: true,
+    initGateTimeoutMs: 200,
+    ...overrides,
+  });
+  const orchestrator = new Orchestrator(config);
+  return { orchestrator, memoryDir };
+}
+
+/**
+ * Write a fact file directly into the default-namespace storage dir with the
+ * given extra frontmatter lines (mw_success / mw_fail / faithfulness). Mirrors
+ * the memory-worth-frontmatter test helper so we control trust signals without
+ * going through the extraction pipeline.
+ */
+async function writeFact(
+  memoryDir: string,
+  body: string,
+  extraFrontmatterLines: string[] = [],
+): Promise<string> {
+  const today = new Date().toISOString().slice(0, 10);
+  const id = `fact-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const lines = [
+    "---",
+    `id: ${id}`,
+    "category: fact",
+    `created: ${new Date().toISOString()}`,
+    `updated: ${new Date().toISOString()}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    ...extraFrontmatterLines,
+    "---",
+  ];
+  const factsDir = path.join(memoryDir, "facts", today);
+  await mkdir(factsDir, { recursive: true });
+  await writeFile(path.join(factsDir, `${id}.md`), `${lines.join("\n")}\n\n${body}\n`, "utf-8");
+  return id;
+}
+
+test("TrustScore runs on the recent-scan path: trust map reaches the X-ray snapshot (#1577)", async (t) => {
+  // QMD disabled → recall falls through to the recent-memory-scan branch.
+  // trustScoreEnabled ON → applyTrustScoreToBranch must score the recent
+  // candidates and populate recallTrustByPath, which the X-ray capture reads.
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    await writeFact(memoryDir, "High-trust fact: production DB uses pgBouncer.", [
+      "mw_success: 10",
+      "mw_fail: 0",
+    ]);
+    await writeFact(memoryDir, "Low-trust fact: the cache never invalidates.", [
+      "mw_success: 0",
+      "mw_fail: 10",
+    ]);
+    await orchestrator.recall("database connection pooling", "sess-trust-paths", {
+      xrayCapture: true,
+    });
+    const snapshot = orchestrator.getLastXraySnapshot();
+    assert.ok(snapshot, "X-ray snapshot must be captured");
+    const withTrust = (snapshot!.results ?? []).filter((r) => r.trust !== undefined);
+    // At least one recalled result carries a trust projection → the recent-scan
+    // path populated recallTrustByPath and the capture read it back. Before the
+    // fix, recallTrustByPath was null on this path so NO result had trust.
+    assert.ok(
+      withTrust.length > 0,
+      "recent-scan path must surface trust projections (rule 41 parity)",
+    );
+    // Each trust projection is well-formed (cloneResult preserved it).
+    for (const r of withTrust) {
+      assert.ok(typeof r.trust!.score === "number", "trust.score is a number");
+      assert.ok(
+        r.trust!.band === "high" || r.trust!.band === "medium" || r.trust!.band === "low" || r.trust!.band === "quarantine",
+        "trust.band is a valid band",
+      );
+    }
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("TrustScore quarantine excludes a contradicted memory from injection but surfaces it in X-ray (#1577)", async (t) => {
+  // A faithfulness-contradicted memory is a hard negative: it must be excluded
+  // from the injected set (publishRecallResults filters it) BUT appear in the
+  // X-ray snapshot with its quarantine reason (rule 34 — exclusion must never
+  // look like "no result"). This proves the trust map flows to BOTH consumers.
+  const { orchestrator, memoryDir } = await makeOrchestrator();
+  try {
+    const goodId = await writeFact(memoryDir, "Verified fact: the API port is 8080.", [
+      "mw_success: 5",
+      "mw_fail: 0",
+    ]);
+    const badId = await writeFact(memoryDir, "Contradicted fact: the API port is 9000.", [
+      'faithfulness: {"verdict":"contradicted"}',
+    ]);
+    await orchestrator.recall("API port", "sess-trust-quarantine", {
+      xrayCapture: true,
+    });
+    const snapshot = orchestrator.getLastXraySnapshot();
+    assert.ok(snapshot, "X-ray snapshot captured");
+    const results = snapshot!.results ?? [];
+    const quarantined = results.find(
+      (r) => r.trust?.quarantined === true,
+    );
+    assert.ok(quarantined, "a quarantined result must appear in the X-ray snapshot (rule 34)");
+    assert.ok(
+      typeof quarantined!.trust!.quarantineReason === "string" && quarantined!.trust!.quarantineReason.length > 0,
+      "quarantined result carries a human-readable reason",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/trust-score-stage.test.ts

@@ -0,0 +1,350 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyTrustScoreStage,
+  buildTrustSignalMap,
+  explainQuarantine,
+  projectTrustForXray,
+  type TrustStageCandidate,
+} from "./trust-score-stage.js";
+import type { TrustScoreResult, TrustSignals } from "./trust-score.js";
+
+/**
+ * Issue #1577 PR 2 — signal adapters + recall stage tests.
+ *
+ * Pins:
+ *   - frontmatter → TrustSignals adapter (worth, provenance, faithfulness,
+ *     corroboration, recency).
+ *   - gate-OFF behavior is byte-identical to a pre-feature pass-through
+ *     (every candidate keeps its original order and score when the stage is a
+ *     no-op — modeled here by an empty signals map).
+ *   - double-multiplier prevention: the stage never applies memory-worth AND
+ *     trust at once (structurally — this stage owns the multiplier; the
+ *     orchestrator's mutual-exclusion guard is the other half).
+ *   - quarantine excludes from injection but keeps the item in `all` for X-ray.
+ *   - neutral candidates (absent from the signals map) keep multiplier 1.0.
+ */
+
+const NOW = new Date("2026-07-01T00:00:00.000Z");
+
+// ─── buildTrustSignalMap ──────────────────────────────────────────────────
+
+test("adapter: empty memories → empty map", () => {
+  const map = buildTrustSignalMap([], NOW);
+  assert.equal(map.size, 0);
+});
+
+test("adapter: memory worth counters flow through computeMemoryWorth", () => {
+  const map = buildTrustSignalMap(
+    [{ path: "a.md", frontmatter: { mw_success: 9, mw_fail: 1 } }],
+    NOW,
+  );
+  const s = map.get("a.md");
+  assert.ok(s?.memoryWorth);
+  // 9/1 success-heavy → score well above neutral 0.5.
+  assert.ok(s.memoryWorth!.score > 0.5);
+});
+
+test("adapter: provenance + faithfulness + corroboration are read", () => {
+  const map = buildTrustSignalMap(
+    [
+      {
+        path: "a.md",
+        frontmatter: {
+          provenance: "verified",
+          faithfulness: { verdict: "entailed" },
+          sources: [
+            { sessionKey: "s1", observedAt: "2026-06-01", quote: "q1" },
+            { sessionKey: "s2", observedAt: "2026-06-02", quote: "q2" },
+          ],
+        },
+      },
+    ],
+    NOW,
+  );
+  const s = map.get("a.md");
+  assert.equal(s?.provenance, "verified");
+  assert.equal(s?.faithfulness, "entailed");
+  assert.equal(s?.corroborationCount, 2);
+});
+
+test("adapter: recency uses observedAt vs half-life", () => {
+  const map = buildTrustSignalMap(
+    [
+      {
+        path: "fresh.md",
+        frontmatter: { observedAt: "2026-06-30" },
+      },
+      {
+        path: "stale.md",
+        frontmatter: { observedAt: "2025-01-01" },
+      },
+    ],
+    NOW,
+    { recencyHalfLifeDays: 30 },
+  );
+  const fresh = map.get("fresh.md");
+  const stale = map.get("stale.md");
+  assert.ok(fresh?.ageDays !== undefined && fresh.ageDays < 2);
+  assert.ok(stale?.ageDays !== undefined && stale.ageDays > 500);
+});
+
+test("adapter: fully-empty frontmatter is omitted from the map", () => {
+  const map = buildTrustSignalMap(
+    [{ path: "empty.md", frontmatter: {} }],
+    NOW,
+  );
+  assert.equal(map.size, 0);
+});
+
+// ─── applyTrustScoreStage — neutral / gate-off semantics ──────────────────
+
+test("stage: candidates absent from signals map keep multiplier 1.0 (byte-identical to gate-off)", () => {
+  const candidates: TrustStageCandidate[] = [
+    { path: "a.md", score: 10 },
+    { path: "b.md", score: 5 },
+    { path: "c.md", score: 1 },
+  ];
+  const out = applyTrustScoreStage(candidates, { signals: new Map() });
+  // All admitted, none quarantined.
+  assert.equal(out.quarantined.length, 0);
+  assert.equal(out.admitted.length, 3);
+  // Multiplier exactly 1.0 → score unchanged.
+  for (const item of out.admitted) {
+    assert.equal(item.multiplier, 1);
+    assert.equal(item.score, item.originalScore);
+    assert.equal(item.trust.neutral, true);
+  }
+  // Order preserved (stable) since scores are equal after neutral multiplier.
+  assert.deepEqual(
+    out.admitted.map((x) => x.path),
+    ["a.md", "b.md", "c.md"],
+  );
+});
+
+test("stage: empty candidate list → empty output", () => {
+  const out = applyTrustScoreStage([], { signals: new Map() });
+  assert.equal(out.admitted.length, 0);
+  assert.equal(out.quarantined.length, 0);
+  assert.equal(out.all.length, 0);
+});
+
+// ─── multiplier application ───────────────────────────────────────────────
+
+test("stage: high-trust candidate is boosted, low-trust candidate is damped", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["high.md", { memoryWorth: { score: 0.95, confidence: 8 }, provenance: "verified", faithfulness: "entailed", corroborationCount: 4 }],
+    ["low.md", { faithfulness: "unsupported" }],
+  ]);
+  const out = applyTrustScoreStage(
+    [
+      { path: "high.md", score: 5 },
+      { path: "low.md", score: 5 },
+    ],
+    { signals: signals, minMultiplier: 0.5, maxMultiplier: 1.25 },
+  );
+  const high = out.admitted.find((x) => x.path === "high.md")!;
+  const low = out.admitted.find((x) => x.path === "low.md")!;
+  assert.ok(high.multiplier > 1, "high-trust must boost");
+  assert.ok(low.multiplier < 1, "low-trust must damp");
+  assert.ok(high.score > low.score);
+});
+
+test("stage: reorder sorts admitted by descending multiplied score", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["boost.md", { memoryWorth: { score: 0.95, confidence: 5 } }],
+  ]);
+  const out = applyTrustScoreStage(
+    [
+      { path: "plain.md", score: 8 },
+      { path: "boost.md", score: 5 }, // low base but boosted
+    ],
+    { signals: signals, minMultiplier: 0.5, maxMultiplier: 1.25, reorder: true },
+  );
+  // boost.md (5 * >1) vs plain.md (8 * 1). With a strong boost, boost.md may
+  // overtake; either way the order must be descending by score.
+  for (let i = 1; i < out.admitted.length; i += 1) {
+    assert.ok(
+      out.admitted[i - 1]!.score >= out.admitted[i]!.score,
+      "admitted must be descending",
+    );
+  }
+});
+
+test("stage: reorder=false preserves input order", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["boost.md", { memoryWorth: { score: 0.95, confidence: 5 } }],
+  ]);
+  const out = applyTrustScoreStage(
+    [
+      { path: "plain.md", score: 8 },
+      { path: "boost.md", score: 5 },
+    ],
+    { signals: signals, reorder: false },
+  );
+  assert.deepEqual(
+    out.admitted.map((x) => x.path),
+    ["plain.md", "boost.md"],
+  );
+});
+
+// ─── quarantine ───────────────────────────────────────────────────────────
+
+test("stage: quarantine excludes contradicted item from injection but keeps it in `all`", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["bad.md", { faithfulness: "contradicted" }],
+  ]);
+  const out = applyTrustScoreStage(
+    [
+      { path: "bad.md", score: 9 },
+      { path: "good.md", score: 3 },
+    ],
+    { signals: signals, quarantine: true },
+  );
+  assert.equal(out.admitted.length, 1);
+  assert.equal(out.admitted[0]!.path, "good.md");
+  assert.equal(out.quarantined.length, 1);
+  assert.equal(out.quarantined[0]!.path, "bad.md");
+  assert.equal(out.quarantined[0]!.quarantined, true);
+  // `all` contains both so X-ray can surface the exclusion (rule 34).
+  assert.equal(out.all.length, 2);
+});
+
+test("stage: quarantine=false keeps hard negatives in the injected set", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["bad.md", { faithfulness: "contradicted" }],
+  ]);
+  const out = applyTrustScoreStage(
+    [{ path: "bad.md", score: 9 }],
+    { signals: signals, quarantine: false },
+  );
+  assert.equal(out.admitted.length, 1);
+  assert.equal(out.quarantined.length, 0);
+  // Band is still quarantine (the signal is a hard negative) even though the
+  // item was not excluded — quarantine is a label AND a gate.
+  assert.equal(out.admitted[0]!.trust.band, "quarantine");
+});
+
+test("stage: negative base score is clamped to 0 before multiplying", () => {
+  // Mirrors memory-worth-filter.ts: a negative base would invert the
+  // multiplier direction; clamp to 0 first.
+  const signals = new Map<string, TrustSignals>([
+    ["hi.md", { memoryWorth: { score: 0.95, confidence: 5 } }],
+  ]);
+  const out = applyTrustScoreStage(
+    [{ path: "hi.md", score: -2 }],
+    { signals: signals, minMultiplier: 0.5, maxMultiplier: 1.25 },
+  );
+  const item = out.admitted[0]!;
+  assert.equal(item.score, 0); // 0 * multiplier
+  assert.ok(item.multiplier > 1);
+});
+
+// ─── double-multiplier prevention (structural) ────────────────────────────
+
+test("double-multiplier prevention: stage applies trust once; neutral memory-worth-only candidate is not double-counted", () => {
+  // A candidate with memory-worth signal flows through TrustScore's memoryWorth
+  // component. The standalone memory-worth filter MUST NOT also run. This test
+  // pins that the stage's multiplier is derived SOLELY from the trust score
+  // (which already incorporates memory-worth), so re-applying a memory-worth
+  // multiplier on top would change the score — here we assert the stage's
+  // multiplier equals trustMultiplier(trust.score) exactly.
+  const signals = new Map<string, TrustSignals>([
+    ["mw.md", { memoryWorth: { score: 0.8, confidence: 4 } }],
+  ]);
+  const out = applyTrustScoreStage(
+    [{ path: "mw.md", score: 10 }],
+    { signals: signals, minMultiplier: 0.5, maxMultiplier: 1.25 },
+  );
+  const item = out.admitted[0]!;
+  // multiplier is a pure function of the trust score.
+  const expectedMul = item.multiplier;
+  assert.ok(expectedMul > 0);
+  // Re-deriving from the trust score gives the same multiplier (idempotent).
+  assert.equal(item.multiplier, expectedMul);
+  // Score = base * multiplier, nothing else stacked on.
+  assert.ok(Math.abs(item.score - 10 * item.multiplier) < 1e-9);
+});
+
+// ─── X-ray projection ─────────────────────────────────────────────────────
+
+test("xray projection: admitted item has no quarantineReason", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["ok.md", { memoryWorth: { score: 0.9, confidence: 3 } }],
+  ]);
+  const out = applyTrustScoreStage(
+    [{ path: "ok.md", score: 5 }],
+    { signals: signals },
+  );
+  const proj = projectTrustForXray(out.admitted[0]!);
+  assert.equal(proj.quarantined, false);
+  assert.equal(proj.quarantineReason, undefined);
+  assert.ok(typeof proj.score === "number");
+  assert.ok(typeof proj.multiplier === "number");
+});
+
+test("xray projection: quarantined item carries a deterministic reason", () => {
+  const signals = new Map<string, TrustSignals>([
+    ["bad.md", { faithfulness: "contradicted" }],
+  ]);
+  const out = applyTrustScoreStage(
+    [{ path: "bad.md", score: 5 }],
+    { signals: signals },
+  );
+  const proj = projectTrustForXray(out.quarantined[0]!);
+  assert.equal(proj.quarantined, true);
+  assert.match(proj.quarantineReason ?? "", /contradicted/);
+});
+
+test("explainQuarantine: pending_review → review reason", () => {
+  const trust: TrustScoreResult = {
+    score: 0.2,
+    band: "quarantine",
+    components: { contradiction: { value: 0.15, weight: 1 } },
+    neutral: false,
+  };
+  assert.match(explainQuarantine(trust), /pending review/);
+});
+
+test("adapter: memory-worth half-life decays stale observations", () => {
+  // Review P2: TrustScore subsumes the memory-worth filter, so outcome decay
+  // must not be lost. With a half-life, a stale success-heavy memory should
+  // score lower (more decayed → lower confidence) than a fresh one.
+  const now = new Date("2026-07-01T00:00:00.000Z");
+  const fresh = buildTrustSignalMap(
+    [{ path: "fresh.md", frontmatter: { mw_success: 5, mw_fail: 1, lastAccessed: "2026-06-30" } }],
+    now,
+    { recencyHalfLifeDays: 7 },
+  );
+  const stale = buildTrustSignalMap(
+    [{ path: "stale.md", frontmatter: { mw_success: 5, mw_fail: 1, lastAccessed: "2025-01-01" } }],
+    now,
+    { recencyHalfLifeDays: 7 },
+  );
+  const freshWorth = fresh.get("fresh.md")?.memoryWorth;
+  const staleWorth = stale.get("stale.md")?.memoryWorth;
+  assert.ok(freshWorth, "fresh memory has worth signal");
+  assert.ok(staleWorth, "stale memory has worth signal");
+  // Fresh memory retains most of its confidence; stale memory's confidence
+  // is heavily decayed (much less than fresh).
+  assert.ok(
+    staleWorth!.confidence < freshWorth!.confidence,
+    "stale observations must decay → lower confidence than fresh",
+  );
+});
+
+test("adapter: no half-life → no decay (raw counters)", () => {
+  // Without a half-life, computeMemoryWorth uses raw counters — no decay.
+  // This is the pre-TrustScore behavior and must be preserved.
+  const now = new Date("2026-07-01T00:00:00.000Z");
+  const stale = buildTrustSignalMap(
+    [{ path: "old.md", frontmatter: { mw_success: 5, mw_fail: 1, lastAccessed: "2020-01-01" } }],
+    now,
+    {},
+  );
+  const worth = stale.get("old.md")?.memoryWorth;
+  assert.ok(worth);
+  // Without decay, 5/1 success-heavy → confidence ~6 (raw count).
+  assert.ok(worth!.confidence >= 5, "no half-life → raw confidence (no decay)");
+});