@remnic/core 9.65.5 → 9.65.7

package/dist/{chunk-4JSF7UUP.js → chunk-S3K2CIK5.js}

@@ -1,7 +1,7 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-CV3GNPOE.js";
+} from "./chunk-RQE4TITU.js";
 import {
   SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
 } from "./chunk-XDL5CYZN.js";
@@ -343,4 +343,4 @@ export {
   parseSupportPassportModelJob,
   SupportPassportModelBridge
 };
-//# sourceMappingURL=chunk-4JSF7UUP.js.map
+//# sourceMappingURL=chunk-S3K2CIK5.js.map

package/dist/chunk-SDEPLF7V.js

@@ -0,0 +1,325 @@
+import {
+  evaluateMemoryActionPolicy
+} from "./chunk-H63EDPFJ.js";
+import {
+  planRecallMode
+} from "./chunk-CSAKJVXW.js";
+
+// src/memory-controller.ts
+import { createHash, randomUUID } from "crypto";
+var NO_OP_FLOOR = 0.35;
+var REVIEW_ONLY_ACTIONS = { discard: true };
+function controllerConfigHash(config) {
+  return sha256(
+    JSON.stringify({
+      mode: config.mode,
+      reportVersion: config.reportVersion,
+      evidenceMaxAgeMs: config.evidenceMaxAgeMs,
+      minPairedSeeds: config.minPairedSeeds,
+      shadowMinRecords: config.shadowMinRecords
+    })
+  );
+}
+function hashControllerState(state) {
+  return sha256(
+    JSON.stringify({
+      prompt: state.prompt,
+      persistentMemoryCandidate: state.persistentMemoryCandidate ?? null,
+      contextMessages: state.contextMessages ?? null,
+      contextPressure: state.contextPressure ?? null
+    })
+  );
+}
+function computeEvidenceReportHash(fields) {
+  return sha256(JSON.stringify(fields));
+}
+function verifyEvidenceReport(report) {
+  return computeEvidenceReportHash({
+    status: report.status,
+    version: report.version,
+    configHash: report.configHash,
+    generatedAt: report.generatedAt
+  }) === report.reportHash;
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function clampScore(value) {
+  if (!Number.isFinite(value)) return Number.NaN;
+  return Math.max(0, Math.min(1, value));
+}
+function chooseAction(input) {
+  const { state, activeContextAdapter, runtimeValues, utilityValues } = input;
+  const recallMode = planRecallMode(state.prompt ?? "");
+  const recallScore = recallMode === "no_recall" ? 0 : recallMode === "minimal" ? 0.4 : 0.6 + 0.2 * (runtimeValues?.recencyWeight ?? 0);
+  let persistentScore = 0;
+  const candidate = state.persistentMemoryCandidate;
+  if (candidate) {
+    const policy = evaluateMemoryActionPolicy({
+      action: candidate.action,
+      eligibility: candidate.eligibility,
+      options: { actionsEnabled: true, maxCompressionTokensPerHour: Number.POSITIVE_INFINITY }
+    });
+    if (policy.decision === "allow") {
+      persistentScore = 0.4 + 0.4 * (candidate.eligibility.confidence ?? 0);
+    } else if (policy.decision === "defer") {
+      persistentScore = 0.2;
+    }
+    if (utilityValues && utilityValues.rankingSuppressMultiplier > 1) {
+      persistentScore *= 1 / utilityValues.rankingSuppressMultiplier;
+    }
+  }
+  let contextScore = 0;
+  let contextPlan = null;
+  const pressure = state.contextPressure;
+  if (activeContextAdapter && typeof pressure === "number" && Number.isFinite(pressure) && pressure > 0.5) {
+    contextPlan = activeContextAdapter.plan(state.contextMessages ?? []);
+    if (contextPlan && contextPlan.messageIds.length > 0) {
+      contextScore = 0.3 + 0.5 * Math.max(0, Math.min(1, pressure));
+    }
+  }
+  const scores = {
+    recall: clampScore(recallScore),
+    persistent_memory: clampScore(persistentScore),
+    active_context: clampScore(contextScore),
+    no_op: NO_OP_FLOOR
+  };
+  if (Object.values(scores).some((score) => !Number.isFinite(score) || score < 0 || score > 1)) {
+    return { choice: { family: "no_op" }, scores };
+  }
+  let choice = { family: "no_op" };
+  let best = scores.no_op;
+  if (scores.recall > best) {
+    best = scores.recall;
+    choice = { family: "recall", mode: recallMode };
+  }
+  if (scores.persistent_memory > best) {
+    best = scores.persistent_memory;
+    choice = {
+      family: "persistent_memory",
+      action: candidate.action,
+      eligibility: candidate.eligibility
+    };
+  }
+  if (scores.active_context > best) {
+    choice = { family: "active_context", plan: contextPlan };
+  }
+  return { choice, scores };
+}
+async function evaluateActiveGates(input) {
+  const { config, reportReader, recorder, consecutiveReceiptFailures, now } = input;
+  const reasons = [];
+  if (!reportReader) return ["no_report_reader"];
+  const evidence = await reportReader.read();
+  if (!evidence) return ["no_evidence"];
+  const { report, pairedSeed } = evidence;
+  if (report.status !== "pass") reasons.push("report_not_passing");
+  if (report.version !== config.reportVersion) reasons.push("report_version_mismatch");
+  if (report.configHash !== controllerConfigHash(config)) reasons.push("report_config_unbound");
+  if (!verifyEvidenceReport(report)) reasons.push("report_hash_invalid");
+  const reportGeneratedAt = Date.parse(report.generatedAt);
+  if (!Number.isFinite(reportGeneratedAt) || now.getTime() - reportGeneratedAt > config.evidenceMaxAgeMs) {
+    reasons.push("report_stale");
+  }
+  if (pairedSeed.status !== "pass") reasons.push("paired_seed_not_passing");
+  if (pairedSeed.seedCount < config.minPairedSeeds) reasons.push("paired_seed_count_low");
+  const seedGeneratedAt = Date.parse(pairedSeed.generatedAt);
+  if (!Number.isFinite(seedGeneratedAt) || now.getTime() - seedGeneratedAt > config.evidenceMaxAgeMs) {
+    reasons.push("paired_seed_stale");
+  }
+  const shadowRecords = recorder ? await recorder.countShadowRecords() : 0;
+  if (shadowRecords < config.shadowMinRecords) reasons.push("shadow_history_insufficient");
+  if (consecutiveReceiptFailures > 0) reasons.push("recent_receipt_failures");
+  return reasons;
+}
+var MemoryControllerCoordinator = class {
+  deps;
+  clock;
+  consecutiveReceiptFailures = 0;
+  constructor(deps) {
+    this.deps = deps;
+    this.clock = deps.clock ?? (() => /* @__PURE__ */ new Date());
+  }
+  async run(state) {
+    const decisionId = randomUUID();
+    const stateHash = hashControllerState(state);
+    const requestedMode = this.deps.config.mode;
+    if (requestedMode === "off") {
+      return {
+        decisionId,
+        requestedMode,
+        effectiveMode: "off",
+        stateHash,
+        choice: { family: "no_op" },
+        scores: { persistent_memory: 0, recall: 0, active_context: 0, no_op: 0 },
+        executed: false,
+        reviewOnly: false,
+        recorded: false,
+        demotionReasons: ["mode_off"]
+      };
+    }
+    const [runtimeValues, utilityValues] = await Promise.all([
+      this.deps.policyRuntime?.loadRuntimeValues() ?? null,
+      this.deps.readUtilityRuntime?.() ?? null
+    ]);
+    const { choice, scores } = chooseAction({
+      state,
+      activeContextAdapter: this.deps.activeContextAdapter,
+      runtimeValues,
+      utilityValues
+    });
+    let demotionReasons = [];
+    let effectiveMode = requestedMode;
+    if (requestedMode === "active") {
+      demotionReasons = await evaluateActiveGates({
+        config: this.deps.config,
+        reportReader: this.deps.reportReader,
+        recorder: this.deps.recorder,
+        consecutiveReceiptFailures: this.consecutiveReceiptFailures,
+        now: this.clock()
+      });
+      if (demotionReasons.length > 0) effectiveMode = "shadow";
+    }
+    const baseEvent = {
+      schemaVersion: 1,
+      phase: "choice",
+      decisionId,
+      timestamp: this.clock().toISOString(),
+      requestedMode,
+      effectiveMode,
+      stateHash,
+      choice,
+      scores,
+      executed: false,
+      ...demotionReasons.length > 0 ? { demotionReasons } : {}
+    };
+    let recorded = false;
+    if (this.deps.recorder) {
+      try {
+        await this.deps.recorder.record(baseEvent);
+        this.deps.telemetry?.(baseEvent);
+        recorded = true;
+      } catch {
+        return {
+          decisionId,
+          requestedMode,
+          effectiveMode,
+          stateHash,
+          choice,
+          scores,
+          executed: false,
+          reviewOnly: false,
+          recorded: false,
+          demotionReasons: [...demotionReasons, "record_failed"]
+        };
+      }
+    }
+    if (effectiveMode !== "active") {
+      return {
+        decisionId,
+        requestedMode,
+        effectiveMode,
+        stateHash,
+        choice,
+        scores,
+        executed: false,
+        reviewOnly: false,
+        recorded,
+        demotionReasons
+      };
+    }
+    if (choice.family === "persistent_memory" && REVIEW_ONLY_ACTIONS[choice.action]) {
+      const event = {
+        ...baseEvent,
+        phase: "outcome",
+        reviewOnly: true,
+        demotionReasons: ["review_only_action"]
+      };
+      await this.recordOutcome(event);
+      return {
+        decisionId,
+        requestedMode,
+        effectiveMode,
+        stateHash,
+        choice,
+        scores,
+        executed: false,
+        reviewOnly: true,
+        recorded,
+        demotionReasons
+      };
+    }
+    const receipt = await this.dispatch(choice, stateHash, decisionId, baseEvent);
+    return {
+      decisionId,
+      requestedMode,
+      effectiveMode,
+      stateHash,
+      choice,
+      scores,
+      executed: receipt?.ok === true,
+      reviewOnly: false,
+      recorded,
+      ...receipt ? { receipt } : {},
+      demotionReasons
+    };
+  }
+  async dispatch(choice, stateHash, decisionId, baseEvent) {
+    const executors = this.deps.executors ?? {};
+    try {
+      let receipt;
+      if (choice.family === "persistent_memory") {
+        if (!executors.executePersistentMemory) throw new Error("no_executor:persistent_memory");
+        receipt = await executors.executePersistentMemory({
+          decisionId,
+          action: choice.action,
+          eligibility: choice.eligibility,
+          stateHash
+        });
+      } else if (choice.family === "recall") {
+        if (!executors.executeRecall) throw new Error("no_executor:recall");
+        receipt = await executors.executeRecall({ decisionId, mode: choice.mode });
+      } else if (choice.family === "active_context") {
+        if (!executors.executeActiveContext) throw new Error("no_executor:active_context");
+        receipt = await executors.executeActiveContext({ decisionId, plan: choice.plan });
+      } else {
+        receipt = { decisionId, ok: true };
+      }
+      if (!isValidReceipt(receipt, decisionId)) {
+        this.consecutiveReceiptFailures += 1;
+        await this.recordOutcome({ ...baseEvent, phase: "outcome", failureClass: "bad_receipt" });
+        return void 0;
+      }
+      this.consecutiveReceiptFailures = 0;
+      await this.recordOutcome({ ...baseEvent, phase: "outcome", executed: receipt.ok, receipt });
+      return receipt;
+    } catch (error) {
+      this.consecutiveReceiptFailures += 1;
+      await this.recordOutcome({
+        ...baseEvent,
+        phase: "outcome",
+        failureClass: error?.message?.startsWith("no_executor:") ? "no_executor" : "executor_error"
+      });
+      return void 0;
+    }
+  }
+  async recordOutcome(event) {
+    if (!this.deps.recorder) return;
+    await this.deps.recorder.record(event);
+    this.deps.telemetry?.(event);
+  }
+};
+function isValidReceipt(receipt, decisionId) {
+  return typeof receipt === "object" && receipt !== null && receipt.decisionId === decisionId && typeof receipt.ok === "boolean";
+}
+
+export {
+  controllerConfigHash,
+  hashControllerState,
+  computeEvidenceReportHash,
+  verifyEvidenceReport,
+  chooseAction,
+  evaluateActiveGates,
+  MemoryControllerCoordinator
+};
+//# sourceMappingURL=chunk-SDEPLF7V.js.map

package/dist/chunk-SDEPLF7V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-controller.ts"],"sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\nimport { planRecallMode } from \"./intent.js\";\nimport { evaluateMemoryActionPolicy } from \"./memory-action-policy.js\";\nimport type { RuntimePolicyValues } from \"./policy-runtime.js\";\nimport type { UtilityRuntimeValues } from \"./utility-runtime.js\";\nimport type { MemoryActionEligibilityContext, MemoryActionType, RecallPlanMode } from \"./types.js\";\n\n/**\n * Gated unified memory controller (#2348).\n *\n * One state enters, one choice leaves. Host-free: every effectful collaborator\n * (adapters, executors, report reader, recorder, telemetry, clock) is injected.\n * The coordinator creates no store and claims no counterfactual lift.\n */\n\nexport type MemoryControllerMode = \"off\" | \"shadow\" | \"active\";\n\nexport type MemoryControllerActionFamily = \"persistent_memory\" | \"recall\" | \"active_context\" | \"no_op\";\n\n/** #2347 adapter seam: the host supplies plans, core only picks one. */\nexport interface ActiveContextMessage {\n  id: string;\n  text: string;\n}\n\nexport interface ActiveContextPlan {\n  transform: \"SUMMARY\" | \"FILTER\";\n  messageIds: string[];\n  planId: string;\n}\n\nexport interface ActiveContextAdapter {\n  plan(messages: ActiveContextMessage[]): ActiveContextPlan | null;\n}\n\n/** #2345 report + #2346 paired-seed evidence, read through one port. */\nexport interface MemoryControllerEvidenceReport {\n  status: \"pass\" | \"fail\";\n  version: string;\n  configHash: string;\n  generatedAt: string;\n  /** sha256 over the canonical report fields; recomputed on verification. */\n  reportHash: string;\n}\n\nexport interface MemoryControllerPairedSeedEvidence {\n  status: \"pass\" | \"fail\";\n  seedCount: number;\n  generatedAt: string;\n}\n\nexport interface MemoryControllerEvidence {\n  report: MemoryControllerEvidenceReport;\n  pairedSeed: MemoryControllerPairedSeedEvidence;\n}\n\nexport interface MemoryControllerReportReader {\n  read(): Promise<MemoryControllerEvidence | null>;\n}\n\nexport interface MemoryControllerReceipt {\n  decisionId: string;\n  ok: boolean;\n  detail?: string;\n}\n\nexport interface MemoryControllerExecutors {\n  executePersistentMemory?(input: {\n    decisionId: string;\n    action: MemoryActionType;\n    eligibility: MemoryActionEligibilityContext;\n    stateHash: string;\n  }): Promise<MemoryControllerReceipt>;\n  executeRecall?(input: { decisionId: string; mode: RecallPlanMode }): Promise<MemoryControllerReceipt>;\n  executeActiveContext?(input: {\n    decisionId: string;\n    plan: ActiveContextPlan;\n  }): Promise<MemoryControllerReceipt>;\n}\n\nexport interface MemoryControllerEvent {\n  schemaVersion: 1;\n  phase: \"choice\" | \"outcome\";\n  decisionId: string;\n  timestamp: string;\n  requestedMode: MemoryControllerMode;\n  effectiveMode: MemoryControllerMode;\n  stateHash: string;\n  choice: MemoryControllerChoice;\n  scores: Record<MemoryControllerActionFamily, number>;\n  executed: boolean;\n  reviewOnly?: boolean;\n  demotionReasons?: string[];\n  failureClass?: \"record_failed\" | \"executor_error\" | \"bad_receipt\" | \"no_executor\";\n  receipt?: MemoryControllerReceipt;\n}\n\nexport interface MemoryControllerRecorder {\n  record(event: MemoryControllerEvent): Promise<void>;\n  /** Prior shadow choice records; active promotion requires shadow history. */\n  countShadowRecords(): Promise<number>;\n}\n\nexport interface MemoryControllerConfig {\n  mode: MemoryControllerMode;\n  /** Expected #2345 report schema version. */\n  reportVersion: string;\n  /** Evidence older than this is stale and forces shadow. */\n  evidenceMaxAgeMs: number;\n  /** Paired-seed arms must cover at least this many seeds (#2346). */\n  minPairedSeeds: number;\n  /** Active promotion requires at least this many prior shadow records. */\n  shadowMinRecords: number;\n}\n\nexport interface MemoryControllerState {\n  prompt: string;\n  persistentMemoryCandidate?: {\n    action: MemoryActionType;\n    eligibility: MemoryActionEligibilityContext;\n  };\n  contextMessages?: ActiveContextMessage[];\n  /** 0..1 host-measured context pressure. */\n  contextPressure?: number;\n}\n\nexport type MemoryControllerChoice =\n  | { family: \"persistent_memory\"; action: MemoryActionType; eligibility: MemoryActionEligibilityContext }\n  | { family: \"recall\"; mode: RecallPlanMode }\n  | { family: \"active_context\"; plan: ActiveContextPlan }\n  | { family: \"no_op\" };\n\nexport interface MemoryControllerRunResult {\n  decisionId: string;\n  requestedMode: MemoryControllerMode;\n  effectiveMode: MemoryControllerMode;\n  stateHash: string;\n  choice: MemoryControllerChoice;\n  scores: Record<MemoryControllerActionFamily, number>;\n  executed: boolean;\n  reviewOnly: boolean;\n  recorded: boolean;\n  receipt?: MemoryControllerReceipt;\n  demotionReasons: string[];\n}\n\nexport interface MemoryControllerDeps {\n  config: MemoryControllerConfig;\n  reportReader?: MemoryControllerReportReader;\n  recorder?: MemoryControllerRecorder;\n  executors?: MemoryControllerExecutors;\n  activeContextAdapter?: ActiveContextAdapter;\n  policyRuntime?: { loadRuntimeValues(): Promise<RuntimePolicyValues | null> };\n  readUtilityRuntime?: () => Promise<UtilityRuntimeValues | null>;\n  telemetry?: (event: MemoryControllerEvent) => void;\n  clock?: () => Date;\n}\n\nconst NO_OP_FLOOR = 0.35;\n/** `discard` (and any destructive change) stays review-only in active mode. */\nconst REVIEW_ONLY_ACTIONS: Partial<Record<MemoryActionType, true>> = { discard: true };\n\nexport function controllerConfigHash(config: MemoryControllerConfig): string {\n  return sha256(\n    JSON.stringify({\n      mode: config.mode,\n      reportVersion: config.reportVersion,\n      evidenceMaxAgeMs: config.evidenceMaxAgeMs,\n      minPairedSeeds: config.minPairedSeeds,\n      shadowMinRecords: config.shadowMinRecords,\n    })\n  );\n}\n\nexport function hashControllerState(state: MemoryControllerState): string {\n  return sha256(\n    JSON.stringify({\n      prompt: state.prompt,\n      persistentMemoryCandidate: state.persistentMemoryCandidate ?? null,\n      contextMessages: state.contextMessages ?? null,\n      contextPressure: state.contextPressure ?? null,\n    })\n  );\n}\n\n/** Canonical #2345 report hash; producers sign with this, the controller verifies. */\nexport function computeEvidenceReportHash(fields: {\n  status: MemoryControllerEvidenceReport[\"status\"];\n  version: string;\n  configHash: string;\n  generatedAt: string;\n}): string {\n  return sha256(JSON.stringify(fields));\n}\n\n/** Verifies the #2345 report hash over its canonical fields. */\nexport function verifyEvidenceReport(report: MemoryControllerEvidenceReport): boolean {\n  return (\n    computeEvidenceReportHash({\n      status: report.status,\n      version: report.version,\n      configHash: report.configHash,\n      generatedAt: report.generatedAt,\n    }) === report.reportHash\n  );\n}\n\nfunction sha256(input: string): string {\n  return createHash(\"sha256\").update(input).digest(\"hex\");\n}\n\nfunction clampScore(value: number): number {\n  if (!Number.isFinite(value)) return Number.NaN;\n  return Math.max(0, Math.min(1, value));\n}\n\n/**\n * Bad scores fail closed to `no_op`.\n */\nexport function chooseAction(input: {\n  state: MemoryControllerState;\n  activeContextAdapter?: ActiveContextAdapter;\n  runtimeValues?: RuntimePolicyValues | null;\n  utilityValues?: UtilityRuntimeValues | null;\n}): { choice: MemoryControllerChoice; scores: Record<MemoryControllerActionFamily, number> } {\n  const { state, activeContextAdapter, runtimeValues, utilityValues } = input;\n\n  // recall: current recall path.\n  const recallMode = planRecallMode(state.prompt ?? \"\");\n  const recallScore =\n    recallMode === \"no_recall\" ? 0 : recallMode === \"minimal\" ? 0.4 : 0.6 + 0.2 * (runtimeValues?.recencyWeight ?? 0);\n\n  // persistent_memory: current action path + policy.\n  let persistentScore = 0;\n  const candidate = state.persistentMemoryCandidate;\n  if (candidate) {\n    const policy = evaluateMemoryActionPolicy({\n      action: candidate.action,\n      eligibility: candidate.eligibility,\n      options: { actionsEnabled: true, maxCompressionTokensPerHour: Number.POSITIVE_INFINITY },\n    });\n    if (policy.decision === \"allow\") {\n      persistentScore = 0.4 + 0.4 * (candidate.eligibility.confidence ?? 0);\n    } else if (policy.decision === \"defer\") {\n      persistentScore = 0.2;\n    }\n    // Utility runtime may suppress the persistent family.\n    if (utilityValues && utilityValues.rankingSuppressMultiplier > 1) {\n      persistentScore *= 1 / utilityValues.rankingSuppressMultiplier;\n    }\n  }\n\n  // active_context: current context path through the #2347 adapter.\n  let contextScore = 0;\n  let contextPlan: ActiveContextPlan | null = null;\n  const pressure = state.contextPressure;\n  if (activeContextAdapter && typeof pressure === \"number\" && Number.isFinite(pressure) && pressure > 0.5) {\n    contextPlan = activeContextAdapter.plan(state.contextMessages ?? []);\n    if (contextPlan && contextPlan.messageIds.length > 0) {\n      contextScore = 0.3 + 0.5 * Math.max(0, Math.min(1, pressure));\n    }\n  }\n\n  const scores: Record<MemoryControllerActionFamily, number> = {\n    recall: clampScore(recallScore),\n    persistent_memory: clampScore(persistentScore),\n    active_context: clampScore(contextScore),\n    no_op: NO_OP_FLOOR,\n  };\n\n  // Bad scores fail closed.\n  if (Object.values(scores).some((score) => !Number.isFinite(score) || score < 0 || score > 1)) {\n    return { choice: { family: \"no_op\" }, scores };\n  }\n\n  let choice: MemoryControllerChoice = { family: \"no_op\" };\n  let best = scores.no_op;\n  if (scores.recall > best) {\n    best = scores.recall;\n    choice = { family: \"recall\", mode: recallMode };\n  }\n  if (scores.persistent_memory > best) {\n    best = scores.persistent_memory;\n    choice = {\n      family: \"persistent_memory\",\n      action: candidate!.action,\n      eligibility: candidate!.eligibility,\n    };\n  }\n  if (scores.active_context > best) {\n    choice = { family: \"active_context\", plan: contextPlan! };\n  }\n  return { choice, scores };\n}\n\n/** Returns the demotion reasons when active-mode gates fail; empty means go. */\nexport async function evaluateActiveGates(input: {\n  config: MemoryControllerConfig;\n  reportReader?: MemoryControllerReportReader;\n  recorder?: MemoryControllerRecorder;\n  consecutiveReceiptFailures: number;\n  now: Date;\n}): Promise<string[]> {\n  const { config, reportReader, recorder, consecutiveReceiptFailures, now } = input;\n  const reasons: string[] = [];\n\n  if (!reportReader) return [\"no_report_reader\"];\n\n  const evidence = await reportReader.read();\n  if (!evidence) return [\"no_evidence\"];\n\n  const { report, pairedSeed } = evidence;\n  if (report.status !== \"pass\") reasons.push(\"report_not_passing\");\n  if (report.version !== config.reportVersion) reasons.push(\"report_version_mismatch\");\n  if (report.configHash !== controllerConfigHash(config)) reasons.push(\"report_config_unbound\");\n  if (!verifyEvidenceReport(report)) reasons.push(\"report_hash_invalid\");\n  const reportGeneratedAt = Date.parse(report.generatedAt);\n  if (!Number.isFinite(reportGeneratedAt) || now.getTime() - reportGeneratedAt > config.evidenceMaxAgeMs) {\n    reasons.push(\"report_stale\");\n  }\n\n  if (pairedSeed.status !== \"pass\") reasons.push(\"paired_seed_not_passing\");\n  if (pairedSeed.seedCount < config.minPairedSeeds) reasons.push(\"paired_seed_count_low\");\n  const seedGeneratedAt = Date.parse(pairedSeed.generatedAt);\n  if (!Number.isFinite(seedGeneratedAt) || now.getTime() - seedGeneratedAt > config.evidenceMaxAgeMs) {\n    reasons.push(\"paired_seed_stale\");\n  }\n\n  const shadowRecords = recorder ? await recorder.countShadowRecords() : 0;\n  if (shadowRecords < config.shadowMinRecords) reasons.push(\"shadow_history_insufficient\");\n\n  if (consecutiveReceiptFailures > 0) reasons.push(\"recent_receipt_failures\");\n\n  return reasons;\n}\n\nexport class MemoryControllerCoordinator {\n  private readonly deps: MemoryControllerDeps;\n  private readonly clock: () => Date;\n  private consecutiveReceiptFailures = 0;\n\n  constructor(deps: MemoryControllerDeps) {\n    this.deps = deps;\n    this.clock = deps.clock ?? (() => new Date());\n  }\n\n  async run(state: MemoryControllerState): Promise<MemoryControllerRunResult> {\n    const decisionId = randomUUID();\n    const stateHash = hashControllerState(state);\n    const requestedMode = this.deps.config.mode;\n\n    // off: no choice, no read, no write, no call.\n    if (requestedMode === \"off\") {\n      return {\n        decisionId,\n        requestedMode,\n        effectiveMode: \"off\",\n        stateHash,\n        choice: { family: \"no_op\" },\n        scores: { persistent_memory: 0, recall: 0, active_context: 0, no_op: 0 },\n        executed: false,\n        reviewOnly: false,\n        recorded: false,\n        demotionReasons: [\"mode_off\"],\n      };\n    }\n\n    const [runtimeValues, utilityValues] = await Promise.all([\n      this.deps.policyRuntime?.loadRuntimeValues() ?? null,\n      this.deps.readUtilityRuntime?.() ?? null,\n    ]);\n    const { choice, scores } = chooseAction({\n      state,\n      activeContextAdapter: this.deps.activeContextAdapter,\n      runtimeValues,\n      utilityValues,\n    });\n\n    let demotionReasons: string[] = [];\n    let effectiveMode = requestedMode;\n    if (requestedMode === \"active\") {\n      demotionReasons = await evaluateActiveGates({\n        config: this.deps.config,\n        reportReader: this.deps.reportReader,\n        recorder: this.deps.recorder,\n        consecutiveReceiptFailures: this.consecutiveReceiptFailures,\n        now: this.clock(),\n      });\n      if (demotionReasons.length > 0) effectiveMode = \"shadow\";\n    }\n\n    const baseEvent: MemoryControllerEvent = {\n      schemaVersion: 1,\n      phase: \"choice\",\n      decisionId,\n      timestamp: this.clock().toISOString(),\n      requestedMode,\n      effectiveMode,\n      stateHash,\n      choice,\n      scores,\n      executed: false,\n      ...(demotionReasons.length > 0 ? { demotionReasons } : {}),\n    };\n\n    // Shadow records before any active dispatch.\n    let recorded = false;\n    if (this.deps.recorder) {\n      try {\n        await this.deps.recorder.record(baseEvent);\n        this.deps.telemetry?.(baseEvent);\n        recorded = true;\n      } catch {\n        // Bad recorder stops work: no dispatch, no outcome event.\n        return {\n          decisionId,\n          requestedMode,\n          effectiveMode,\n          stateHash,\n          choice,\n          scores,\n          executed: false,\n          reviewOnly: false,\n          recorded: false,\n          demotionReasons: [...demotionReasons, \"record_failed\"],\n        };\n      }\n    }\n\n    if (effectiveMode !== \"active\") {\n      return {\n        decisionId,\n        requestedMode,\n        effectiveMode,\n        stateHash,\n        choice,\n        scores,\n        executed: false,\n        reviewOnly: false,\n        recorded,\n        demotionReasons,\n      };\n    }\n\n    // First active scope: reversible actions only.\n    if (choice.family === \"persistent_memory\" && REVIEW_ONLY_ACTIONS[choice.action]) {\n      const event: MemoryControllerEvent = {\n        ...baseEvent,\n        phase: \"outcome\",\n        reviewOnly: true,\n        demotionReasons: [\"review_only_action\"],\n      };\n      await this.recordOutcome(event);\n      return {\n        decisionId,\n        requestedMode,\n        effectiveMode,\n        stateHash,\n        choice,\n        scores,\n        executed: false,\n        reviewOnly: true,\n        recorded,\n        demotionReasons,\n      };\n    }\n\n    const receipt = await this.dispatch(choice, stateHash, decisionId, baseEvent);\n    return {\n      decisionId,\n      requestedMode,\n      effectiveMode,\n      stateHash,\n      choice,\n      scores,\n      executed: receipt?.ok === true,\n      reviewOnly: false,\n      recorded,\n      ...(receipt ? { receipt } : {}),\n      demotionReasons,\n    };\n  }\n\n  private async dispatch(\n    choice: MemoryControllerChoice,\n    stateHash: string,\n    decisionId: string,\n    baseEvent: MemoryControllerEvent\n  ): Promise<MemoryControllerReceipt | undefined> {\n    const executors = this.deps.executors ?? {};\n    try {\n      let receipt: MemoryControllerReceipt | undefined;\n      if (choice.family === \"persistent_memory\") {\n        if (!executors.executePersistentMemory) throw new Error(\"no_executor:persistent_memory\");\n        receipt = await executors.executePersistentMemory({\n          decisionId,\n          action: choice.action,\n          eligibility: choice.eligibility,\n          stateHash,\n        });\n      } else if (choice.family === \"recall\") {\n        if (!executors.executeRecall) throw new Error(\"no_executor:recall\");\n        receipt = await executors.executeRecall({ decisionId, mode: choice.mode });\n      } else if (choice.family === \"active_context\") {\n        if (!executors.executeActiveContext) throw new Error(\"no_executor:active_context\");\n        receipt = await executors.executeActiveContext({ decisionId, plan: choice.plan });\n      } else {\n        // no_op executed trivially; no executor call.\n        receipt = { decisionId, ok: true };\n      }\n      if (!isValidReceipt(receipt, decisionId)) {\n        this.consecutiveReceiptFailures += 1;\n        await this.recordOutcome({ ...baseEvent, phase: \"outcome\", failureClass: \"bad_receipt\" });\n        return undefined;\n      }\n      this.consecutiveReceiptFailures = 0;\n      await this.recordOutcome({ ...baseEvent, phase: \"outcome\", executed: receipt.ok, receipt });\n      return receipt;\n    } catch (error) {\n      this.consecutiveReceiptFailures += 1;\n      await this.recordOutcome({\n        ...baseEvent,\n        phase: \"outcome\",\n        failureClass: (error as Error)?.message?.startsWith(\"no_executor:\") ? \"no_executor\" : \"executor_error\",\n      });\n      return undefined;\n    }\n  }\n\n  private async recordOutcome(event: MemoryControllerEvent): Promise<void> {\n    if (!this.deps.recorder) return;\n    await this.deps.recorder.record(event);\n    this.deps.telemetry?.(event);\n  }\n}\n\nfunction isValidReceipt(receipt: unknown, decisionId: string): boolean {\n  return (\n    typeof receipt === \"object\" &&\n    receipt !== null &&\n    (receipt as MemoryControllerReceipt).decisionId === decisionId &&\n    typeof (receipt as MemoryControllerReceipt).ok === \"boolean\"\n  );\n}\n\n// ponytail: consecutiveReceiptFailures is per-instance, not persisted; persist\n// with the recorder if coordinator restarts must carry receipt health forward.\n"],"mappings":"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","names":[]}

