@remnic/core 1.1.1 → 1.1.3

package/dist/chunk-UKJAGEXH.js

@@ -0,0 +1,260 @@
+import {
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  KDF_SALT_LENGTH
+} from "./chunk-FP2373TW.js";
+
+// src/secure-store/metadata.ts
+var METADATA_FORMAT = "remnic.secure-store.metadata";
+var METADATA_FORMAT_VERSION = 1;
+function bytesToHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function hexToBytes(hex, expectedLength) {
+  if (typeof hex !== "string") {
+    throw new Error("hex field must be a string");
+  }
+  if (!/^[0-9a-f]*$/i.test(hex)) {
+    throw new Error("hex field must contain only hexadecimal characters");
+  }
+  if (hex.length % 2 !== 0) {
+    throw new Error("hex field must have even length");
+  }
+  const buf = Buffer.from(hex, "hex");
+  if (buf.length !== expectedLength) {
+    throw new Error(
+      `hex field decoded to ${buf.length} bytes, expected ${expectedLength}`
+    );
+  }
+  return buf;
+}
+function buildMetadata(options) {
+  const { algorithm, salt } = options;
+  if (!(salt instanceof Uint8Array) || salt.length !== KDF_SALT_LENGTH) {
+    throw new Error(
+      `salt must be ${KDF_SALT_LENGTH} bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  const createdAt = options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  let kdf;
+  if (algorithm === "scrypt") {
+    const params = options.params ?? {
+      ...DEFAULT_SCRYPT_PARAMS
+    };
+    kdf = { algorithm: "scrypt", params, salt: bytesToHex(salt) };
+  } else if (algorithm === "argon2id") {
+    const params = options.params ?? {
+      ...DEFAULT_ARGON2ID_PARAMS
+    };
+    kdf = { algorithm: "argon2id", params, salt: bytesToHex(salt) };
+  } else {
+    throw new Error(`unknown KDF algorithm: ${algorithm}`);
+  }
+  const meta = {
+    format: METADATA_FORMAT,
+    formatVersion: METADATA_FORMAT_VERSION,
+    kdf,
+    createdAt
+  };
+  if (options.note !== void 0) {
+    meta.note = options.note;
+  }
+  return meta;
+}
+function serializeMetadata(meta) {
+  validateMetadata(meta);
+  const ordered = {
+    format: meta.format,
+    formatVersion: meta.formatVersion,
+    kdf: orderKdf(meta.kdf),
+    createdAt: meta.createdAt
+  };
+  if (meta.note !== void 0) {
+    ordered.note = meta.note;
+  }
+  return JSON.stringify(ordered, null, 2);
+}
+function orderKdf(kdf) {
+  if (kdf.algorithm === "scrypt") {
+    return {
+      algorithm: kdf.algorithm,
+      params: {
+        N: kdf.params.N,
+        r: kdf.params.r,
+        p: kdf.params.p,
+        keyLength: kdf.params.keyLength,
+        maxmem: kdf.params.maxmem
+      },
+      salt: kdf.salt
+    };
+  }
+  return {
+    algorithm: kdf.algorithm,
+    params: {
+      memoryKiB: kdf.params.memoryKiB,
+      iterations: kdf.params.iterations,
+      parallelism: kdf.params.parallelism,
+      keyLength: kdf.params.keyLength
+    },
+    salt: kdf.salt
+  };
+}
+function parseMetadata(json) {
+  if (typeof json !== "string") {
+    throw new Error("metadata input must be a string");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`metadata is not valid JSON: ${msg}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("metadata must be a JSON object");
+  }
+  const obj = parsed;
+  if (obj.format !== METADATA_FORMAT) {
+    throw new Error(
+      `unexpected metadata format: ${String(obj.format)} (expected ${METADATA_FORMAT})`
+    );
+  }
+  if (obj.formatVersion !== METADATA_FORMAT_VERSION) {
+    throw new Error(
+      `unsupported metadata formatVersion: ${String(obj.formatVersion)} (this build supports ${METADATA_FORMAT_VERSION})`
+    );
+  }
+  if (typeof obj.createdAt !== "string" || obj.createdAt.length === 0) {
+    throw new Error("metadata.createdAt must be a non-empty string");
+  }
+  if (obj.note !== void 0 && typeof obj.note !== "string") {
+    throw new Error("metadata.note must be a string when present");
+  }
+  const kdf = parseKdf(obj.kdf);
+  const meta = {
+    format: METADATA_FORMAT,
+    formatVersion: METADATA_FORMAT_VERSION,
+    kdf,
+    createdAt: obj.createdAt
+  };
+  if (typeof obj.note === "string") {
+    meta.note = obj.note;
+  }
+  validateMetadata(meta);
+  return meta;
+}
+function parseKdf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("metadata.kdf must be an object");
+  }
+  const k = value;
+  if (k.algorithm !== "scrypt" && k.algorithm !== "argon2id") {
+    throw new Error(`metadata.kdf.algorithm must be 'scrypt' or 'argon2id', got ${String(k.algorithm)}`);
+  }
+  if (typeof k.salt !== "string") {
+    throw new Error("metadata.kdf.salt must be a hex string");
+  }
+  hexToBytes(k.salt, KDF_SALT_LENGTH);
+  if (typeof k.params !== "object" || k.params === null || Array.isArray(k.params)) {
+    throw new Error("metadata.kdf.params must be an object");
+  }
+  const params = k.params;
+  if (k.algorithm === "scrypt") {
+    const required = ["N", "r", "p", "keyLength", "maxmem"];
+    for (const key of required) {
+      if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
+        throw new Error(`metadata.kdf.params.${key} must be a finite number`);
+      }
+    }
+    return {
+      algorithm: "scrypt",
+      params: {
+        N: params.N,
+        r: params.r,
+        p: params.p,
+        keyLength: params.keyLength,
+        maxmem: params.maxmem
+      },
+      salt: k.salt
+    };
+  }
+  const required2 = [
+    "memoryKiB",
+    "iterations",
+    "parallelism",
+    "keyLength"
+  ];
+  for (const key of required2) {
+    if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
+      throw new Error(`metadata.kdf.params.${key} must be a finite number`);
+    }
+  }
+  return {
+    algorithm: "argon2id",
+    params: {
+      memoryKiB: params.memoryKiB,
+      iterations: params.iterations,
+      parallelism: params.parallelism,
+      keyLength: params.keyLength
+    },
+    salt: k.salt
+  };
+}
+function validateMetadata(meta) {
+  if (meta.format !== METADATA_FORMAT) {
+    throw new Error(`metadata.format must be ${METADATA_FORMAT}`);
+  }
+  if (meta.formatVersion !== METADATA_FORMAT_VERSION) {
+    throw new Error(`metadata.formatVersion must be ${METADATA_FORMAT_VERSION}`);
+  }
+  if (typeof meta.createdAt !== "string" || meta.createdAt.length === 0) {
+    throw new Error("metadata.createdAt must be a non-empty ISO-8601 string");
+  }
+  hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
+  if (meta.kdf.algorithm === "scrypt") {
+    const { N, r, p, keyLength, maxmem } = meta.kdf.params;
+    if (!Number.isInteger(N) || N < 2 || N > 2 ** 30 || !Number.isInteger(Math.log2(N))) {
+      throw new Error("metadata.kdf.params.N must be a power of 2 in [2, 2^30]");
+    }
+    if (!Number.isInteger(r) || r < 1) {
+      throw new Error("metadata.kdf.params.r must be a positive integer");
+    }
+    if (!Number.isInteger(p) || p < 1) {
+      throw new Error("metadata.kdf.params.p must be a positive integer");
+    }
+    if (!Number.isInteger(keyLength) || keyLength !== 32) {
+      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
+    }
+    if (!Number.isInteger(maxmem) || maxmem < 1024) {
+      throw new Error("metadata.kdf.params.maxmem must be a positive integer");
+    }
+  } else if (meta.kdf.algorithm === "argon2id") {
+    const { memoryKiB, iterations, parallelism, keyLength } = meta.kdf.params;
+    if (!Number.isInteger(memoryKiB) || memoryKiB < 8) {
+      throw new Error("metadata.kdf.params.memoryKiB must be \u2265 8");
+    }
+    if (!Number.isInteger(iterations) || iterations < 1) {
+      throw new Error("metadata.kdf.params.iterations must be a positive integer");
+    }
+    if (!Number.isInteger(parallelism) || parallelism < 1 || parallelism > 255) {
+      throw new Error("metadata.kdf.params.parallelism must be an integer in [1, 255]");
+    }
+    if (!Number.isInteger(keyLength) || keyLength !== 32) {
+      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
+    }
+  }
+}
+function decodeMetadataSalt(meta) {
+  return hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
+}
+
+export {
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  buildMetadata,
+  serializeMetadata,
+  parseMetadata,
+  validateMetadata,
+  decodeMetadataSalt
+};
+//# sourceMappingURL=chunk-UKJAGEXH.js.map

