@remnic/core 9.65.6 → 9.65.7

package/dist/{chunk-X2DWBWOX.js → chunk-S3K2CIK5.js}

@@ -1,7 +1,7 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-PNAGNVGK.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-X2DWBWOX.js.map
+//# sourceMappingURL=chunk-S3K2CIK5.js.map

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

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

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

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

package/dist/{chunk-7K5Q6COX.js → chunk-TVVEYCNW.js}

@@ -1,9 +1,9 @@
-import {
-  appendRecallAuditEntry
-} from "./chunk-LBLXEFWK.js";
 import {
   detectRecallAnomalies
 } from "./chunk-RFYAYKTD.js";
+import {
+  appendRecallAuditEntry
+} from "./chunk-LBLXEFWK.js";
 
 // src/access-audit.ts
 var AccessAuditAdapter = class {
@@ -62,4 +62,4 @@ var AccessAuditAdapter = class {
 export {
   AccessAuditAdapter
 };
-//# sourceMappingURL=chunk-7K5Q6COX.js.map
+//# sourceMappingURL=chunk-TVVEYCNW.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":[]}

package/dist/chunk-ULM7JCDH.js

@@ -0,0 +1,154 @@
+// src/eval-trajectory-contracts.ts
+import { createHash } from "crypto";
+var EVAL_TRAJECTORY_REPORT_SCHEMA_VERSION = 1;
+var DEFAULT_EVAL_TRAJECTORY_OUTCOME_WINDOW_MS = 6048e5;
+var DEFAULT_EVAL_TRAJECTORY_MAX_FUTURE_SKEW_MS = 3e5;
+var DEFAULT_EVAL_TRAJECTORY_MAX_ROWS = 5e3;
+var MAX_EVAL_TRAJECTORY_ROWS_LIMIT = 5e4;
+var DEFAULT_EVAL_TRAJECTORY_REPORT_MAX_AGE_MS = 2592e6;
+var DEFAULT_EVAL_TRAJECTORY_WEIGHTS = Object.freeze({
+  task: 1,
+  context: 0.25,
+  trust: 1,
+  stale: 0.5
+});
+var MEMORY_ACTION_TYPES = {
+  store_episode: true,
+  store_note: true,
+  update_note: true,
+  create_artifact: true,
+  summarize_node: true,
+  discard: true,
+  link_graph: true
+};
+var DESTRUCTIVE_ACTION_TYPES = { discard: true };
+var STALE_LIFECYCLE_STATES = {
+  active: true,
+  stale: true,
+  archived: true,
+  superseded: true
+};
+var STALE_OUTCOMES = {
+  success: true,
+  partial: true,
+  failure: true,
+  unknown: true
+};
+var EVAL_TRAJECTORY_PROMOTION_THRESHOLDS = Object.freeze({
+  minJoinedRows: 30,
+  minReach: 0.5
+});
+function resolveEvalTrajectoryRunConfig(partial) {
+  const source = partial ?? {};
+  const weightsSource = source.weights ?? DEFAULT_EVAL_TRAJECTORY_WEIGHTS;
+  const weights = {
+    task: Number(weightsSource.task),
+    context: Number(weightsSource.context),
+    trust: Number(weightsSource.trust),
+    stale: Number(weightsSource.stale)
+  };
+  for (const [name, value] of Object.entries(weights)) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`eval trajectory weight '${name}' must be a finite non-negative number`);
+    }
+  }
+  const totalWeight = weights.task + weights.context + weights.trust + weights.stale;
+  if (!(totalWeight > 0)) {
+    throw new Error("eval trajectory weights must have a positive total weight");
+  }
+  const outcomeWindowMs = Number(source.outcomeWindowMs ?? DEFAULT_EVAL_TRAJECTORY_OUTCOME_WINDOW_MS);
+  if (!Number.isSafeInteger(outcomeWindowMs) || outcomeWindowMs <= 0) {
+    throw new Error("outcomeWindowMs must be a positive integer");
+  }
+  const maxFutureSkewMs = Number(source.maxFutureSkewMs ?? DEFAULT_EVAL_TRAJECTORY_MAX_FUTURE_SKEW_MS);
+  if (!Number.isSafeInteger(maxFutureSkewMs) || maxFutureSkewMs < 0) {
+    throw new Error("maxFutureSkewMs must be a non-negative integer");
+  }
+  const maxRows = Number(source.maxRows ?? DEFAULT_EVAL_TRAJECTORY_MAX_ROWS);
+  if (!Number.isSafeInteger(maxRows) || maxRows < 1 || maxRows > MAX_EVAL_TRAJECTORY_ROWS_LIMIT) {
+    throw new Error(`maxRows must be an integer in [1, ${MAX_EVAL_TRAJECTORY_ROWS_LIMIT}]`);
+  }
+  return { outcomeWindowMs, maxFutureSkewMs, weights, maxRows };
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeysDeep(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeysDeep(value));
+}
+function digestOf(salt, payload) {
+  return sha256Hex(`${salt}
+${canonicalJson(payload)}`);
+}
+function serializeEvalTrajectoryReport(report) {
+  return `${JSON.stringify(sortKeysDeep(report), null, 2)}
+`;
+}
+function compareStrings(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function compareRows(a, b) {
+  const byTime = compareStrings(a.outcomeRecordedAt ?? "", b.outcomeRecordedAt ?? "");
+  if (byTime !== 0) return byTime;
+  return compareStrings(a.actionDigest, b.actionDigest);
+}
+var ISO_UTC_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function isIsoTimestamp(value) {
+  return typeof value === "string" && ISO_UTC_TIMESTAMP_RE.test(value) && !Number.isNaN(Date.parse(value));
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isMemoryActionType(value) {
+  return typeof value === "string" && MEMORY_ACTION_TYPES[value] === true;
+}
+function isRowStatus(value) {
+  return value === "joined" || value === "ambiguous" || value === "late_outcome" || value === "future_outcome" || value === "missing_within_window";
+}
+function isHexSha256(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+
+export {
+  EVAL_TRAJECTORY_REPORT_SCHEMA_VERSION,
+  DEFAULT_EVAL_TRAJECTORY_OUTCOME_WINDOW_MS,
+  DEFAULT_EVAL_TRAJECTORY_MAX_FUTURE_SKEW_MS,
+  DEFAULT_EVAL_TRAJECTORY_MAX_ROWS,
+  MAX_EVAL_TRAJECTORY_ROWS_LIMIT,
+  DEFAULT_EVAL_TRAJECTORY_REPORT_MAX_AGE_MS,
+  DEFAULT_EVAL_TRAJECTORY_WEIGHTS,
+  DESTRUCTIVE_ACTION_TYPES,
+  STALE_LIFECYCLE_STATES,
+  STALE_OUTCOMES,
+  EVAL_TRAJECTORY_PROMOTION_THRESHOLDS,
+  resolveEvalTrajectoryRunConfig,
+  sha256Hex,
+  sortKeysDeep,
+  canonicalJson,
+  digestOf,
+  serializeEvalTrajectoryReport,
+  compareStrings,
+  compareRows,
+  isIsoTimestamp,
+  isNonEmptyString,
+  isFiniteNumber,
+  isMemoryActionType,
+  isRowStatus,
+  isHexSha256
+};
+//# sourceMappingURL=chunk-ULM7JCDH.js.map

package/dist/chunk-ULM7JCDH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eval-trajectory-contracts.ts"],"sourcesContent":["/**\n * Issue #2345 — internal contracts, config bounds, digests, and validators for\n * the privacy-safe action-to-outcome trajectory evaluator.\n *\n * Internal module: never re-exported from the package root by itself. The\n * public surface is `eval-trajectory.ts` (builder) and `eval-trajectory-store.ts`\n * (validation, persistence, promotion gate). Keeping this layer separate holds\n * every file under the #1995 new-file ratchet cap while preserving one\n * subsystem.\n */\n\nimport { createHash } from \"node:crypto\";\nimport type { MemoryActionOutcome, MemoryActionPolicyDecision, MemoryActionType } from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Constants and bounded config\n// ---------------------------------------------------------------------------\n\nexport const EVAL_TRAJECTORY_REPORT_SCHEMA_VERSION = 1;\n\n/** Default delayed-outcome window: 7 days, half-open `actionAt < outcomeAt < actionAt + window`. */\nexport const DEFAULT_EVAL_TRAJECTORY_OUTCOME_WINDOW_MS = 604_800_000;\n/** Default allowed clock skew for input timestamps beyond `asOf`. */\nexport const DEFAULT_EVAL_TRAJECTORY_MAX_FUTURE_SKEW_MS = 300_000;\n/** Default cap on emitted rows per report. */\nexport const DEFAULT_EVAL_TRAJECTORY_MAX_ROWS = 5_000;\nexport const MAX_EVAL_TRAJECTORY_ROWS_LIMIT = 50_000;\n/** Default reader expiry: a report older than 30 days fails the checked read. */\nexport const DEFAULT_EVAL_TRAJECTORY_REPORT_MAX_AGE_MS = 2_592_000_000;\n\nexport interface EvalTrajectoryWeights {\n  task: number;\n  context: number;\n  trust: number;\n  stale: number;\n}\n\nexport const DEFAULT_EVAL_TRAJECTORY_WEIGHTS: Readonly<EvalTrajectoryWeights> = Object.freeze({\n  task: 1,\n  context: 0.25,\n  trust: 1,\n  stale: 0.5,\n});\n\nconst MEMORY_ACTION_TYPES: Record<string, true> = {\n  store_episode: true,\n  store_note: true,\n  update_note: true,\n  create_artifact: true,\n  summarize_node: true,\n  discard: true,\n  link_graph: true,\n};\n\n/** Action types whose live execution is destructive (irreversible) for promotion gating. */\nexport const DESTRUCTIVE_ACTION_TYPES: Record<string, true> = { discard: true };\n\nexport const STALE_LIFECYCLE_STATES: Record<string, true> = {\n  active: true,\n  stale: true,\n  archived: true,\n  superseded: true,\n};\n\nexport const STALE_OUTCOMES: Record<string, true> = {\n  success: true,\n  partial: true,\n  failure: true,\n  unknown: true,\n};\n\n/**\n * Fixed promotion thresholds for `deriveUnifiedMemoryPromotionReport`. These\n * are deliberately conservative named constants — #2348 owns application, and\n * any loosening must be a reviewed change, not a config knob.\n */\nexport const EVAL_TRAJECTORY_PROMOTION_THRESHOLDS = Object.freeze({\n  minJoinedRows: 30,\n  minReach: 0.5,\n});\n\nexport interface EvalTrajectoryRunConfig {\n  outcomeWindowMs: number;\n  maxFutureSkewMs: number;\n  weights: EvalTrajectoryWeights;\n  maxRows: number;\n}\n\nexport function resolveEvalTrajectoryRunConfig(partial?: Partial<EvalTrajectoryRunConfig>): EvalTrajectoryRunConfig {\n  const source = partial ?? {};\n  const weightsSource = source.weights ?? DEFAULT_EVAL_TRAJECTORY_WEIGHTS;\n  const weights: EvalTrajectoryWeights = {\n    task: Number(weightsSource.task),\n    context: Number(weightsSource.context),\n    trust: Number(weightsSource.trust),\n    stale: Number(weightsSource.stale),\n  };\n  for (const [name, value] of Object.entries(weights)) {\n    if (!Number.isFinite(value) || value < 0) {\n      throw new Error(`eval trajectory weight '${name}' must be a finite non-negative number`);\n    }\n  }\n  const totalWeight = weights.task + weights.context + weights.trust + weights.stale;\n  if (!(totalWeight > 0)) {\n    throw new Error(\"eval trajectory weights must have a positive total weight\");\n  }\n\n  const outcomeWindowMs = Number(source.outcomeWindowMs ?? DEFAULT_EVAL_TRAJECTORY_OUTCOME_WINDOW_MS);\n  if (!Number.isSafeInteger(outcomeWindowMs) || outcomeWindowMs <= 0) {\n    throw new Error(\"outcomeWindowMs must be a positive integer\");\n  }\n  const maxFutureSkewMs = Number(source.maxFutureSkewMs ?? DEFAULT_EVAL_TRAJECTORY_MAX_FUTURE_SKEW_MS);\n  if (!Number.isSafeInteger(maxFutureSkewMs) || maxFutureSkewMs < 0) {\n    throw new Error(\"maxFutureSkewMs must be a non-negative integer\");\n  }\n  const maxRows = Number(source.maxRows ?? DEFAULT_EVAL_TRAJECTORY_MAX_ROWS);\n  if (!Number.isSafeInteger(maxRows) || maxRows < 1 || maxRows > MAX_EVAL_TRAJECTORY_ROWS_LIMIT) {\n    throw new Error(`maxRows must be an integer in [1, ${MAX_EVAL_TRAJECTORY_ROWS_LIMIT}]`);\n  }\n  return { outcomeWindowMs, maxFutureSkewMs, weights, maxRows };\n}\n\n// ---------------------------------------------------------------------------\n// Input contracts (sanitized caller rows — raw IDs live here, never in output)\n// ---------------------------------------------------------------------------\n\nexport type EvalTrajectoryTaskResult = \"success\" | \"partial\" | \"failure\";\nexport type EvalTrajectoryOutcomeSource = \"eval_artifact\" | \"causal_trajectory\" | \"memory_outcome\";\nexport type EvalStaleUseLifecycleState = \"active\" | \"stale\" | \"archived\" | \"superseded\";\nexport type EvalStaleUseOutcome = \"success\" | \"partial\" | \"failure\" | \"unknown\";\n\nexport interface EvalActionInput {\n  schemaVersion: 1;\n  /** Stable action identity. Required — rows without it are rejected. */\n  actionId: string;\n  namespace: string;\n  actionAt: string;\n  action: MemoryActionType;\n  /** Immediate operation status. Never a delayed task result. */\n  immediateStatus: MemoryActionOutcome;\n  policyDecision?: MemoryActionPolicyDecision;\n  policyVersion?: string;\n  /** Producing subsystem tag (enum-like; exported through the projection). */\n  subsystem?: string;\n  sessionKey?: string;\n  memoryId?: string;\n  trajectoryId?: string;\n  contextTokensBefore?: number;\n  contextTokensAfter?: number;\n  contextTokenBudget?: number;\n  contextOverflow?: boolean;\n  replayMismatch?: boolean;\n  missingReversibleGuard?: boolean;\n  outsideEligibility?: boolean;\n}\n\nexport interface EvalOutcomeInput {\n  schemaVersion: 1;\n  namespace: string;\n  /** Stable local identity used only for digesting/dedup — never exported. */\n  outcomeId: string;\n  outcomeAt: string;\n  source: EvalTrajectoryOutcomeSource;\n  /** success | partial | failure. Memory-outcome results never become task results. */\n  result?: EvalTrajectoryTaskResult;\n  actionId?: string;\n  trajectoryId?: string;\n  memoryId?: string;\n  sessionKey?: string;\n}\n\nexport interface EvalStaleUseEvidenceInput {\n  schemaVersion: 1;\n  namespace: string;\n  actionId: string;\n  memoryId: string;\n  lifecycleState: EvalStaleUseLifecycleState;\n  usedAt: string;\n  outcome: EvalStaleUseOutcome;\n}\n\n/**\n * Normalized digest-only projections. Joins run on these, so raw IDs never\n * reach the metric or export layers. Equality joins survive digesting because\n * equal raw keys digest to equal values under the same run salt.\n */\nexport interface EvalActionProjection {\n  schemaVersion: 1;\n  actionDigest: string;\n  namespaceDigest: string;\n  actionAt: string;\n  action: MemoryActionType;\n  immediateStatus: MemoryActionOutcome;\n  policyDecision: MemoryActionPolicyDecision | null;\n  policyVersion: string | null;\n  source: string | null;\n  actionIdDigest: string;\n  sessionKeyDigest: string | null;\n  memoryIdDigest: string | null;\n  trajectoryIdDigest: string | null;\n  contextTokenCost: number | null;\n  trustViolation: 0 | 1;\n}\n\nexport interface EvalOutcomeProjection {\n  schemaVersion: 1;\n  outcomeDigest: string;\n  namespaceDigest: string;\n  recordedAt: string;\n  kind: EvalTrajectoryOutcomeSource;\n  /** 1 | 0.5 | 0 for task sources; null when unknown or memory-sourced. */\n  value: number | null;\n  sourceRefDigest: string;\n  actionIdDigest: string | null;\n  trajectoryIdDigest: string | null;\n  memoryIdDigest: string | null;\n  sessionKeyDigest: string | null;\n}\n\nexport interface EvalStaleUseEvidence {\n  schemaVersion: 1;\n  actionDigest: string;\n  memoryDigest: string;\n  lifecycleState: EvalStaleUseLifecycleState;\n  usedAt: string;\n  outcome: EvalStaleUseOutcome;\n}\n\n// ---------------------------------------------------------------------------\n// Exported report contracts (digests, enums, numbers only)\n// ---------------------------------------------------------------------------\n\nexport type EvalTrajectoryMetricName = \"taskOutcome\" | \"contextTokenCost\" | \"trustViolation\" | \"staleMemoryHarm\";\n\nexport type EvalTrajectoryJoinKind = \"action_id\" | \"trajectory_id\" | \"memory_scope\" | \"session_scope\";\n\nexport type EvalTrajectoryRowStatus =\n  | \"joined\"\n  | \"ambiguous\"\n  | \"late_outcome\"\n  | \"future_outcome\"\n  | \"missing_within_window\";\n\nexport type EvalTrajectoryRejectionReason =\n  | \"missing_action_id\"\n  | \"namespace_mismatch\"\n  | \"invalid_timestamp\"\n  | \"future_beyond_skew\"\n  | \"malformed_row\"\n  | \"invalid_context_budget\"\n  | \"duplicate_row\"\n  | \"max_rows_exceeded\";\n\nexport interface EvalActionOutcomeRow {\n  schemaVersion: 1;\n  actionDigest: string;\n  outcomeDigest: string | null;\n  join: EvalTrajectoryJoinKind | null;\n  status: EvalTrajectoryRowStatus;\n  outcomeRecordedAt: string | null;\n  taskOutcome: number | null;\n  contextTokenCost: number | null;\n  trustViolation: 0 | 1;\n  staleMemoryHarm: 0 | 0.5 | 1;\n  actionConditionedUtility: number | null;\n  missingDimensions: EvalTrajectoryMetricName[];\n}\n\nexport interface EvalTrajectoryAggregates {\n  rowCount: number;\n  statusCounts: Record<EvalTrajectoryRowStatus, number>;\n  metricMeans: {\n    taskOutcome: number | null;\n    contextTokenCost: number | null;\n    trustViolation: number | null;\n    staleMemoryHarm: number | null;\n    actionConditionedUtility: number | null;\n  };\n  coverage: {\n    reach: number | null;\n    joined: number;\n    missingWithinWindow: number;\n    lateOutcome: number;\n    futureOutcome: number;\n    ambiguous: number;\n    excludedFromMeans: number;\n  };\n  byAction: Array<{ action: MemoryActionType; rowCount: number; meanUtility: number | null }>;\n  byPolicyDecision: Array<{ policyDecision: string; rowCount: number; meanUtility: number | null }>;\n}\n\nexport interface EvalTrajectoryReport {\n  schemaVersion: 1;\n  reportId: string;\n  namespaceDigest: string;\n  asOf: string;\n  config: EvalTrajectoryRunConfig;\n  sourceCounts: { actions: number; outcomes: number; staleUseEvidence: number };\n  rejectionCounts: Record<EvalTrajectoryRejectionReason, number>;\n  rows: EvalActionOutcomeRow[];\n  aggregates: EvalTrajectoryAggregates;\n  inputFingerprint: string;\n  contentHash: string;\n}\n\nexport type UnifiedMemoryPromotionState =\n  | \"insufficient_evidence\"\n  | \"shadow_eligible\"\n  | \"active_reversible_eligible\"\n  | \"active_destructive_review_only\"\n  | \"demote_to_shadow\";\n\nexport interface UnifiedMemoryPromotionReport {\n  schemaVersion: 1;\n  sourceReportId: string;\n  namespaceDigest: string;\n  asOf: string;\n  inputFingerprint: string;\n  state: UnifiedMemoryPromotionState;\n  reasons: string[];\n  evidence: {\n    joinedRows: number;\n    reach: number | null;\n    meanUtility: number | null;\n    trustViolations: number;\n    staleHarms: number;\n    destructiveJoinedRows: number;\n  };\n  contentHash: string;\n}\n\n// ---------------------------------------------------------------------------\n// Digests and deterministic serialization\n// ---------------------------------------------------------------------------\n\nexport function sha256Hex(input: string): string {\n  return createHash(\"sha256\").update(input, \"utf8\").digest(\"hex\");\n}\n\nexport function sortKeysDeep(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map(sortKeysDeep);\n  if (typeof value === \"object\" && value !== null) {\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(value as Record<string, unknown>).sort()) {\n      out[key] = sortKeysDeep((value as Record<string, unknown>)[key]);\n    }\n    return out;\n  }\n  return value;\n}\n\nexport function canonicalJson(value: unknown): string {\n  return JSON.stringify(sortKeysDeep(value));\n}\n\nexport function digestOf(salt: string, payload: unknown): string {\n  return sha256Hex(`${salt}\\n${canonicalJson(payload)}`);\n}\n\n/** Byte-identical serialization for given report content, independent of construction order. */\nexport function serializeEvalTrajectoryReport(report: EvalTrajectoryReport): string {\n  return `${JSON.stringify(sortKeysDeep(report), null, 2)}\\n`;\n}\n\n/** Total-order comparators (equality guarded — never let equal keys claim both orders). */\nexport function compareStrings(a: string, b: string): number {\n  if (a === b) return 0;\n  return a < b ? -1 : 1;\n}\n\nexport function compareRows(a: EvalActionOutcomeRow, b: EvalActionOutcomeRow): number {\n  const byTime = compareStrings(a.outcomeRecordedAt ?? \"\", b.outcomeRecordedAt ?? \"\");\n  if (byTime !== 0) return byTime;\n  return compareStrings(a.actionDigest, b.actionDigest);\n}\n\n// ---------------------------------------------------------------------------\n// Small shared validators (local copies — evals.ts is at its ratchet ceiling)\n// ---------------------------------------------------------------------------\n\nconst ISO_UTC_TIMESTAMP_RE = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/;\n\nexport function isIsoTimestamp(value: unknown): value is string {\n  return typeof value === \"string\" && ISO_UTC_TIMESTAMP_RE.test(value) && !Number.isNaN(Date.parse(value));\n}\n\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === \"string\" && value.trim().length > 0;\n}\n\nexport function isFiniteNumber(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isFinite(value);\n}\n\nexport function isMemoryActionType(value: unknown): value is MemoryActionType {\n  return typeof value === \"string\" && MEMORY_ACTION_TYPES[value] === true;\n}\n\nexport function isRowStatus(value: unknown): value is EvalTrajectoryRowStatus {\n  return (\n    value === \"joined\" ||\n    value === \"ambiguous\" ||\n    value === \"late_outcome\" ||\n    value === \"future_outcome\" ||\n    value === \"missing_within_window\"\n  );\n}\n\nexport function isHexSha256(value: unknown): value is string {\n  return typeof value === \"string\" && /^[0-9a-f]{64}$/.test(value);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-NLUCDKLT.js → chunk-VKCAHCBI.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-PNAGNVGK.js";
+} from "./chunk-RQE4TITU.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-NLUCDKLT.js.map
+//# sourceMappingURL=chunk-VKCAHCBI.js.map

package/dist/{chunk-BXXOPKT5.js → chunk-VXVZ2GM3.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-IDQ6DKXC.js";
+} from "./chunk-5VPQSRQO.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -282,4 +282,4 @@ export {
   computeServiceCorpusWatermarks,
   computeServiceCorpusCensus
 };
-//# sourceMappingURL=chunk-BXXOPKT5.js.map
+//# sourceMappingURL=chunk-VXVZ2GM3.js.map