package/dist/{chunk-OCCHUEZB.js → chunk-SEA6M7SS.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-THVI4Y7X.js";
+} from "./chunk-BJTHRFFC.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-OCCHUEZB.js.map
+//# sourceMappingURL=chunk-SEA6M7SS.js.map

package/dist/{chunk-KOO37E4Y.js → chunk-SVVIASVX.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-THVI4Y7X.js";
+} from "./chunk-BJTHRFFC.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
@@ -765,4 +765,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-KOO37E4Y.js.map
+//# sourceMappingURL=chunk-SVVIASVX.js.map

package/dist/{chunk-4K7IW3F7.js → chunk-UD7UNYRD.js}

@@ -16,7 +16,10 @@ function runSerialized(key, task) {
   });
   return next;
 }
-var MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES = /* @__PURE__ */ new Set(["fact", "procedure"]);
+var MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES = /* @__PURE__ */ new Set([
+  "fact",
+  "procedure"
+]);
 function memoryWorthOutcomeEligibleCategories() {
   return new Set(MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES);
 }
@@ -82,9 +85,37 @@ async function recordMemoryOutcome(storage, input) {
     };
   });
 }
+var OBSERVATION_ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function toMemoryOutcomeObservation(raw) {
+  if (typeof raw.memoryId !== "string" || raw.memoryId.length === 0 || typeof raw.namespace !== "string" || raw.namespace.length === 0 || raw.outcome !== "success" && raw.outcome !== "failure") {
+    throw new Error("toMemoryOutcomeObservation requires memoryId, namespace, and outcome");
+  }
+  const observedAt = typeof raw.observedAt === "string" && OBSERVATION_ISO_RE.test(raw.observedAt) ? raw.observedAt : raw.observedAt instanceof Date ? raw.observedAt.toISOString() : null;
+  if (observedAt === null) {
+    return { status: "missing_observation", memoryId: raw.memoryId, reason: "missing_observed_at" };
+  }
+  const joinId = typeof raw.joinId === "string" && raw.joinId.length > 0 ? raw.joinId : void 0;
+  const sessionKey = typeof raw.sessionKey === "string" && raw.sessionKey.length > 0 ? raw.sessionKey : void 0;
+  if (joinId === void 0 && sessionKey === void 0) {
+    return { status: "missing_observation", memoryId: raw.memoryId, reason: "missing_join_data" };
+  }
+  return {
+    status: "observed",
+    observation: {
+      schemaVersion: 1,
+      memoryId: raw.memoryId,
+      namespace: raw.namespace,
+      outcome: raw.outcome,
+      observedAt,
+      joinId,
+      sessionKey
+    }
+  };
+}
 
 export {
   memoryWorthOutcomeEligibleCategories,
-  recordMemoryOutcome
+  recordMemoryOutcome,
+  toMemoryOutcomeObservation
 };