package/dist/chunk-UKJAGEXH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/secure-store/metadata.ts"],"sourcesContent":["/**\n * Secure-store metadata file format.\n *\n * Issue #690 (PR 1/4) — pure data structure + serialize/parse helpers.\n * No I/O. The eventual `secure-store init` CLI (PR 2/4) will be the\n * surface that actually writes a metadata file to disk.\n *\n * Purpose\n * -------\n * When at-rest encryption is enabled, the memory directory needs a\n * stable record of:\n *\n *   - which KDF algorithm was used to derive the master key,\n *   - the algorithm parameters (so changing OWASP defaults later\n *     doesn't break existing stores),\n *   - the canonical salt for the master key,\n *   - the metadata format version (so we can evolve the file).\n *\n * Crucially, the metadata file does **not** contain the master key,\n * the passphrase, or anything that would let an attacker decrypt\n * memories. It contains only the public parameters needed to\n * re-derive the same key from the same passphrase.\n *\n * On-disk shape\n * -------------\n * The file is JSON. All binary fields are encoded as lowercase hex\n * strings (chosen over base64 for readability when the file is\n * `cat`'d during incident response).\n *\n *   {\n *     \"format\": \"remnic.secure-store.metadata\",\n *     \"formatVersion\": 1,\n *     \"kdf\": {\n *       \"algorithm\": \"argon2id\",\n *       \"params\": { \"memoryKiB\": 65536, \"iterations\": 3, \"parallelism\": 4, \"keyLength\": 32 },\n *       \"salt\": \"<32-hex-chars-for-16-bytes>\"\n *     },\n *     \"createdAt\": \"<ISO-8601 timestamp>\",\n *     \"note\": \"<optional human-readable note>\"\n *   }\n */\n\nimport {\n  DEFAULT_ARGON2ID_PARAMS,\n  DEFAULT_SCRYPT_PARAMS,\n  KDF_SALT_LENGTH,\n  type Argon2idParams,\n  type KdfAlgorithm,\n  type ScryptParams,\n} from \"./kdf.js\";\n\n/** Stable identifier so we can sniff the file shape without parsing JSON. */\nexport const METADATA_FORMAT = \"remnic.secure-store.metadata\" as const;\n\n/** Current metadata format version. Bump on breaking schema changes. */\nexport const METADATA_FORMAT_VERSION = 1 as const;\n\nexport interface SecureStoreMetadataKdfScrypt {\n  algorithm: \"scrypt\";\n  params: ScryptParams;\n  /** Hex-encoded salt. Length must match `KDF_SALT_LENGTH` after decode. */\n  salt: string;\n}\n\nexport interface SecureStoreMetadataKdfArgon2id {\n  algorithm: \"argon2id\";\n  params: Argon2idParams;\n  salt: string;\n}\n\nexport type SecureStoreMetadataKdf =\n  | SecureStoreMetadataKdfScrypt\n  | SecureStoreMetadataKdfArgon2id;\n\nexport interface SecureStoreMetadata {\n  format: typeof METADATA_FORMAT;\n  formatVersion: number;\n  kdf: SecureStoreMetadataKdf;\n  /** ISO-8601 timestamp recorded at init time. */\n  createdAt: string;\n  /** Optional human-readable note. Never persist secrets here. */\n  note?: string;\n}\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  return Buffer.from(bytes).toString(\"hex\");\n}\n\nfunction hexToBytes(hex: string, expectedLength: number): Buffer {\n  if (typeof hex !== \"string\") {\n    throw new Error(\"hex field must be a string\");\n  }\n  if (!/^[0-9a-f]*$/i.test(hex)) {\n    throw new Error(\"hex field must contain only hexadecimal characters\");\n  }\n  if (hex.length % 2 !== 0) {\n    throw new Error(\"hex field must have even length\");\n  }\n  const buf = Buffer.from(hex, \"hex\");\n  if (buf.length !== expectedLength) {\n    throw new Error(\n      `hex field decoded to ${buf.length} bytes, expected ${expectedLength}`,\n    );\n  }\n  return buf;\n}\n\nexport interface BuildMetadataOptions {\n  algorithm: KdfAlgorithm;\n  salt: Uint8Array;\n  /** Optional override; defaults to `DEFAULT_SCRYPT_PARAMS` / `DEFAULT_ARGON2ID_PARAMS`. */\n  params?: ScryptParams | Argon2idParams;\n  /** Optional ISO timestamp. Defaults to `new Date().toISOString()`. */\n  createdAt?: string;\n  /** Optional human-readable note. */\n  note?: string;\n}\n\n/**\n * Build an in-memory `SecureStoreMetadata` object from the given\n * algorithm + salt. Pure: does not touch the filesystem or the clock\n * unless `createdAt` is omitted (in which case `new Date()` is read).\n */\nexport function buildMetadata(options: BuildMetadataOptions): SecureStoreMetadata {\n  const { algorithm, salt } = options;\n  if (!(salt instanceof Uint8Array) || salt.length !== KDF_SALT_LENGTH) {\n    throw new Error(\n      `salt must be ${KDF_SALT_LENGTH} bytes, got ${salt?.length ?? \"non-buffer\"}`,\n    );\n  }\n  const createdAt = options.createdAt ?? new Date().toISOString();\n\n  let kdf: SecureStoreMetadataKdf;\n  if (algorithm === \"scrypt\") {\n    const params = (options.params as ScryptParams | undefined) ?? {\n      ...DEFAULT_SCRYPT_PARAMS,\n    };\n    kdf = { algorithm: \"scrypt\", params, salt: bytesToHex(salt) };\n  } else if (algorithm === \"argon2id\") {\n    const params = (options.params as Argon2idParams | undefined) ?? {\n      ...DEFAULT_ARGON2ID_PARAMS,\n    };\n    kdf = { algorithm: \"argon2id\", params, salt: bytesToHex(salt) };\n  } else {\n    throw new Error(`unknown KDF algorithm: ${algorithm as string}`);\n  }\n\n  const meta: SecureStoreMetadata = {\n    format: METADATA_FORMAT,\n    formatVersion: METADATA_FORMAT_VERSION,\n    kdf,\n    createdAt,\n  };\n  if (options.note !== undefined) {\n    meta.note = options.note;\n  }\n  return meta;\n}\n\n/**\n * Serialize metadata to a stable JSON string with sorted top-level\n * keys. Stable ordering matters because hash-based integrity checks\n * may eventually consume the serialized form.\n */\nexport function serializeMetadata(meta: SecureStoreMetadata): string {\n  // Validate before serializing so we never write a malformed file.\n  validateMetadata(meta);\n  // JSON.stringify preserves insertion order; we construct the object\n  // explicitly to lock the field order.\n  const ordered: Record<string, unknown> = {\n    format: meta.format,\n    formatVersion: meta.formatVersion,\n    kdf: orderKdf(meta.kdf),\n    createdAt: meta.createdAt,\n  };\n  if (meta.note !== undefined) {\n    ordered.note = meta.note;\n  }\n  return JSON.stringify(ordered, null, 2);\n}\n\nfunction orderKdf(kdf: SecureStoreMetadataKdf): Record<string, unknown> {\n  if (kdf.algorithm === \"scrypt\") {\n    return {\n      algorithm: kdf.algorithm,\n      params: {\n        N: kdf.params.N,\n        r: kdf.params.r,\n        p: kdf.params.p,\n        keyLength: kdf.params.keyLength,\n        maxmem: kdf.params.maxmem,\n      },\n      salt: kdf.salt,\n    };\n  }\n  return {\n    algorithm: kdf.algorithm,\n    params: {\n      memoryKiB: kdf.params.memoryKiB,\n      iterations: kdf.params.iterations,\n      parallelism: kdf.params.parallelism,\n      keyLength: kdf.params.keyLength,\n    },\n    salt: kdf.salt,\n  };\n}\n\n/**\n * Parse a metadata JSON string. Throws on any structural problem.\n * Callers that need to migrate older formats should branch on\n * `formatVersion` *before* calling this; this function is strict\n * about the current version.\n */\nexport function parseMetadata(json: string): SecureStoreMetadata {\n  if (typeof json !== \"string\") {\n    throw new Error(\"metadata input must be a string\");\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(json);\n  } catch (e) {\n    const msg = e instanceof Error ? e.message : String(e);\n    throw new Error(`metadata is not valid JSON: ${msg}`);\n  }\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n    throw new Error(\"metadata must be a JSON object\");\n  }\n  const obj = parsed as Record<string, unknown>;\n  if (obj.format !== METADATA_FORMAT) {\n    throw new Error(\n      `unexpected metadata format: ${String(obj.format)} (expected ${METADATA_FORMAT})`,\n    );\n  }\n  if (obj.formatVersion !== METADATA_FORMAT_VERSION) {\n    throw new Error(\n      `unsupported metadata formatVersion: ${String(obj.formatVersion)} ` +\n        `(this build supports ${METADATA_FORMAT_VERSION})`,\n    );\n  }\n  if (typeof obj.createdAt !== \"string\" || obj.createdAt.length === 0) {\n    throw new Error(\"metadata.createdAt must be a non-empty string\");\n  }\n  if (obj.note !== undefined && typeof obj.note !== \"string\") {\n    throw new Error(\"metadata.note must be a string when present\");\n  }\n  const kdf = parseKdf(obj.kdf);\n  const meta: SecureStoreMetadata = {\n    format: METADATA_FORMAT,\n    formatVersion: METADATA_FORMAT_VERSION,\n    kdf,\n    createdAt: obj.createdAt,\n  };\n  if (typeof obj.note === \"string\") {\n    meta.note = obj.note;\n  }\n  validateMetadata(meta);\n  return meta;\n}\n\nfunction parseKdf(value: unknown): SecureStoreMetadataKdf {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new Error(\"metadata.kdf must be an object\");\n  }\n  const k = value as Record<string, unknown>;\n  if (k.algorithm !== \"scrypt\" && k.algorithm !== \"argon2id\") {\n    throw new Error(`metadata.kdf.algorithm must be 'scrypt' or 'argon2id', got ${String(k.algorithm)}`);\n  }\n  if (typeof k.salt !== \"string\") {\n    throw new Error(\"metadata.kdf.salt must be a hex string\");\n  }\n  // Decode to validate length and hex shape; we don't need the bytes here.\n  hexToBytes(k.salt, KDF_SALT_LENGTH);\n  if (typeof k.params !== \"object\" || k.params === null || Array.isArray(k.params)) {\n    throw new Error(\"metadata.kdf.params must be an object\");\n  }\n  const params = k.params as Record<string, unknown>;\n  if (k.algorithm === \"scrypt\") {\n    const required: (keyof ScryptParams)[] = [\"N\", \"r\", \"p\", \"keyLength\", \"maxmem\"];\n    for (const key of required) {\n      if (typeof params[key] !== \"number\" || !Number.isFinite(params[key] as number)) {\n        throw new Error(`metadata.kdf.params.${key} must be a finite number`);\n      }\n    }\n    return {\n      algorithm: \"scrypt\",\n      params: {\n        N: params.N as number,\n        r: params.r as number,\n        p: params.p as number,\n        keyLength: params.keyLength as number,\n        maxmem: params.maxmem as number,\n      },\n      salt: k.salt,\n    };\n  }\n  // argon2id\n  const required2: (keyof Argon2idParams)[] = [\n    \"memoryKiB\",\n    \"iterations\",\n    \"parallelism\",\n    \"keyLength\",\n  ];\n  for (const key of required2) {\n    if (typeof params[key] !== \"number\" || !Number.isFinite(params[key] as number)) {\n      throw new Error(`metadata.kdf.params.${key} must be a finite number`);\n    }\n  }\n  return {\n    algorithm: \"argon2id\",\n    params: {\n      memoryKiB: params.memoryKiB as number,\n      iterations: params.iterations as number,\n      parallelism: params.parallelism as number,\n      keyLength: params.keyLength as number,\n    },\n    salt: k.salt,\n  };\n}\n\n/** Validate a metadata object's invariants. Throws on the first problem. */\nexport function validateMetadata(meta: SecureStoreMetadata): void {\n  if (meta.format !== METADATA_FORMAT) {\n    throw new Error(`metadata.format must be ${METADATA_FORMAT}`);\n  }\n  if (meta.formatVersion !== METADATA_FORMAT_VERSION) {\n    throw new Error(`metadata.formatVersion must be ${METADATA_FORMAT_VERSION}`);\n  }\n  if (typeof meta.createdAt !== \"string\" || meta.createdAt.length === 0) {\n    throw new Error(\"metadata.createdAt must be a non-empty ISO-8601 string\");\n  }\n  // Salt round-trip check.\n  hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);\n  if (meta.kdf.algorithm === \"scrypt\") {\n    const { N, r, p, keyLength, maxmem } = meta.kdf.params;\n    // Cursor Low + codex P2: bitwise `(N & (N - 1))` truncates to\n    // 32-bit signed in JS, so for N >= 2**31 the check silently\n    // wraps and accepts non-powers-of-two like `5 * 2**30`. Use\n    // Math.log2 plus an upper bound at 2**30 so out-of-range\n    // values are rejected loudly at metadata-load time rather than\n    // locking up the KDF later.\n    if (\n      !Number.isInteger(N) ||\n      N < 2 ||\n      N > 2 ** 30 ||\n      !Number.isInteger(Math.log2(N))\n    ) {\n      throw new Error(\"metadata.kdf.params.N must be a power of 2 in [2, 2^30]\");\n    }\n    if (!Number.isInteger(r) || r < 1) {\n      throw new Error(\"metadata.kdf.params.r must be a positive integer\");\n    }\n    if (!Number.isInteger(p) || p < 1) {\n      throw new Error(\"metadata.kdf.params.p must be a positive integer\");\n    }\n    // Codex P2: cipher.ts hard-requires a 32-byte AES-256 key\n    // (`assertAesKey`). Accepting `keyLength: 16` here would parse\n    // and validate cleanly but later fail at encrypt/decrypt time\n    // — a latent runtime break. Reject anything other than 32 at\n    // load time so the metadata file is the authoritative gate.\n    if (!Number.isInteger(keyLength) || keyLength !== 32) {\n      throw new Error(\"metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)\");\n    }\n    if (!Number.isInteger(maxmem) || maxmem < 1024) {\n      throw new Error(\"metadata.kdf.params.maxmem must be a positive integer\");\n    }\n  } else if (meta.kdf.algorithm === \"argon2id\") {\n    const { memoryKiB, iterations, parallelism, keyLength } = meta.kdf.params;\n    if (!Number.isInteger(memoryKiB) || memoryKiB < 8) {\n      throw new Error(\"metadata.kdf.params.memoryKiB must be ≥ 8\");\n    }\n    if (!Number.isInteger(iterations) || iterations < 1) {\n      throw new Error(\"metadata.kdf.params.iterations must be a positive integer\");\n    }\n    if (!Number.isInteger(parallelism) || parallelism < 1 || parallelism > 255) {\n      throw new Error(\"metadata.kdf.params.parallelism must be an integer in [1, 255]\");\n    }\n    // Codex P2: cipher.ts hard-requires a 32-byte AES-256 key\n    // (`assertAesKey`). Accepting `keyLength: 16` here would parse\n    // and validate cleanly but later fail at encrypt/decrypt time\n    // — a latent runtime break. Reject anything other than 32 at\n    // load time so the metadata file is the authoritative gate.\n    if (!Number.isInteger(keyLength) || keyLength !== 32) {\n      throw new Error(\"metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)\");\n    }\n  }\n}\n\n/**\n * Decode the salt field of a metadata object back into bytes.\n * Convenience helper so callers don't reach into the hex codec.\n */\nexport function decodeMetadataSalt(meta: SecureStoreMetadata): Buffer {\n  return hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-KVBLZUKV.js → chunk-USFPPRAF.js}

