@remnic/core 9.3.719 → 9.3.720

package/dist/{chunk-YTZLBBEB.js → chunk-YMPEGBLL.js}

@@ -1,9 +1,9 @@
 import {
   NamespaceStorageRouter
-} from "./chunk-DIFU33GU.js";
+} from "./chunk-JV7Q226R.js";
 import {
   namespaceCollectionName
-} from "./chunk-CTOQEZSN.js";
+} from "./chunk-IPJD7WJH.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken
@@ -204,4 +204,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-YTZLBBEB.js.map
+//# sourceMappingURL=chunk-YMPEGBLL.js.map

package/dist/chunk-YN2UN7N3.js

@@ -0,0 +1,217 @@
+// src/trust-score.ts
+var DEFAULT_TRUST_WEIGHTS = {
+  memoryWorth: 0.28,
+  provenance: 0.16,
+  faithfulness: 0.2,
+  corroboration: 0.12,
+  contradiction: 0.1,
+  domainCalibration: 0.04,
+  feedback: 0.05,
+  recency: 0.05
+};
+var TRUST_BAND_THRESHOLDS = {
+  high: 0.7,
+  medium: 0.45,
+  low: 0.2
+};
+var NEUTRAL_TRUST_SCORE = 0.5;
+function sanitizeWeight(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number") return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  if (value < 0 || value > 1) return void 0;
+  return value;
+}
+function resolveTrustWeights(override) {
+  const out = { ...DEFAULT_TRUST_WEIGHTS };
+  if (!override) return out;
+  Object.keys(DEFAULT_TRUST_WEIGHTS).forEach((key) => {
+    const v = sanitizeWeight(override[key]);
+    if (v !== void 0) out[key] = v;
+  });
+  return out;
+}
+function clampUnit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return NEUTRAL_TRUST_SCORE;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function unitValue(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  if (value < 0 || value > 1) return void 0;
+  return value;
+}
+function provenanceValue(tag) {
+  if (tag === void 0) return void 0;
+  if (tag === "verified") return 1;
+  if (tag === "unverified") return 0.5;
+  if (tag === "none") return 0.25;
+  return void 0;
+}
+function faithfulnessValue(verdict) {
+  if (verdict === void 0) return void 0;
+  if (verdict === "entailed") return 1;
+  if (verdict === "unchecked") return void 0;
+  if (verdict === "unsupported") return 0.35;
+  if (verdict === "contradicted") return 0;
+  return void 0;
+}
+function contradictionValue(status) {
+  if (status === void 0) return void 0;
+  if (status === "none") return NEUTRAL_TRUST_SCORE;
+  if (status === "resolved_kept") return 0.7;
+  if (status === "resolved_superseded") return 0.1;
+  if (status === "pending_review") return 0.15;
+  return void 0;
+}
+function feedbackValue(fb) {
+  if (fb === void 0) return void 0;
+  const up = typeof fb.up === "number" && Number.isFinite(fb.up) && fb.up >= 0 ? fb.up : 0;
+  const down = typeof fb.down === "number" && Number.isFinite(fb.down) && fb.down >= 0 ? fb.down : 0;
+  if (up === 0 && down === 0) return void 0;
+  return clampUnit((up + 1) / (up + down + 2));
+}
+function corroborationValue(count) {
+  if (count === void 0) return void 0;
+  if (typeof count !== "number" || !Number.isFinite(count) || count < 0) return void 0;
+  if (count === 0) return 0.3;
+  return clampUnit(Math.log2(1 + count) / 2);
+}
+function recencyValue(signals) {
+  if (signals.ageDays === void 0) return void 0;
+  if (typeof signals.ageDays !== "number" || !Number.isFinite(signals.ageDays) || signals.ageDays < 0)
+    return void 0;
+  const halfLife = signals.recencyHalfLifeDays;
+  if (typeof halfLife !== "number" || !Number.isFinite(halfLife) || halfLife <= 0) return void 0;
+  return clampUnit(Math.pow(2, -signals.ageDays / halfLife));
+}
+function isHardNegative(signals) {
+  if (signals.faithfulness === "contradicted") return true;
+  if (signals.contradiction === "pending_review") return true;
+  return false;
+}
+function computeTrustScore(signals = {}, weights = DEFAULT_TRUST_WEIGHTS) {
+  const resolved = resolveTrustWeights(weights);
+  const candidates = [];
+  const push = (key, value) => {
+    if (value === void 0) return;
+    candidates.push({ key, value: clampUnit(value) });
+  };
+  push("memoryWorth", signals.memoryWorth ? clampUnit(signals.memoryWorth.score) : void 0);
+  push("provenance", provenanceValue(signals.provenance));
+  push("faithfulness", faithfulnessValue(signals.faithfulness));
+  push("corroboration", corroborationValue(signals.corroborationCount));
+  push("contradiction", contradictionValue(signals.contradiction));
+  push("domainCalibration", unitValue(signals.domainCalibration));
+  push("feedback", feedbackValue(signals.feedback));
+  push("recency", recencyValue(signals));
+  if (candidates.length === 0) {
+    return {
+      score: NEUTRAL_TRUST_SCORE,
+      band: "medium",
+      components: {},
+      neutral: true
+    };
+  }
+  const activeWeightSum = candidates.reduce((acc, c) => acc + resolved[c.key], 0);
+  if (activeWeightSum <= 0) {
+    return {
+      score: NEUTRAL_TRUST_SCORE,
+      band: "medium",
+      components: {},
+      neutral: true
+    };
+  }
+  const safeWeightSum = activeWeightSum;
+  let blended = 0;
+  const components = {};
+  for (const c of candidates) {
+    const w = resolved[c.key] / safeWeightSum;
+    blended += c.value * w;
+    components[c.key] = { value: c.value, weight: w };
+  }
+  const score = clampUnit(blended);
+  const band = bandForScore(score, isHardNegative(signals));
+  return { score, band, components, neutral: false };
+}
+function bandForScore(score, hardNegative) {
+  if (hardNegative) return "quarantine";
+  const s = clampUnit(score);
+  if (s >= TRUST_BAND_THRESHOLDS.high) return "high";
+  if (s >= TRUST_BAND_THRESHOLDS.medium) return "medium";
+  if (s >= TRUST_BAND_THRESHOLDS.low) return "low";
+  return "low";
+}
+function trustMultiplier(score, minMultiplier = 0.5, maxMultiplier = 1.25) {
+  const min = typeof minMultiplier === "number" && Number.isFinite(minMultiplier) ? minMultiplier : 0.5;
+  const max = typeof maxMultiplier === "number" && Number.isFinite(maxMultiplier) ? maxMultiplier : 1.25;
+  const lo = Math.min(min, max);
+  const hi = Math.max(min, max);
+  const s = clampUnit(score);
+  if (s === NEUTRAL_TRUST_SCORE) return 1;
+  if (s < NEUTRAL_TRUST_SCORE) {
+    const t2 = s / NEUTRAL_TRUST_SCORE;
+    return lo + (1 - lo) * t2;
+  }
+  const t = (s - NEUTRAL_TRUST_SCORE) / (1 - NEUTRAL_TRUST_SCORE);
+  return 1 + (hi - 1) * t;
+}
+function renderEpistemicHedge(result) {
+  if (result.neutral) return "";
+  switch (result.band) {
+    case "high":
+      return "";
+    case "quarantine":
+    case "low":
+      return `(low confidence \u2014 ${describeWeakness(result.components)})`;
+    case "medium":
+      return `(unconfirmed \u2014 ${describeWeakness(result.components)})`;
+    default:
+      return "";
+  }
+}
+function describeWeakness(components) {
+  const parts = [];
+  const f = components.faithfulness;
+  if (f && f.value <= 0.35) parts.push(f.value === 0 ? "contradicted" : "unsupported");
+  const c = components.contradiction;
+  if (c && c.value <= 0.2) parts.push("under review");
+  const cor = components.corroboration;
+  if (cor && cor.value <= 0.4) parts.push("single mention");
+  const prov = components.provenance;
+  if (prov && prov.value <= 0.3) parts.push("unprovenanced");
+  const rec = components.recency;
+  if (rec && rec.value <= 0.3) parts.push("stale");
+  if (parts.length === 0) {
+    let weakest = null;
+    for (const [key, comp] of Object.entries(components)) {
+      if (!weakest || comp.value < weakest.value) weakest = { key, value: comp.value };
+    }
+    if (weakest) parts.push(`weak ${humanizeComponentName(weakest.key)}`);
+  }
+  return parts.slice(0, 2).join(", ");
+}
+function humanizeComponentName(key) {
+  switch (key) {
+    case "memoryWorth":
+      return "outcome history";
+    case "domainCalibration":
+      return "domain calibration";
+    default:
+      return key;
+  }
+}
+
+export {
+  DEFAULT_TRUST_WEIGHTS,
+  TRUST_BAND_THRESHOLDS,
+  NEUTRAL_TRUST_SCORE,
+  resolveTrustWeights,
+  computeTrustScore,
+  bandForScore,
+  trustMultiplier,
+  renderEpistemicHedge
+};
+//# sourceMappingURL=chunk-YN2UN7N3.js.map