-//# sourceMappingURL=chunk-4K7IW3F7.js.map
+//# sourceMappingURL=chunk-UD7UNYRD.js.map

package/dist/chunk-UD7UNYRD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-worth-outcomes.ts"],"sourcesContent":["/**\n * Issue #560 PR 3 — Memory Worth outcome signal pipeline.\n *\n * PR 1 added `mw_success` / `mw_fail` fields to MemoryFrontmatter. PR 2 added\n * a pure scoring helper. This module adds the one piece tying the two\n * together: a way for callers to record a single outcome observation against\n * a memory, which increments the appropriate counter in frontmatter.\n *\n * The public entry point is `recordMemoryOutcome({ memoryPath, outcome, ... })`.\n * Callers pass the full path to the memory file (not just the ID) because in\n * the usual outcome source — the observation ledger — the memory path is\n * already captured in the event payload, and path-based lookup avoids a\n * full-corpus scan.\n *\n * Intentional properties:\n *   - Works on a per-memory basis (no bulk API in this slice). Bulk update is\n *     an easy layer on top of this once a second caller needs it.\n *   - Reuses the existing `updateMemoryFrontmatter(id, patch)` write path so\n *     unrelated fields (confidence, importance, lifecycle hooks, etc.) are\n *     preserved. The PR 1 serializer rejects negative / non-integer counters,\n *     so we rely on that for defensive validation rather than duplicating it.\n *   - Only instruments categories in `MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES`\n *     (currently `fact` and `procedure` — procedures joined in issue #2370 —\n *     matching `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in operator-toolkit.ts for\n *     the doctor audit). Non-eligible memories return\n *     `{ ok: false, reason: \"ineligible_category\" }` rather than throwing so\n *     the caller — typically a ledger consumer draining heterogeneous events\n *     — doesn't need to pre-filter by category.\n *   - Missing / unknown memory IDs return `{ ok: false, reason: \"not_found\" }`\n *     rather than throwing, because outcome events may reference memories\n *     that were archived/deleted between the session and the ledger drain.\n *     That isn't an operator-actionable error.\n *   - On success, returns the new counter values so observability surfaces\n *     can report the increment without a second read.\n *\n * Out of scope (later PRs):\n *   - Recall filter reading the counters (PR 4).\n *   - Benchmark + default flip (PR 5).\n *   - Automatic increments from extraction or summarization. Only the\n *     explicit `MEM_OUTCOME` ledger tag or an MCP tool call drives writes.\n */\n\nimport path from \"node:path\";\n\nimport type { StorageManager } from \"./storage.js\";\nimport type { MemoryFrontmatter } from \"./types.js\";\n\n/**\n * Per-memory-ID serialization of the read-modify-write increment.\n *\n * Codex P1: without this, concurrent calls for the same memory race. Both\n * callers read the same `mw_*` values, each writes +1, and one increment\n * is lost — silently undercounting outcomes. We chain an async promise\n * per memory ID so read-then-write is atomic with respect to other calls\n * into this module.\n *\n * This serializes only THIS module. Direct writers (e.g. hand-rolled\n * frontmatter patches) still bypass the lock, but the documented surface\n * for Memory Worth increments is this function, and the bench only uses\n * this path.\n *\n * The lock map is WeakRef-free by design: the chain self-cleans once the\n * last pending write resolves (we delete the entry inside the `.finally`\n * of the tail), so memory use stays bounded even for long-running\n * processes that touch many different memory IDs.\n */\nconst outcomeLocks = new Map<string, Promise<unknown>>();\n\nfunction runSerialized<T>(key: string, task: () => Promise<T>): Promise<T> {\n  const prev = outcomeLocks.get(key) ?? Promise.resolve();\n  // Swallow upstream errors so a failed outcome for memory A doesn't\n  // permanently poison the chain for memory A. We still propagate our own\n  // result/errors to the caller.\n  const next = prev.catch(() => undefined).then(task);\n  outcomeLocks.set(key, next);\n  // Chain the cleanup off `next` BUT attach a `.catch` so the cleanup\n  // promise itself never surfaces as an unhandled rejection. The caller\n  // gets `next` back and handles it their own way; this detached cleanup\n  // chain has no observer, so without the .catch Node would crash the\n  // process on a task rejection even when the caller awaited `next` and\n  // handled the error correctly.\n  next\n    .then(\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      },\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      }\n    )\n    .catch(() => {\n      // Defensive no-op in case a hook inside the cleanup branches throws.\n    });\n  return next;\n}\n\n/**\n * Categories currently instrumented for Memory Worth counters. `procedure`\n * joined in issue #2370 — the procedure library-health maintenance loop\n * retires on failure-dominant `mw_*` counters, so injected procedures must\n * be able to accrue outcomes. Must be kept in sync with\n * `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in `operator-toolkit.ts`. Declared\n * here (not imported) to avoid a circular dep with operator-toolkit, which\n * imports from this file's peers. The two constants are validated by a\n * test to stay in lockstep.\n */\nconst MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES: ReadonlySet<MemoryFrontmatter[\"category\"]> = new Set([\n  \"fact\",\n  \"procedure\",\n]);\n\n/**\n * Exported so downstream tests / operators can query the allowlist without\n * re-declaring it. Returned as a frozen copy so consumers cannot mutate the\n * module-internal set.\n */\nexport function memoryWorthOutcomeEligibleCategories(): ReadonlySet<MemoryFrontmatter[\"category\"]> {\n  return new Set(MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES);\n}\n\n/**\n * The direction of an outcome — whether the session that consumed this\n * memory succeeded or failed. Restricted to a string literal union so\n * callers in TypeScript land can't pass arbitrary tags.\n */\nexport type MemoryOutcomeKind = \"success\" | \"failure\";\n\n/**\n * Arguments to `recordMemoryOutcome`.\n *\n * `memoryPath` is the filesystem path to the memory; we derive the ID from\n * the basename, matching how the operator-toolkit and recall layers map\n * paths to IDs.\n */\nexport interface RecordMemoryOutcomeInput {\n  /**\n   * Absolute or repo-relative path to the memory file. Typically the value\n   * of `MemoryFile.path` for a memory returned by `readAllMemories`.\n   */\n  memoryPath: string;\n  /** Outcome direction — \"success\" bumps mw_success; \"failure\" bumps mw_fail. */\n  outcome: MemoryOutcomeKind;\n  /**\n   * Optional observation timestamp for audit / telemetry. This PR doesn't\n   * persist the timestamp (PR 4/5 will use `lastAccessed`, which already\n   * covers the recency-decay requirement), but accepting it here keeps the\n   * call shape stable so future ledger integrations don't need a breaking\n   * change.\n   */\n  timestamp?: Date | string;\n}\n\n/**\n * Outcome of a `recordMemoryOutcome` call.\n *\n * `ok: true` means the counter was incremented and flushed. The returned\n * values reflect the post-increment state, so callers can log\n * `\"fact-xyz: 4/1 → 5/1\"` without re-reading.\n *\n * `ok: false` carries a short machine-readable `reason` so a ledger drainer\n * can aggregate metrics (\"how many events hit not_found this hour?\"). The\n * human-readable `message` is a friendlier version for logs.\n */\nexport type RecordMemoryOutcomeResult =\n  | {\n      ok: true;\n      memoryId: string;\n      /** New value of `mw_success` after the increment. */\n      mw_success: number;\n      /** New value of `mw_fail` after the increment. */\n      mw_fail: number;\n    }\n  | {\n      ok: false;\n      reason: \"not_found\" | \"ineligible_category\" | \"invalid_outcome\" | \"invalid_path\";\n      message: string;\n    };\n\n/**\n * Extract the memory ID from a file path. Memory files are stored as\n * `<id>.md`, matching the rest of the system (see `getMemoryById`, which\n * infers paths from IDs).\n *\n * Returns `null` for any path that does not end in `.md`. The check is\n * unconditional — `path.basename` strips directory components before the\n * suffix check, so previous conditional logic silently accepted\n * directory-prefixed paths like `/tmp/facts/2026-01-01/not-a-memory`\n * (the basename `not-a-memory` is not equal to the input, so the `.md`\n * guard was skipped). The new check looks at the raw input once.\n */\nfunction memoryIdFromPath(memoryPath: string): string | null {\n  if (!memoryPath || typeof memoryPath !== \"string\") return null;\n  if (!memoryPath.endsWith(\".md\")) return null;\n  const basename = path.basename(memoryPath, \".md\");\n  if (!basename) return null;\n  return basename;\n}\n\n/**\n * Record a single outcome observation against a memory. Increments\n * `mw_success` or `mw_fail` on the memory's frontmatter (preserving all\n * other fields) via the existing `updateMemoryFrontmatter` write path.\n *\n * See the top-of-file doc comment for policy details (eligible categories,\n * error semantics, and what is intentionally out of scope).\n */\nexport async function recordMemoryOutcome(\n  storage: StorageManager,\n  input: RecordMemoryOutcomeInput\n): Promise<RecordMemoryOutcomeResult> {\n  if (input.outcome !== \"success\" && input.outcome !== \"failure\") {\n    return {\n      ok: false,\n      reason: \"invalid_outcome\",\n      message: `outcome must be \"success\" or \"failure\"; got ${JSON.stringify(input.outcome)}`,\n    };\n  }\n\n  const memoryId = memoryIdFromPath(input.memoryPath);\n  if (memoryId === null) {\n    return {\n      ok: false,\n      reason: \"invalid_path\",\n      message: `memoryPath must end in .md; got ${JSON.stringify(input.memoryPath)}`,\n    };\n  }\n\n  // Serialize the read-modify-write per memory ID so concurrent callers\n  // (parallel ledger drain, multiple MCP clients, etc.) can't each read\n  // the same snapshot and race to write `+1`, losing an increment.\n  return runSerialized(memoryId, async () => {\n    const memory = await storage.getMemoryById(memoryId);\n    if (!memory) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `no memory with id ${memoryId}`,\n      };\n    }\n\n    if (!MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES.has(memory.frontmatter.category)) {\n      return {\n        ok: false,\n        reason: \"ineligible_category\",\n        message: `category ${memory.frontmatter.category} is not instrumented for Memory Worth`,\n      };\n    }\n\n    // Absent counters are treated as 0 (matching the PR 1 semantics — legacy\n    // memories implicitly have Beta(1,1) priors). Increments land on the\n    // actual counter regardless of whether the field was previously set.\n    const currentSuccess = memory.frontmatter.mw_success ?? 0;\n    const currentFail = memory.frontmatter.mw_fail ?? 0;\n\n    const nextSuccess = input.outcome === \"success\" ? currentSuccess + 1 : currentSuccess;\n    const nextFail = input.outcome === \"failure\" ? currentFail + 1 : currentFail;\n\n    // `updateMemoryFrontmatter` goes through `writeMemoryFrontmatter`, which\n    // routes through the PR 1 serializer — so a stored corrupt value (e.g., a\n    // pre-existing float) would be rejected here. That is intentional: we\n    // refuse to layer a fresh increment on top of garbage. Operators should\n    // use `remnic doctor` to find and fix those rows before PR 4 ships.\n    //\n    // `updateMemoryFrontmatter` returns `false` when the memory is no\n    // longer present (archived / deleted between `getMemoryById` and the\n    // write). Surface that as `not_found` so callers see an honest result\n    // — silently returning `ok: true` with a counter that never landed\n    // would skew downstream worth scoring.\n    const updated = await storage.updateMemoryFrontmatter(memoryId, {\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    });\n    if (!updated) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `memory ${memoryId} disappeared between read and write`,\n      };\n    }\n\n    return {\n      ok: true,\n      memoryId,\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    };\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Issue #2345 — pure outcome-observation view (no writes, no counter changes)\n// ---------------------------------------------------------------------------\n\n/**\n * A Memory Worth outcome that carries WHEN it was observed and WHAT it can\n * join to — the facts the trajectory evaluator needs and plain counter rows\n * lack. `mw_success` / `mw_fail` totals have no timestamp or join ID, so they\n * cannot participate in delayed action-to-outcome joins.\n */\nexport interface MemoryOutcomeObservation {\n  schemaVersion: 1;\n  memoryId: string;\n  namespace: string;\n  outcome: MemoryOutcomeKind;\n  observedAt: string;\n  /** Stable join key shared with the action side (never free text). */\n  joinId?: string;\n  sessionKey?: string;\n}\n\n/**\n * Discriminated view over outcome facts a caller can supply.\n *\n * - `missing_observation` — counter-only or incomplete rows. The evaluator\n *   must never guess the action behind an aggregate counter, so these stay\n *   visible as missing rather than being inferred.\n */\nexport type MemoryOutcomeObservationView =\n  | { status: \"observed\"; observation: MemoryOutcomeObservation }\n  | { status: \"missing_observation\"; memoryId: string; reason: \"missing_observed_at\" | \"missing_join_data\" };\n\nconst OBSERVATION_ISO_RE = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/;\n\n/**\n * Build the pure observation view. Accepts exactly what a caller already\n * knows; performs no storage reads and no writes, and does not alter the\n * counter path — `recordMemoryOutcome` keeps its current behavior.\n */\nexport function toMemoryOutcomeObservation(raw: {\n  memoryId: string;\n  namespace: string;\n  outcome: MemoryOutcomeKind;\n  observedAt?: unknown;\n  joinId?: unknown;\n  sessionKey?: unknown;\n}): MemoryOutcomeObservationView {\n  if (\n    typeof raw.memoryId !== \"string\" ||\n    raw.memoryId.length === 0 ||\n    typeof raw.namespace !== \"string\" ||\n    raw.namespace.length === 0 ||\n    (raw.outcome !== \"success\" && raw.outcome !== \"failure\")\n  ) {\n    throw new Error(\"toMemoryOutcomeObservation requires memoryId, namespace, and outcome\");\n  }\n  const observedAt =\n    typeof raw.observedAt === \"string\" && OBSERVATION_ISO_RE.test(raw.observedAt)\n      ? raw.observedAt\n      : raw.observedAt instanceof Date\n        ? raw.observedAt.toISOString()\n        : null;\n  if (observedAt === null) {\n    return { status: \"missing_observation\", memoryId: raw.memoryId, reason: \"missing_observed_at\" };\n  }\n  const joinId = typeof raw.joinId === \"string\" && raw.joinId.length > 0 ? raw.joinId : undefined;\n  const sessionKey = typeof raw.sessionKey === \"string\" && raw.sessionKey.length > 0 ? raw.sessionKey : undefined;\n  if (joinId === undefined && sessionKey === undefined) {\n    return { status: \"missing_observation\", memoryId: raw.memoryId, reason: \"missing_join_data\" };\n  }\n  return {\n    status: \"observed\",\n    observation: {\n      schemaVersion: 1,\n      memoryId: raw.memoryId,\n      namespace: raw.namespace,\n      outcome: raw.outcome,\n      observedAt,\n      joinId,\n      sessionKey,\n    },\n  };\n}\n"],"mappings":"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","names":[]}