@@ -1,5 +1,13 @@
+import {
+  isRecallDisclosure
+} from "./chunk-43EKP2UK.js";
+
 // src/recall-xray.ts
 import { randomUUID } from "crypto";
+function estimateRecallTokens(text) {
+  if (typeof text !== "string" || text.length === 0) return 0;
+  return Math.ceil(text.length / 4);
+}
 var RECALL_XRAY_SERVED_BY_VALUES = [
   "direct-answer",
   "hybrid",
@@ -19,7 +27,20 @@ function buildXraySnapshot(input) {
   const budgetChars = nonNegativeInt(input.budget?.chars);
   const budgetUsed = nonNegativeInt(input.budget?.used);
   const tierExplain = input.tierExplain && typeof input.tierExplain === "object" ? cloneTierExplain(input.tierExplain) : null;
-  return {
+  let peerProfileInjection;
+  if (input.peerProfileInjection && typeof input.peerProfileInjection === "object") {
+    const raw = input.peerProfileInjection;
+    const peerId = nonEmptyString(raw.peerId);
+    if (peerId !== void 0) {
+      peerProfileInjection = {
+        peerId,
+        fieldsInjected: nonNegativeInt(raw.fieldsInjected)
+      };
+    }
+  } else if (input.peerProfileInjection === null) {
+    peerProfileInjection = null;
+  }
+  const out = {
     schemaVersion: "1",
     query: typeof input.query === "string" ? input.query : "",
     snapshotId: snapshotIdGenerator(),
@@ -32,6 +53,10 @@ function buildXraySnapshot(input) {
     namespace: nonEmptyString(input.namespace),
     traceId: nonEmptyString(input.traceId)
   };
+  if (peerProfileInjection !== void 0) {
+    out.peerProfileInjection = peerProfileInjection;
+  }
+  return out;
 }
 var RecallXrayBuilder = class {
   query;
@@ -43,6 +68,7 @@ var RecallXrayBuilder = class {
   filters = [];
   budgetChars = 0;
   budgetUsed = 0;
+  peerProfileInjection;
   constructor(opts) {
     this.query = typeof opts.query === "string" ? opts.query : "";
     this.sessionKey = nonEmptyString(opts.sessionKey);
@@ -62,6 +88,14 @@ var RecallXrayBuilder = class {
     this.budgetChars = nonNegativeInt(budget.chars);
     this.budgetUsed = nonNegativeInt(budget.used);
   }
+  /**
+   * Record peer-profile injection metadata for this recall snapshot
+   * (issue #679 completion). Pass `null` to explicitly record that no
+   * injection happened (feature enabled but no peer / no profile fields).
+   */
+  setPeerProfileInjection(injection) {
+    this.peerProfileInjection = injection;
+  }
   recordResult(result) {
     this.results.push(cloneResult(result));
   }
@@ -78,6 +112,7 @@ var RecallXrayBuilder = class {
       sessionKey: this.sessionKey,
       namespace: this.namespace,
       traceId: this.traceId,
+      peerProfileInjection: this.peerProfileInjection,
       now: opts.now,
       snapshotIdGenerator: opts.snapshotIdGenerator
     });
@@ -98,6 +133,25 @@ function cloneResult(result) {
   const path = typeof result.path === "string" ? result.path : "";
   const admittedBy = Array.isArray(result.admittedBy) ? result.admittedBy.filter((x) => typeof x === "string") : [];
   const graphPath = Array.isArray(result.graphPath) ? result.graphPath.filter((x) => typeof x === "string") : void 0;
+  let graphEdgeConfidences;
+  if (Array.isArray(result.graphEdgeConfidences) && graphPath && graphPath.length > 1) {
+    const expected = graphPath.length - 1;
+    const raw = result.graphEdgeConfidences;
+    if (raw.length === expected) {
+      const cleaned = [];
+      let allFinite = true;
+      for (const value of raw) {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          allFinite = false;
+          break;
+        }
+        cleaned.push(Math.min(1, Math.max(0, value)));
+      }
+      if (allFinite) {
+        graphEdgeConfidences = cleaned;
+      }
+    }
+  }
   const auditEntryId = nonEmptyString(result.auditEntryId);
   const rejectedBy = nonEmptyString(result.rejectedBy);
   const scoreDecomposition = cloneScoreDecomposition(result.scoreDecomposition);
@@ -109,10 +163,40 @@ function cloneResult(result) {
     admittedBy
   };
   if (graphPath !== void 0) out.graphPath = graphPath;
+  if (graphEdgeConfidences !== void 0) {
+    out.graphEdgeConfidences = graphEdgeConfidences;
+  }
   if (auditEntryId !== void 0) out.auditEntryId = auditEntryId;
   if (rejectedBy !== void 0) out.rejectedBy = rejectedBy;
+  if (isRecallDisclosure(result.disclosure)) {
+    out.disclosure = result.disclosure;
+  }
+  if (typeof result.estimatedTokens === "number" && Number.isFinite(result.estimatedTokens) && result.estimatedTokens >= 0) {
+    out.estimatedTokens = Math.floor(result.estimatedTokens);
+  }
+  if (Array.isArray(result.tags)) {
+    const cleanedTags = result.tags.filter((t) => typeof t === "string").map((t) => t.trim()).filter((t) => t.length > 0);
+    if (cleanedTags.length > 0) {
+      out.tags = cleanedTags;
+    }
+  }
   return out;
 }
+function summarizeDisclosureTokens(results) {
+  const summary = {
+    chunk: { count: 0, estimatedTokens: 0 },
+    section: { count: 0, estimatedTokens: 0 },
+    raw: { count: 0, estimatedTokens: 0 },
+    unspecified: { count: 0, estimatedTokens: 0 }
+  };
+  for (const result of results) {
+    const tokens = typeof result.estimatedTokens === "number" && Number.isFinite(result.estimatedTokens) && result.estimatedTokens >= 0 ? Math.floor(result.estimatedTokens) : 0;
+    const bucket = isRecallDisclosure(result.disclosure) ? result.disclosure : "unspecified";
+    summary[bucket].count += 1;
+    summary[bucket].estimatedTokens += tokens;
+  }
+  return summary;
+}
 function cloneFilter(filter) {
   if (!filter || typeof filter !== "object") {
     throw new TypeError("RecallFilterTrace must be an object");
@@ -143,6 +227,10 @@ function cloneScoreDecomposition(value) {
   if (mmrPenalty !== void 0) out.mmrPenalty = mmrPenalty;
   const tierPrior = finiteNumber(value.tierPrior);
   if (tierPrior !== void 0) out.tierPrior = tierPrior;
+  const reinforcementBoost = finiteNumber(value.reinforcementBoost);
+  if (reinforcementBoost !== void 0 && reinforcementBoost > 0) {
+    out.reinforcementBoost = reinforcementBoost;
+  }
   return out;
 }
 function cloneTierExplain(tierExplain) {
@@ -165,9 +253,11 @@ function nonEmptyString(value) {
 }
 
 export {
+  estimateRecallTokens,
   RECALL_XRAY_SERVED_BY_VALUES,
   isRecallXrayServedBy,
   buildXraySnapshot,
-  RecallXrayBuilder
+  RecallXrayBuilder,
+  summarizeDisclosureTokens
 };
-//# sourceMappingURL=chunk-KVBLZUKV.js.map
+//# sourceMappingURL=chunk-USFPPRAF.js.map

package/dist/chunk-USFPPRAF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-xray.ts"],"sourcesContent":["/**\n * Recall X-ray snapshot schema (issue #570, PR 1).\n *\n * The X-ray surface is the unified, per-result attribution document that\n * merges the tier that served each memory, its score decomposition, any\n * graph path, an audit entry id, and the exact filter/eligibility ladder\n * that either admitted or rejected each candidate.  This file defines the\n * schema and an in-memory builder + builder-state helper.\n *\n * Scope for PR 1 (this slice):\n *   - Types only + pure builder functions (no IO, no rendering).\n *   - Orchestrator plumbing captures a snapshot when the caller passes\n *     `xrayCapture: true`.  No behavior change when the flag is absent.\n *   - NO new public surfaces here — CLI/HTTP/MCP land in later slices.\n *\n * The shared renderer lands in PR 2 at `recall-xray-renderer.ts`.  Do not\n * fork formatting logic into other surfaces; extend the renderer.\n */\n\nimport { randomUUID } from \"node:crypto\";\n\nimport type { RecallDisclosure, RecallTierExplain } from \"./types.js\";\nimport { isRecallDisclosure } from \"./types.js\";\n\n/**\n * Estimate token cost of a payload at the rough ~4 chars/token English\n * heuristic.  Non-negative integer; returns 0 for empty / null input.\n * Used by recall surfaces to attach `estimatedTokens` to X-ray results\n * (issue #677 PR 3/4).  Identical to the private heuristic in\n * `chunking.ts`; kept self-contained here so X-ray callers don't pull\n * in chunking internals.\n */\nexport function estimateRecallTokens(text: string | null | undefined): number {\n  if (typeof text !== \"string\" || text.length === 0) return 0;\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Aggregated per-disclosure token spend summary, computed by the\n * renderer from a snapshot's results.  Non-negative integers.\n */\nexport interface RecallXrayDisclosureSummary {\n  chunk: { count: number; estimatedTokens: number };\n  section: { count: number; estimatedTokens: number };\n  raw: { count: number; estimatedTokens: number };\n  /** Number of results without a recorded disclosure level. */\n  unspecified: { count: number; estimatedTokens: number };\n}\n\n/**\n * Which retrieval source produced a given result.  This is the X-ray\n * tier ladder called out in issue #570 and is *distinct* from the\n * `RetrievalTier` enum (which describes issue #518's tier-explain\n * block).  Keeping the sets separate lets the two observability\n * surfaces evolve without conflating their vocabularies:\n *\n *   - `RetrievalTier`     — direct-answer eligibility ladder.\n *   - `RecallXrayServedBy` — which source materialized each result.\n */\nexport type RecallXrayServedBy =\n  | \"direct-answer\"\n  | \"hybrid\"\n  | \"graph\"\n  | \"recent-scan\"\n  | \"procedural\"\n  | \"review-context\";\n\nexport const RECALL_XRAY_SERVED_BY_VALUES: readonly RecallXrayServedBy[] = [\n  \"direct-answer\",\n  \"hybrid\",\n  \"graph\",\n  \"recent-scan\",\n  \"procedural\",\n  \"review-context\",\n] as const;\n\nexport function isRecallXrayServedBy(\n  value: unknown,\n): value is RecallXrayServedBy {\n  return (\n    typeof value === \"string\" &&\n    (RECALL_XRAY_SERVED_BY_VALUES as readonly string[]).includes(value)\n  );\n}\n\n/**\n * Score decomposition for a single X-ray result.\n *\n * All fields are optional because different tiers populate different\n * terms: `hybrid` reports vector + bm25 + mmr penalty, `direct-answer`\n * reports importance + tier prior, etc.  The only guaranteed field is\n * `final`, which is the post-combination score used for ordering.\n */\nexport interface RecallXrayScoreDecomposition {\n  vector?: number;\n  bm25?: number;\n  importance?: number;\n  mmrPenalty?: number;\n  tierPrior?: number;\n  /** Additive boost from `reinforcement_count` frontmatter (issue #687 PR 3/4). */\n  reinforcementBoost?: number;\n  final: number;\n}\n\n/**\n * Per-result breakdown inside an X-ray snapshot.\n */\nexport interface RecallXrayResult {\n  memoryId: string;\n  path: string;\n  servedBy: RecallXrayServedBy;\n  scoreDecomposition: RecallXrayScoreDecomposition;\n  graphPath?: string[];\n  /**\n   * Issue #681 PR 3/3 — per-edge confidence values aligned with\n   * `graphPath`. When present, `graphEdgeConfidences[i]` is the\n   * confidence of the edge between `graphPath[i]` and `graphPath[i+1]`,\n   * so the array length is one less than `graphPath`. Legacy edges\n   * without a recorded confidence render as `1.0`. Operators use this\n   * to attribute floor-pruning and PageRank ranking decisions back to\n   * specific edges. The renderer drops the line when the array is\n   * empty or absent so legacy snapshots round-trip cleanly.\n   */\n  graphEdgeConfidences?: number[];\n  auditEntryId?: string;\n  /** Human-readable list of filters the candidate *passed*. */\n  admittedBy: string[];\n  /**\n   * First filter that *would have* rejected the candidate, or undefined\n   * when the candidate was admitted without a rejection trace.  When\n   * present, `admittedBy` may still contain filters the candidate passed\n   * before the rejecting gate; consumers should render both.\n   */\n  rejectedBy?: string;\n  /**\n   * Disclosure depth used to render this result's payload (issue #677\n   * PR 3/4).  Mirrors the per-result disclosure already exposed in the\n   * recall response so X-ray consumers can attribute token spend to\n   * the depth that produced it.\n   */\n  disclosure?: RecallDisclosure;\n  /**\n   * Estimated token cost of the rendered payload at the chosen\n   * disclosure depth.  Non-negative integer.  Computed by callers via\n   * `estimateRecallTokens(text)`; the renderer aggregates these into\n   * a per-disclosure summary so operators can see where their budget\n   * went.\n   */\n  estimatedTokens?: number;\n  /**\n   * Free-form tags from the memory's YAML frontmatter (issue #689 PR 3/3).\n   * Populated by the X-ray capture path when the caller passes a `tags`\n   * filter so per-result tags are available alongside the filter trace\n   * in `snapshot.filters`.  Also populated without a filter when the\n   * orchestrator decorates results via `xrayCapture: true` so all X-ray\n   * consumers can inspect memory labels without a separate storage read.\n   * Absent (not `[]`) when the frontmatter has no tags or the memory\n   * could not be read.\n   */\n  tags?: string[];\n}\n\n/**\n * Trace entry for a filter the orchestrator evaluated during recall.\n * Captures the name of the filter, how many candidates it saw, and how\n * many it let through.  Used by X-ray consumers to render the filter\n * ladder above the per-result breakdown.\n */\nexport interface RecallFilterTrace {\n  name: string;\n  considered: number;\n  admitted: number;\n  /** Optional human-readable reason for any rejections. */\n  reason?: string;\n}\n\n/**\n * Peer-profile injection annotation (issue #679 completion).\n *\n * When `peerProfileRecallEnabled` is true and a peer is registered for\n * the session, the orchestrator injects a `## Peer Profile` section into\n * the recall context. This annotation records which peer was injected and\n * how many profile fields were included so operators can correlate\n * retrieval quality with peer-context enrichment.\n *\n * `null` means no peer profile was injected (peer not registered, feature\n * disabled, or peer has no profile fields).\n */\nexport interface RecallXrayPeerProfileInjection {\n  /** The peer id whose profile was injected. */\n  peerId: string;\n  /**\n   * Number of profile fields included after the `peerProfileRecallMaxFields`\n   * cap was applied.  Zero means the profile existed but had no fields.\n   */\n  fieldsInjected: number;\n}\n\n/**\n * The unified X-ray snapshot.  CLI, HTTP, and MCP surfaces all render\n * this same shape through the shared renderer (CLAUDE.md rule 22).\n */\nexport interface RecallXraySnapshot {\n  /** Stable v1 tag so downstream consumers can version-gate their parsers. */\n  schemaVersion: \"1\";\n  query: string;\n  /** UUID minted per capture; unique across snapshots within a process. */\n  snapshotId: string;\n  /** Epoch milliseconds the snapshot was captured. */\n  capturedAt: number;\n  /**\n   * Tier-explain block from issue #518, carried verbatim when present.\n   * `null` means direct-answer tier did not run (disabled, or another\n   * tier served the query).\n   */\n  tierExplain: RecallTierExplain | null;\n  results: RecallXrayResult[];\n  filters: RecallFilterTrace[];\n  /**\n   * Character budget accounting for the final assembled recall payload.\n   * `used` is the rendered-context length; `chars` is the cap.  Both are\n   * non-negative integers in `[0, 2**31)`.\n   */\n  budget: { chars: number; used: number };\n  /** Optional session-scope fields carried for downstream filtering. */\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /**\n   * Peer-profile injection metadata (issue #679 completion).\n   * Non-null when `peerProfileRecallEnabled` is true and a peer profile\n   * was successfully injected into this recall's context. `null` (or\n   * absent) means no peer profile was injected.\n   */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n}\n\n// ─── Builder ──────────────────────────────────────────────────────────────\n\nexport interface BuildXraySnapshotInput {\n  query: string;\n  tierExplain?: RecallTierExplain | null;\n  results?: RecallXrayResult[];\n  filters?: RecallFilterTrace[];\n  budget?: { chars?: number; used?: number };\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /** Peer-profile injection metadata (issue #679 completion). */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n  /** Optional injected timestamp for deterministic tests. */\n  now?: () => number;\n  /** Optional injected id generator for deterministic tests. */\n  snapshotIdGenerator?: () => string;\n}\n\n/**\n * Build a `RecallXraySnapshot` from explicit input fields.  Pure\n * function; safe to call from anywhere.  All array/object inputs are\n * shallow-copied so caller mutation after build cannot tear the\n * returned snapshot.\n */\nexport function buildXraySnapshot(\n  input: BuildXraySnapshotInput,\n): RecallXraySnapshot {\n  const now = input.now ?? Date.now;\n  const snapshotIdGenerator = input.snapshotIdGenerator ?? randomUUID;\n\n  const results = Array.isArray(input.results)\n    ? input.results.map(cloneResult)\n    : [];\n  const filters = Array.isArray(input.filters)\n    ? input.filters.map(cloneFilter)\n    : [];\n\n  const budgetChars = nonNegativeInt(input.budget?.chars);\n  const budgetUsed = nonNegativeInt(input.budget?.used);\n\n  const tierExplain =\n    input.tierExplain && typeof input.tierExplain === \"object\"\n      ? cloneTierExplain(input.tierExplain)\n      : null;\n\n  // Peer-profile injection annotation (issue #679 completion).\n  // Deep-copy via structuredClone so the caller can't mutate the snapshot\n  // after build. Accept null explicitly (no injection) or a valid object.\n  let peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n  if (input.peerProfileInjection && typeof input.peerProfileInjection === \"object\") {\n    const raw = input.peerProfileInjection;\n    const peerId = nonEmptyString(raw.peerId);\n    if (peerId !== undefined) {\n      peerProfileInjection = {\n        peerId,\n        fieldsInjected: nonNegativeInt(raw.fieldsInjected),\n      };\n    }\n  } else if (input.peerProfileInjection === null) {\n    peerProfileInjection = null;\n  }\n\n  const out: RecallXraySnapshot = {\n    schemaVersion: \"1\",\n    query: typeof input.query === \"string\" ? input.query : \"\",\n    snapshotId: snapshotIdGenerator(),\n    capturedAt: now(),\n    tierExplain,\n    results,\n    filters,\n    budget: { chars: budgetChars, used: budgetUsed },\n    sessionKey: nonEmptyString(input.sessionKey),\n    namespace: nonEmptyString(input.namespace),\n    traceId: nonEmptyString(input.traceId),\n  };\n  if (peerProfileInjection !== undefined) {\n    out.peerProfileInjection = peerProfileInjection;\n  }\n  return out;\n}\n\n/**\n * Mutable builder used by the orchestrator to accumulate X-ray fields\n * as recall progresses.  Call `build()` to get the finalized\n * immutable-ish snapshot.  All inputs are validated at insert time so\n * a malformed entry cannot poison the snapshot later.\n */\nexport class RecallXrayBuilder {\n  private readonly query: string;\n  private readonly sessionKey: string | undefined;\n  private namespace: string | undefined;\n  private traceId: string | undefined;\n  private tierExplain: RecallTierExplain | null = null;\n  private readonly results: RecallXrayResult[] = [];\n  private readonly filters: RecallFilterTrace[] = [];\n  private budgetChars = 0;\n  private budgetUsed = 0;\n  private peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n\n  constructor(opts: {\n    query: string;\n    sessionKey?: string;\n    namespace?: string;\n    traceId?: string;\n  }) {\n    this.query = typeof opts.query === \"string\" ? opts.query : \"\";\n    this.sessionKey = nonEmptyString(opts.sessionKey);\n    this.namespace = nonEmptyString(opts.namespace);\n    this.traceId = nonEmptyString(opts.traceId);\n  }\n\n  setNamespace(namespace: string | undefined): void {\n    this.namespace = nonEmptyString(namespace);\n  }\n\n  setTraceId(traceId: string | undefined): void {\n    this.traceId = nonEmptyString(traceId);\n  }\n\n  setTierExplain(tierExplain: RecallTierExplain | null | undefined): void {\n    this.tierExplain =\n      tierExplain && typeof tierExplain === \"object\"\n        ? cloneTierExplain(tierExplain)\n        : null;\n  }\n\n  setBudget(budget: { chars?: number; used?: number }): void {\n    this.budgetChars = nonNegativeInt(budget.chars);\n    this.budgetUsed = nonNegativeInt(budget.used);\n  }\n\n  /**\n   * Record peer-profile injection metadata for this recall snapshot\n   * (issue #679 completion). Pass `null` to explicitly record that no\n   * injection happened (feature enabled but no peer / no profile fields).\n   */\n  setPeerProfileInjection(\n    injection: RecallXrayPeerProfileInjection | null,\n  ): void {\n    this.peerProfileInjection = injection;\n  }\n\n  recordResult(result: RecallXrayResult): void {\n    this.results.push(cloneResult(result));\n  }\n\n  recordFilter(filter: RecallFilterTrace): void {\n    this.filters.push(cloneFilter(filter));\n  }\n\n  build(opts: {\n    now?: () => number;\n    snapshotIdGenerator?: () => string;\n  } = {}): RecallXraySnapshot {\n    return buildXraySnapshot({\n      query: this.query,\n      tierExplain: this.tierExplain,\n      results: this.results,\n      filters: this.filters,\n      budget: { chars: this.budgetChars, used: this.budgetUsed },\n      sessionKey: this.sessionKey,\n      namespace: this.namespace,\n      traceId: this.traceId,\n      peerProfileInjection: this.peerProfileInjection,\n      now: opts.now,\n      snapshotIdGenerator: opts.snapshotIdGenerator,\n    });\n  }\n}\n\n// ─── Internals ────────────────────────────────────────────────────────────\n\nfunction cloneResult(result: RecallXrayResult): RecallXrayResult {\n  if (!result || typeof result !== \"object\") {\n    throw new TypeError(\"RecallXrayResult must be an object\");\n  }\n  if (!isRecallXrayServedBy(result.servedBy)) {\n    throw new TypeError(\n      `RecallXrayResult.servedBy must be one of ${RECALL_XRAY_SERVED_BY_VALUES.join(\n        \", \",\n      )}; got ${JSON.stringify(result.servedBy)}`,\n    );\n  }\n  const memoryId = typeof result.memoryId === \"string\" ? result.memoryId : \"\";\n  const path = typeof result.path === \"string\" ? result.path : \"\";\n  const admittedBy = Array.isArray(result.admittedBy)\n    ? result.admittedBy.filter((x): x is string => typeof x === \"string\")\n    : [];\n  const graphPath = Array.isArray(result.graphPath)\n    ? result.graphPath.filter((x): x is string => typeof x === \"string\")\n    : undefined;\n  // Issue #681 PR 3/3 — per-edge confidences alongside graph path.\n  // Each entry is clamped into [0, 1]; the array is rejected wholesale\n  // when alignment cannot be verified so downstream surfaces can rely\n  // on `graphEdgeConfidences[i]` describing the edge between\n  // `graphPath[i]` and `graphPath[i+1]`.\n  //\n  // Cursor review (#735): the input array length MUST match\n  // `graphPath.length - 1` *before* any per-element filtering. The\n  // earlier implementation skipped non-finite entries via `continue`\n  // and then length-checked the cleaned array — that would silently\n  // shift surviving values to earlier positions. Example: input\n  // `[0.5, NaN, 0.7]` for a 3-edge path would collapse to\n  // `[0.5, 0.7]`, length-check would pass against `expected = 2`, and\n  // the renderer would mis-attribute `0.7` to edge B→C when it really\n  // came from edge C→D. Reject on either size mismatch or any\n  // non-finite entry so misalignment is impossible.\n  let graphEdgeConfidences: number[] | undefined;\n  if (Array.isArray(result.graphEdgeConfidences) && graphPath && graphPath.length > 1) {\n    const expected = graphPath.length - 1;\n    const raw = result.graphEdgeConfidences;\n    if (raw.length === expected) {\n      const cleaned: number[] = [];\n      let allFinite = true;\n      for (const value of raw) {\n        if (typeof value !== \"number\" || !Number.isFinite(value)) {\n          allFinite = false;\n          break;\n        }\n        cleaned.push(Math.min(1, Math.max(0, value)));\n      }\n      if (allFinite) {\n        graphEdgeConfidences = cleaned;\n      }\n    }\n  }\n  const auditEntryId = nonEmptyString(result.auditEntryId);\n  const rejectedBy = nonEmptyString(result.rejectedBy);\n  const scoreDecomposition = cloneScoreDecomposition(result.scoreDecomposition);\n  const out: RecallXrayResult = {\n    memoryId,\n    path,\n    servedBy: result.servedBy,\n    scoreDecomposition,\n    admittedBy,\n  };\n  if (graphPath !== undefined) out.graphPath = graphPath;\n  if (graphEdgeConfidences !== undefined) {\n    out.graphEdgeConfidences = graphEdgeConfidences;\n  }\n  if (auditEntryId !== undefined) out.auditEntryId = auditEntryId;\n  if (rejectedBy !== undefined) out.rejectedBy = rejectedBy;\n  // Disclosure + token telemetry (issue #677 PR 3/4).  Only attach when\n  // present and well-formed; unknown disclosure values are dropped so a\n  // bad caller can't poison downstream renderers.  Uses the shared\n  // `isRecallDisclosure` guard so adding a fourth disclosure level\n  // requires touching only `types.ts`.\n  if (isRecallDisclosure(result.disclosure)) {\n    out.disclosure = result.disclosure;\n  }\n  if (\n    typeof result.estimatedTokens === \"number\" &&\n    Number.isFinite(result.estimatedTokens) &&\n    result.estimatedTokens >= 0\n  ) {\n    out.estimatedTokens = Math.floor(result.estimatedTokens);\n  }\n  // Tags from frontmatter (issue #689 PR 3/3).  Normalize identically to\n  // the recall-surface path: trim and drop empty strings so consumers can\n  // compare tags directly without a secondary normalization step.\n  if (Array.isArray(result.tags)) {\n    const cleanedTags = result.tags\n      .filter((t): t is string => typeof t === \"string\")\n      .map((t) => t.trim())\n      .filter((t) => t.length > 0);\n    if (cleanedTags.length > 0) {\n      out.tags = cleanedTags;\n    }\n  }\n  return out;\n}\n\n/**\n * Summarize per-disclosure token spend across an X-ray snapshot's\n * results.  Pure helper — used by the markdown renderer to print a\n * \"per-disclosure token spend\" line and exposed for tests / surfaces.\n */\nexport function summarizeDisclosureTokens(\n  results: ReadonlyArray<RecallXrayResult>,\n): RecallXrayDisclosureSummary {\n  const summary: RecallXrayDisclosureSummary = {\n    chunk: { count: 0, estimatedTokens: 0 },\n    section: { count: 0, estimatedTokens: 0 },\n    raw: { count: 0, estimatedTokens: 0 },\n    unspecified: { count: 0, estimatedTokens: 0 },\n  };\n  for (const result of results) {\n    const tokens =\n      typeof result.estimatedTokens === \"number\" &&\n      Number.isFinite(result.estimatedTokens) &&\n      result.estimatedTokens >= 0\n        ? Math.floor(result.estimatedTokens)\n        : 0;\n    const bucket = isRecallDisclosure(result.disclosure)\n      ? result.disclosure\n      : \"unspecified\";\n    summary[bucket].count += 1;\n    summary[bucket].estimatedTokens += tokens;\n  }\n  return summary;\n}\n\nfunction cloneFilter(filter: RecallFilterTrace): RecallFilterTrace {\n  if (!filter || typeof filter !== \"object\") {\n    throw new TypeError(\"RecallFilterTrace must be an object\");\n  }\n  const out: RecallFilterTrace = {\n    name: typeof filter.name === \"string\" ? filter.name : \"\",\n    considered: nonNegativeInt(filter.considered),\n    admitted: nonNegativeInt(filter.admitted),\n  };\n  const reason = nonEmptyString(filter.reason);\n  if (reason !== undefined) out.reason = reason;\n  return out;\n}\n\nfunction cloneScoreDecomposition(\n  value: RecallXrayScoreDecomposition | undefined,\n): RecallXrayScoreDecomposition {\n  if (!value || typeof value !== \"object\") {\n    return { final: 0 };\n  }\n  const out: RecallXrayScoreDecomposition = {\n    final: finiteNumber(value.final) ?? 0,\n  };\n  const vector = finiteNumber(value.vector);\n  if (vector !== undefined) out.vector = vector;\n  const bm25 = finiteNumber(value.bm25);\n  if (bm25 !== undefined) out.bm25 = bm25;\n  const importance = finiteNumber(value.importance);\n  if (importance !== undefined) out.importance = importance;\n  const mmrPenalty = finiteNumber(value.mmrPenalty);\n  if (mmrPenalty !== undefined) out.mmrPenalty = mmrPenalty;\n  const tierPrior = finiteNumber(value.tierPrior);\n  if (tierPrior !== undefined) out.tierPrior = tierPrior;\n  const reinforcementBoost = finiteNumber(value.reinforcementBoost);\n  if (reinforcementBoost !== undefined && reinforcementBoost > 0) {\n    out.reinforcementBoost = reinforcementBoost;\n  }\n  return out;\n}\n\nfunction cloneTierExplain(tierExplain: RecallTierExplain): RecallTierExplain {\n  // Use structuredClone so future RecallTierExplain additions do not\n  // silently share references through hand-enumerated fields.  The\n  // payload is JSON-shaped.\n  return structuredClone(tierExplain);\n}\n\nfunction nonNegativeInt(value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 0;\n  if (value <= 0) return 0;\n  return Math.floor(value);\n}\n\nfunction finiteNumber(value: unknown): number | undefined {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return undefined;\n  return value;\n}\n\nfunction nonEmptyString(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  if (trimmed.length === 0) return undefined;\n  return trimmed;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-EPQJM2GC.js → chunk-VTJVUHRK.js}

@@ -1,6 +1,3 @@
-import {
-  resolveHomeDir
-} from "./chunk-MARWOCVP.js";
 import {
   validateRouteTarget
 } from "./chunk-2LGMW3DJ.js";
@@ -139,19 +136,9 @@ function validateReplayTurn(turn, index) {
   return issues;
 }
 
-// src/utils/path.ts
-import path from "path";
-function expandTildePath(p) {
-  if (p === "~") return resolveHomeDir();
-  if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path.join(resolveHomeDir(), p.slice(2));
-  }
-  return p;
-}
-
 // src/routing/store.ts
 import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "fs/promises";
-import path2 from "path";
+import path from "path";
 import { createHash } from "crypto";
 function defaultState() {
   return {
@@ -170,14 +157,14 @@ function stableRuleId(rule) {
   return `route-${createHash("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path2.resolve(memoryDir);
-  const defaultPath = path2.join(root, "state", "routing-rules.json");
-  if (path2.isAbsolute(stateFile)) {
-    const absolute = path2.resolve(stateFile);
-    return absolute.startsWith(root + path2.sep) ? absolute : defaultPath;
+  const root = path.resolve(memoryDir);
+  const defaultPath = path.join(root, "state", "routing-rules.json");
+  if (path.isAbsolute(stateFile)) {
+    const absolute = path.resolve(stateFile);
+    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;
   }
-  const resolved = path2.resolve(root, stateFile);
-  return resolved.startsWith(root + path2.sep) ? resolved : defaultPath;
+  const resolved = path.resolve(root, stateFile);
+  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -210,7 +197,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path2.resolve(memoryDir);
+    this.memoryRoot = path.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -316,7 +303,7 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir(path2.dirname(this.lockPath), { recursive: true });
+    await mkdir(path.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
         await mkdir(this.lockPath);
@@ -351,12 +338,12 @@ var RoutingRulesStore = class {
   async assertStatePathScoped() {
     await mkdir(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path2.dirname(this.statePath));
-    const canonicalStatePath = path2.join(canonicalParent, path2.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));
+    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir(path2.dirname(this.statePath), { recursive: true });
+    await mkdir(path.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -373,28 +360,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path2.resolve(root);
-    const normalizedCandidate = path2.resolve(candidate);
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path2.parse(normalizedRoot).root) {
+    if (normalizedRoot === path.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path2.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path2.resolve(targetPath);
+    const absoluteTarget = path.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path2.relative(probe, absoluteTarget);
-        return path2.resolve(canonicalProbe, remainder);
+        const remainder = path.relative(probe, absoluteTarget);
+        return path.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path2.dirname(probe);
+        const parent = path.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -411,7 +398,6 @@ export {
   normalizeReplaySessionKey,
   parseIsoTimestamp,
   validateReplayTurn,
-  expandTildePath,
   RoutingRulesStore
 };
-//# sourceMappingURL=chunk-EPQJM2GC.js.map
+//# sourceMappingURL=chunk-VTJVUHRK.js.map