package/dist/chunk-YN2UN7N3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/trust-score.ts"],"sourcesContent":["/**\n * trust-score.ts — unified TrustScore pure module (issue #1577 PR 1).\n *\n * Combines the trust-relevant signals Remnic already computes — memory worth\n * (Laplace-smoothed outcome probability + recency decay), provenance strength,\n * faithfulness verdict, corroboration count, contradiction status, and optional\n * domain calibration — into ONE deterministic score in `[0, 1]` plus a band\n * (`high` / `medium` / `low` / `quarantine`) and a fully-explained component\n * breakdown for X-ray.\n *\n * Contract rules (mirror the battle-tested `memory-worth.ts` \"corrupt inputs\n * fail safely\" header — read it before changing anything here):\n *\n *   1. **No signals → neutral.** An empty `TrustSignals` yields score `0.5`,\n *      band `medium`, and a recall multiplier of exactly `1.0`. Uninstrumented\n *      memories are NEVER penalized (rule 39 — byte-identical ranking when the\n *      feature is off; neutral prior when on but a memory has no data).\n *   2. **Corrupt / out-of-range component → that component collapses to\n *      neutral**, never to an extreme. A `NaN` weight or a `corroborationCount`\n *      of `-3` is treated as \"no signal\", not as damning evidence. Precedent:\n *      `memory-worth.ts` `classifyCounter`.\n *   3. **Deterministic.** Same inputs → identical result. All weights come from\n *      the caller (config); no wall clock, no RNG, no hidden constants.\n *   4. **Explainable.** Every active component is echoed in the result with its\n *      normalized weight and contribution, so X-ray can render the basis\n *      without re-deriving the math.\n *   5. **`quarantine` is reserved for hard negatives** — `faithfulness:\n *      \"contradicted\"` or `contradiction: \"pending_review\"`. Quarantined items\n *      are excluded from injection but MUST stay visible in X-ray with the\n *      reason (rule 34 — exclusion must never look like \"no result\").\n *\n * This module is deliberately framework-free: it takes already-collected\n * signals and config weights, returns a score. The signal ADAPTERS (reading\n * frontmatter / counters / review queues) live in `trust-score-stage.ts` so\n * this file stays pure and trivially property-testable.\n */\n\n/**\n * Per-component weights. Defined canonically in `types.ts` (the PluginConfig\n * home) and re-exported here so callers of the pure scorer don't need a second\n * import path. Every field is optional and defaults to\n * `DEFAULT_TRUST_WEIGHTS`; weights are sum-normalized at score time, so only\n * their relative magnitudes matter (rule 51: invalid weight rejected at config\n * parse, here we only defend against runtime corruption).\n */\nexport type { TrustWeights } from \"./types.js\";\nimport type { TrustWeights } from \"./types.js\";\n\n/**\n * Default per-component weights. Chosen so that, with all signals at neutral,\n * the score is exactly `0.5`. Sum-normalized at compute time. These are the\n * documented defaults; operators override via `trustScore.weights.*` config.\n */\nexport const DEFAULT_TRUST_WEIGHTS: Required<TrustWeights> = {\n  memoryWorth: 0.28,\n  provenance: 0.16,\n  faithfulness: 0.20,\n  corroboration: 0.12,\n  contradiction: 0.10,\n  domainCalibration: 0.04,\n  feedback: 0.05,\n  recency: 0.05,\n};\n\n/**\n * All trust-relevant signals for ONE memory. Every field is optional — the\n * scorer degrades to neutral for any absent or corrupt signal (rule 34).\n */\nexport interface TrustSignals {\n  /** Memory-worth result (Laplace success prob + confidence). */\n  memoryWorth?: { score: number; confidence: number };\n  /** Thumbs feedback tallies. */\n  feedback?: { up: number; down: number };\n  /** Contradiction review queue status. */\n  contradiction?: \"none\" | \"pending_review\" | \"resolved_kept\" | \"resolved_superseded\";\n  /** Claim-level provenance strength (#1575). */\n  provenance?: \"verified\" | \"unverified\" | \"none\";\n  /** Faithfulness gate verdict (#1576). */\n  faithfulness?: \"entailed\" | \"contradicted\" | \"unsupported\" | \"unchecked\";\n  /** Count of distinct source turns/sessions corroborating the fact. */\n  corroborationCount?: number;\n  /** Belief-ledger accuracy for the memory's domain, `0..1`. */\n  domainCalibration?: number;\n  /** Age in days vs a per-category half-life (caller computes). */\n  ageDays?: number;\n  /** Half-life (days) for recency decay; the caller supplies the per-category value. */\n  recencyHalfLifeDays?: number;\n}\n\n/** Trust band, coarse-grained for injection hedging and X-ray grouping. */\nexport type TrustBand = \"high\" | \"medium\" | \"low\" | \"quarantine\";\n\n/**\n * One component's contribution to the final score, for full explainability.\n * `value` is the normalized `[0,1]` signal contribution; `weight` is the\n * sum-normalized weight that was applied.\n */\nexport interface TrustScoreComponent {\n  value: number;\n  weight: number;\n}\n\n/**\n * Full TrustScore result. `score` is the weighted blend in `[0,1]`; `band` is\n * the coarse category; `components` echoes every active component so X-ray /\n * epistemic rendering can explain the basis without re-deriving it.\n */\nexport interface TrustScoreResult {\n  score: number;\n  band: TrustBand;\n  components: Record<string, TrustScoreComponent>;\n  /**\n   * `true` when the result is the neutral prior (no usable signals). Lets the\n   * multiplier short-circuit to exactly `1.0` and the epistemic renderer skip\n   * the hedge for the common uninstrumented case.\n   */\n  neutral: boolean;\n}\n\n/** Band thresholds on the blended score. */\nexport const TRUST_BAND_THRESHOLDS = {\n  high: 0.7,\n  medium: 0.45,\n  low: 0.2,\n} as const;\n\n/** Neutral prior: the score an empty-signal memory receives. */\nexport const NEUTRAL_TRUST_SCORE = 0.5;\n\n/**\n * Validate a single weight: a finite number in `[0, 1]`. Returns the value or\n * `undefined` when corrupt (the caller falls back to the default).\n */\nfunction sanitizeWeight(value: number | undefined): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\") return undefined;\n  if (!Number.isFinite(value)) return undefined;\n  if (value < 0 || value > 1) return undefined;\n  return value;\n}\n\n/**\n * Merge caller weights over the defaults, dropping corrupt entries. Exposed for\n * config parse so an invalid weight is rejected once at the boundary (rule 51\n * spirit) — but the scorer defends again here so a hand-built bench fixture\n * cannot poison the math.\n */\nexport function resolveTrustWeights(\n  override: Readonly<TrustWeights> | undefined,\n): Required<TrustWeights> {\n  const out: Required<TrustWeights> = { ...DEFAULT_TRUST_WEIGHTS };\n  if (!override) return out;\n  (Object.keys(DEFAULT_TRUST_WEIGHTS) as Array<keyof TrustWeights>).forEach((key) => {\n    const v = sanitizeWeight(override[key]);\n    if (v !== undefined) out[key] = v;\n  });\n  return out;\n}\n\n/** Clamp a value to `[0,1]`; NaN/Infinity collapse to the neutral `0.5`. */\nfunction clampUnit(value: number): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return NEUTRAL_TRUST_SCORE;\n  if (value < 0) return 0;\n  if (value > 1) return 1;\n  return value;\n}\n\n/**\n * Coerce an already-`[0,1]` signal (domain calibration, etc.) for the scorer.\n * Returns `undefined` when absent or corrupt so the component is DROPPED — a\n * single corrupt signal must not be read as damning evidence nor as a neutral\n * contribution that masquerades as \"we measured this\". Mirrors the\n * `classifyCounter` precedent from `memory-worth.ts`.\n */\nfunction unitValue(value: number | undefined): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return undefined;\n  if (value < 0 || value > 1) return undefined;\n  return value;\n}\n\n/** Map a provenance tag to a `[0,1]` contribution. Absent → neutral. */\nfunction provenanceValue(tag: TrustSignals[\"provenance\"]): number | undefined {\n  if (tag === undefined) return undefined;\n  if (tag === \"verified\") return 1;\n  if (tag === \"unverified\") return 0.5;\n  // \"none\" is meaningful negative evidence (no surviving source span), not\n  // neutral. It pulls toward 0 but gently so a single unprovenanced fact is\n  // not damned on its own.\n  if (tag === \"none\") return 0.25;\n  return undefined;\n}\n\n/** Map a faithfulness verdict to a `[0,1]` contribution. Absent → dropped. */\nfunction faithfulnessValue(verdict: TrustSignals[\"faithfulness\"]): number | undefined {\n  if (verdict === undefined) return undefined;\n  if (verdict === \"entailed\") return 1;\n  // \"unchecked\" means the gate ran but could not verify — it carries NO signal.\n  // Return undefined (absent) so a memory whose ONLY signal is unchecked\n  // faithfulness scores truly neutral, not \"active 0.5\". This stops the\n  // epistemic hedge from spuriously firing on unverifiable memories (review\n  // Oqg_0: unchecked-as-absent for hedging) and stops the component from\n  // masquerading as measured evidence.\n  if (verdict === \"unchecked\") return undefined;\n  if (verdict === \"unsupported\") return 0.35;\n  // \"contradicted\" is a hard negative — it also forces quarantine (see below),\n  // but as a component it contributes 0 so the blended score sinks.\n  if (verdict === \"contradicted\") return 0;\n  return undefined;\n}\n\n/** Map contradiction review status to a `[0,1]` contribution. */\nfunction contradictionValue(\n  status: TrustSignals[\"contradiction\"],\n): number | undefined {\n  if (status === undefined) return undefined;\n  if (status === \"none\") return NEUTRAL_TRUST_SCORE;\n  if (status === \"resolved_kept\") return 0.7;\n  if (status === \"resolved_superseded\") return 0.1;\n  if (status === \"pending_review\") return 0.15;\n  return undefined;\n}\n\n/** Feedback balance → `[0,1]` via Laplace smoothing (mirrors memory-worth). */\nfunction feedbackValue(fb: TrustSignals[\"feedback\"]): number | undefined {\n  if (fb === undefined) return undefined;\n  const up = typeof fb.up === \"number\" && Number.isFinite(fb.up) && fb.up >= 0 ? fb.up : 0;\n  const down =\n    typeof fb.down === \"number\" && Number.isFinite(fb.down) && fb.down >= 0 ? fb.down : 0;\n  if (up === 0 && down === 0) return undefined;\n  // Laplace: (up+1)/(up+down+2). Clamped defensively.\n  return clampUnit((up + 1) / (up + down + 2));\n}\n\n/** Corroboration count → `[0,1]` via log-saturation (3+ sources ≈ 1.0). */\nfunction corroborationValue(count: TrustSignals[\"corroborationCount\"]): number | undefined {\n  if (count === undefined) return undefined;\n  if (typeof count !== \"number\" || !Number.isFinite(count) || count < 0) return undefined;\n  if (count === 0) return 0.3; // single mention is mild negative evidence vs neutral\n  // log2(1 + count) saturates: 1→0.5, 2→0.63, 3→0.66, 4→0.68 ... capped at 1.\n  return clampUnit(Math.log2(1 + count) / 2);\n}\n\n/** Recency decay vs a half-life, mapped so \"fresh\" → high, \"stale\" → low. */\nfunction recencyValue(signals: TrustSignals): number | undefined {\n  if (signals.ageDays === undefined) return undefined;\n  if (typeof signals.ageDays !== \"number\" || !Number.isFinite(signals.ageDays) || signals.ageDays < 0)\n    return undefined;\n  const halfLife = signals.recencyHalfLifeDays;\n  if (typeof halfLife !== \"number\" || !Number.isFinite(halfLife) || halfLife <= 0) return undefined;\n  // 2^(-age/halfLife): age 0 → 1, age=halfLife → 0.5, age≫halfLife → ~0.\n  return clampUnit(Math.pow(2, -signals.ageDays / halfLife));\n}\n\n/**\n * Determine whether the signals warrant the `quarantine` band: a hard negative\n * that excludes the item from injection (but never from X-ray — rule 34).\n */\nfunction isHardNegative(signals: TrustSignals): boolean {\n  if (signals.faithfulness === \"contradicted\") return true;\n  if (signals.contradiction === \"pending_review\") return true;\n  return false;\n}\n\n/**\n * Compute the unified TrustScore for one memory.\n *\n * Returns the neutral prior (`0.5`, band `medium`, `neutral: true`) when no\n * usable signal is present, so uninstrumented memories are untouched.\n */\nexport function computeTrustScore(\n  signals: TrustSignals = {},\n  weights: Readonly<TrustWeights> = DEFAULT_TRUST_WEIGHTS,\n): TrustScoreResult {\n  const resolved = resolveTrustWeights(weights);\n\n  // Build the (component → value) map, skipping absent/corrupt signals.\n  // Each value is already clamped to [0,1] by its mapper.\n  const candidates: Array<{ key: keyof TrustWeights; value: number }> = [];\n  const push = (key: keyof TrustWeights, value: number | undefined) => {\n    if (value === undefined) return;\n    candidates.push({ key, value: clampUnit(value) });\n  };\n\n  push(\"memoryWorth\", signals.memoryWorth ? clampUnit(signals.memoryWorth.score) : undefined);\n  push(\"provenance\", provenanceValue(signals.provenance));\n  push(\"faithfulness\", faithfulnessValue(signals.faithfulness));\n  push(\"corroboration\", corroborationValue(signals.corroborationCount));\n  push(\"contradiction\", contradictionValue(signals.contradiction));\n  push(\"domainCalibration\", unitValue(signals.domainCalibration));\n  push(\"feedback\", feedbackValue(signals.feedback));\n  push(\"recency\", recencyValue(signals));\n\n  // No usable signal → neutral prior, multiplier exactly 1.0.\n  if (candidates.length === 0) {\n    return {\n      score: NEUTRAL_TRUST_SCORE,\n      band: \"medium\",\n      components: {},\n      neutral: true,\n    };\n  }\n\n  // Sum-normalize the active weights so absent components redistribute their\n  // weight to the present ones (a memory with only memory-worth data is scored\n  // purely on memory-worth, not half-scored because other signals are absent).\n  const activeWeightSum = candidates.reduce((acc, c) => acc + resolved[c.key], 0);\n  // When every present signal's weight is 0 (operator explicitly disabled\n  // the only components the memory has), fall back to the neutral prior\n  // rather than damning the memory to score 0. A disabled signal is not a\n  // negative signal — it carries no information (review P2: zero-weight).\n  if (activeWeightSum <= 0) {\n    return {\n      score: NEUTRAL_TRUST_SCORE,\n      band: \"medium\",\n      components: {},\n      neutral: true,\n    };\n  }\n  const safeWeightSum = activeWeightSum;\n\n  let blended = 0;\n  const components: Record<string, TrustScoreComponent> = {};\n  for (const c of candidates) {\n    const w = resolved[c.key] / safeWeightSum;\n    blended += c.value * w;\n    components[c.key] = { value: c.value, weight: w };\n  }\n\n  // Clamp the blend: floating-point noise can drift a hair outside [0,1].\n  const score = clampUnit(blended);\n\n  // Hard negatives are quarantined regardless of the blended score, so a\n  // corroborated-but-contradicted fact is still excluded from injection.\n  const band = bandForScore(score, isHardNegative(signals));\n\n  return { score, band, components, neutral: false };\n}\n\n/**\n * Resolve the band from the blended score, accounting for hard-negative\n * quarantine. Extracted so the thresholds live in ONE place (X-ray, injection,\n * and tests all agree on the mapping).\n */\nexport function bandForScore(score: number, hardNegative: boolean): TrustBand {\n  if (hardNegative) return \"quarantine\";\n  const s = clampUnit(score);\n  if (s >= TRUST_BAND_THRESHOLDS.high) return \"high\";\n  if (s >= TRUST_BAND_THRESHOLDS.medium) return \"medium\";\n  if (s >= TRUST_BAND_THRESHOLDS.low) return \"low\";\n  return \"low\";\n}\n\n/**\n * Map a `[0,1]` trust score to a recall multiplier in\n * `[minMultiplier, maxMultiplier]`. The neutral prior (`0.5`) maps to exactly\n * `1.0` so uninstrumented memories are untouched. Linear interpolation centered\n * at neutral:\n *\n *   score < 0.5 → multiplier in [min, 1)\n *   score = 0.5 → 1.0\n *   score > 0.5 → multiplier in (1, max]\n */\nexport function trustMultiplier(\n  score: number,\n  minMultiplier: number = 0.5,\n  maxMultiplier: number = 1.25,\n): number {\n  const min = typeof minMultiplier === \"number\" && Number.isFinite(minMultiplier) ? minMultiplier : 0.5;\n  const max = typeof maxMultiplier === \"number\" && Number.isFinite(maxMultiplier) ? maxMultiplier : 1.25;\n  // Defend against an inverted contract (min > max): pick the tighter bound.\n  const lo = Math.min(min, max);\n  const hi = Math.max(min, max);\n  const s = clampUnit(score);\n  if (s === NEUTRAL_TRUST_SCORE) return 1;\n  if (s < NEUTRAL_TRUST_SCORE) {\n    // Map [0, 0.5) → [lo, 1). score 0 → lo, score →0.5 → 1.\n    const t = s / NEUTRAL_TRUST_SCORE; // [0,1)\n    return lo + (1 - lo) * t;\n  }\n  // Map (0.5, 1] → (1, hi]. score 0.5 → 1, score 1 → hi.\n  const t = (s - NEUTRAL_TRUST_SCORE) / (1 - NEUTRAL_TRUST_SCORE); // (0,1]\n  return 1 + (hi - 1) * t;\n}\n\n/**\n * Deterministic epistemic hedge suffix for an injected memory line, generated\n * from the trust components (template, not LLM). Returns the empty string for\n * the `high` band and for neutral results so the common case wastes no tokens.\n *\n * Examples:\n *   high    → \"\"\n *   medium  → \"(unconfirmed — single mention, 2025-11)\"\n *   low     → \"(low confidence — contradicted once, uncorroborated)\"\n */\nexport function renderEpistemicHedge(result: TrustScoreResult): string {\n  if (result.neutral) return \"\";\n  switch (result.band) {\n    case \"high\":\n      return \"\";\n    case \"quarantine\":\n    case \"low\":\n      return `(low confidence — ${describeWeakness(result.components)})`;\n    case \"medium\":\n      return `(unconfirmed — ${describeWeakness(result.components)})`;\n    default:\n      return \"\";\n  }\n}\n\n/**\n * Build a short, deterministic weakness description from the components. Reads\n * the lowest-contributing signals so the hedge names the actual reason the\n * model should hedge. Pure and order-stable.\n */\nfunction describeWeakness(components: Record<string, TrustScoreComponent>): string {\n  const parts: string[] = [];\n  const f = components.faithfulness;\n  if (f && f.value <= 0.35) parts.push(f.value === 0 ? \"contradicted\" : \"unsupported\");\n  const c = components.contradiction;\n  if (c && c.value <= 0.2) parts.push(\"under review\");\n  const cor = components.corroboration;\n  if (cor && cor.value <= 0.4) parts.push(\"single mention\");\n  const prov = components.provenance;\n  if (prov && prov.value <= 0.3) parts.push(\"unprovenanced\");\n  const rec = components.recency;\n  if (rec && rec.value <= 0.3) parts.push(\"stale\");\n  if (parts.length === 0) {\n    // No single component is weak but the blend is below high — name the\n    // weakest one explicitly so the hedge is never vacuous.\n    let weakest: { key: string; value: number } | null = null;\n    for (const [key, comp] of Object.entries(components)) {\n      if (!weakest || comp.value < weakest.value) weakest = { key, value: comp.value };\n    }\n    if (weakest) parts.push(`weak ${humanizeComponentName(weakest.key)}`);\n  }\n  return parts.slice(0, 2).join(\", \");\n}\n\nfunction humanizeComponentName(key: string): string {\n  switch (key) {\n    case \"memoryWorth\":\n      return \"outcome history\";\n    case \"domainCalibration\":\n      return \"domain calibration\";\n    default:\n      return key;\n  }\n}\n"],"mappings":"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","names":["t"]}

package/dist/{chunk-YI7RZO7Y.js → chunk-ZE7GJ76H.js}

@@ -216,4 +216,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-YI7RZO7Y.js.map
+//# sourceMappingURL=chunk-ZE7GJ76H.js.map

package/dist/{chunk-74MYJSKB.js → chunk-ZG2WP425.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7FL4CNPV.js";
 import {
   resolveCausalTrajectoryStoreDir
-} from "./chunk-YI7RZO7Y.js";
+} from "./chunk-ZE7GJ76H.js";
 import {
   normalizeRecallTokens
 } from "./chunk-ZBJMUXZH.js";
@@ -339,4 +339,4 @@ export {
   scoreStitchCandidate,
   stitchCausalChain
 };
-//# sourceMappingURL=chunk-74MYJSKB.js.map
+//# sourceMappingURL=chunk-ZG2WP425.js.map

package/dist/{chunk-A5TUPZ3N.js → chunk-ZKUW2MJG.js}

@@ -1961,6 +1961,27 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
       const n = coerceNumber(cfg.recallMemoryWorthHalfLifeMs);
       return n !== void 0 && n >= 0 ? n : 0;
     })(),
+    // Unified TrustScore recall stage (issue #1577). Default off: the stage
+    // is absent and ranking is byte-identical to the pre-feature pipeline
+    // (rule 39). Flip the master gate via #1574 ablation evidence only.
+    trustScoreEnabled: coerceBool(cfg.trustScoreEnabled) ?? false,
+    // Epistemic rendering ships behind its own gate so scoring can land first.
+    trustScoreEpistemicRendering: coerceBool(cfg.trustScoreEpistemicRendering) ?? false,
+    // Quarantine defaults on (only effective under the master gate); keeps
+    // hard negatives out of injection but visible in X-ray (rule 34).
+    trustScoreQuarantine: coerceBool(cfg.trustScoreQuarantine) ?? true,
+    trustScoreMinMultiplier: (() => {
+      const n = coerceNumber(cfg.trustScoreMinMultiplier);
+      return n !== void 0 && n >= 0 && n <= 1 ? n : 0.5;
+    })(),
+    trustScoreMaxMultiplier: (() => {
+      const n = coerceNumber(cfg.trustScoreMaxMultiplier);
+      return n !== void 0 && n >= 1 && n <= 4 ? n : 1.25;
+    })(),
+    // Per-component weights. Accept a nested object from config; invalid
+    // entries (non-finite, outside [0,1]) are dropped by resolveTrustWeights,
+    // which falls back to the documented defaults (rule 51).
+    trustScoreWeights: parseTrustScoreWeights(cfg.trustScoreWeights),
     // Memory Linking (Phase 3A)
     memoryLinkingEnabled: cfg.memoryLinkingEnabled === true,
     // Off by default initially
@@ -3362,6 +3383,27 @@ function buildRecallPipelineConfig(cfg) {
   const pipeline = Array.isArray(rawPipeline) ? rawPipeline.map(parseRecallSectionEntry).filter((entry) => entry.id.length > 0) : buildDefaultRecallPipeline(cfg);
   return { recallBudgetChars, pipeline };
 }
+function parseTrustScoreWeights(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const src = value;
+  const out = {};
+  const keys = [
+    "memoryWorth",
+    "provenance",
+    "faithfulness",
+    "corroboration",
+    "contradiction",
+    "domainCalibration",
+    "feedback",
+    "recency"
+  ];
+  for (const key of keys) {
+    const raw = src[key];
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0 || raw > 1) continue;
+    out[key] = raw;
+  }
+  return out;
+}
 
 export {
   KNOWN_WEARABLE_SOURCE_IDS,
@@ -3375,4 +3417,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-A5TUPZ3N.js.map
+//# sourceMappingURL=chunk-ZKUW2MJG.js.map