@remnic/core 9.49.0 → 9.49.1

package/dist/chunk-ACPCA4NO.js

@@ -0,0 +1,321 @@
+import {
+  resolveAbstractionNodeStoreDir,
+  validateAbstractionNode
+} from "./chunk-DJUKBGAD.js";
+import {
+  compareDeterministicStrings,
+  mergeSortedUniqueStrings
+} from "./chunk-G73MCJKL.js";
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalStringArray,
+  validateStringRecord
+} from "./chunk-A2IYSXDQ.js";
+import {
+  listJsonFilesStrict,
+  readJsonFile,
+  withJsonStoreMutationLock,
+  writeJsonFileAtomic
+} from "./chunk-P77QX3ID.js";
+
+// src/cue-anchors.ts
+import { mkdir, unlink, writeFile } from "fs/promises";
+import path from "path";
+function validateAnchorType(raw) {
+  const value = assertString(raw, "anchorType");
+  if (!["entity", "file", "tool", "outcome", "constraint", "date"].includes(value)) {
+    throw new Error("anchorType must be one of entity|file|tool|outcome|constraint|date");
+  }
+  return value;
+}
+function validateNodeRefs(raw) {
+  const nodeRefs = optionalStringArray(raw, "nodeRefs");
+  if (!nodeRefs || nodeRefs.length === 0) {
+    throw new Error("nodeRefs must contain at least one node reference");
+  }
+  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));
+}
+function validateSourceMemoryIdsByNodeRef(raw) {
+  if (raw === void 0) return void 0;
+  if (!isRecord(raw)) throw new Error("sourceMemoryIdsByNodeRef must be an object of string arrays");
+  const entries = [];
+  for (const [rawNodeRef, rawSourceMemoryIds] of Object.entries(raw)) {
+    const nodeRef = assertSafePathSegment(
+      assertString(rawNodeRef, "sourceMemoryIdsByNodeRef key"),
+      "sourceMemoryIdsByNodeRef.nodeRef"
+    );
+    const sourceMemoryIds = optionalStringArray(rawSourceMemoryIds, `sourceMemoryIdsByNodeRef.${nodeRef}`);
+    if (sourceMemoryIds) entries.push([nodeRef, mergeSortedUniqueStrings(sourceMemoryIds)]);
+  }
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries.sort(([left], [right]) => compareDeterministicStrings(left, right)));
+}
+function mergeSourceMemoryIdsByNodeRef(existing, incoming) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [nodeRef, sourceMemoryIds] of Object.entries(existing ?? {})) {
+    merged.set(nodeRef, [...sourceMemoryIds]);
+  }
+  for (const [nodeRef, sourceMemoryIds] of Object.entries(incoming ?? {})) {
+    merged.set(nodeRef, mergeSortedUniqueStrings(merged.get(nodeRef), sourceMemoryIds));
+  }
+  return validateSourceMemoryIdsByNodeRef(Object.fromEntries(merged));
+}
+function boundSourceMemoryIdsByNodeRef(sourceMemoryIdsByNodeRef, nodeRefs, liveNodes) {
+  if (!sourceMemoryIdsByNodeRef) return void 0;
+  const retained = Object.fromEntries(
+    nodeRefs.flatMap((nodeRef) => {
+      const sourceMemoryIds = sourceMemoryIdsByNodeRef[nodeRef];
+      if (!sourceMemoryIds) return [];
+      const liveSourceMemoryIds = liveNodes?.get(nodeRef)?.sourceMemoryIds;
+      if (liveNodes && !liveSourceMemoryIds) return [];
+      const retainedSourceMemoryIds = mergeSortedUniqueStrings(sourceMemoryIds).filter(
+        (sourceMemoryId) => liveSourceMemoryIds ? liveSourceMemoryIds.includes(sourceMemoryId) : true
+      );
+      return retainedSourceMemoryIds.length > 0 ? [[nodeRef, retainedSourceMemoryIds]] : [];
+    })
+  );
+  return validateSourceMemoryIdsByNodeRef(retained);
+}
+function resolveCueAnchorStoreDir(abstractionNodeStoreDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(abstractionNodeStoreDir, "anchors");
+}
+function validateCueAnchor(raw) {
+  if (!isRecord(raw)) throw new Error("cue anchor must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    anchorId: assertSafePathSegment(assertString(raw.anchorId, "anchorId"), "anchorId"),
+    anchorType: validateAnchorType(raw.anchorType),
+    anchorValue: assertString(raw.anchorValue, "anchorValue"),
+    normalizedCue: assertString(raw.normalizedCue, "normalizedCue"),
+    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString(raw.sessionKey, "sessionKey"),
+    nodeRefs: validateNodeRefs(raw.nodeRefs),
+    sourceMemoryIdsByNodeRef: validateSourceMemoryIdsByNodeRef(raw.sourceMemoryIdsByNodeRef),
+    tags: optionalStringArray(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function recordCueAnchor(options) {
+  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path.join(options.memoryDir, "state", "abstraction-nodes");
+  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
+  const validated = validateCueAnchor(options.anchor);
+  const boundedNodeRefs = boundNodeRefs(validated.nodeRefs);
+  const bounded = validateCueAnchor({
+    ...validated,
+    nodeRefs: boundedNodeRefs,
+    sourceMemoryIdsByNodeRef: boundSourceMemoryIdsByNodeRef(validated.sourceMemoryIdsByNodeRef, boundedNodeRefs)
+  });
+  const anchorDir = path.join(rootDir, bounded.anchorType);
+  const filePath = path.join(anchorDir, `${bounded.anchorId}.json`);
+  await mkdir(anchorDir, { recursive: true });
+  await writeFile(filePath, JSON.stringify(bounded, null, 2), "utf8");
+  return filePath;
+}
+function mergeSortedValues(existing, incoming) {
+  return mergeSortedUniqueStrings(existing, incoming);
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function boundNodeRefs(nodeRefs, liveNodes) {
+  const uniqueRefs = mergeSortedUniqueStrings(nodeRefs);
+  if (!liveNodes) return uniqueRefs.slice(0, 50);
+  return uniqueRefs.filter((nodeRef) => liveNodes.has(nodeRef)).sort(
+    (left, right) => Date.parse(liveNodes.get(right)?.recordedAt ?? "") - Date.parse(liveNodes.get(left)?.recordedAt ?? "") || compareDeterministicStrings(left, right)
+  ).slice(0, 50);
+}
+async function readLiveNodes(nodesDir) {
+  const liveNodes = /* @__PURE__ */ new Map();
+  let nodeFiles;
+  try {
+    nodeFiles = await listJsonFilesStrict(nodesDir);
+  } catch (error) {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  }
+  for (const filePath of nodeFiles) {
+    const node = validateAbstractionNode(await readJsonFile(filePath));
+    const previous = liveNodes.get(node.nodeId);
+    if (!previous || Date.parse(previous.recordedAt) < Date.parse(node.recordedAt) || Date.parse(previous.recordedAt) === Date.parse(node.recordedAt) && compareDeterministicStrings(previous.sessionKey, node.sessionKey) < 0) {
+      liveNodes.set(node.nodeId, node);
+    }
+  }
+  return liveNodes;
+}
+async function upsertCueAnchors(options) {
+  const abstractionNodeStoreDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const incomingAnchors = options.anchors.map(validateCueAnchor);
+  if (incomingAnchors.length === 0) return [];
+  return withJsonStoreMutationLock(abstractionNodeStoreDir, async () => {
+    const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
+    const liveNodes = await readLiveNodes(path.join(abstractionNodeStoreDir, "nodes"));
+    const incomingByKey = /* @__PURE__ */ new Map();
+    for (const anchor of incomingAnchors) {
+      const key = `${anchor.anchorType}\0${anchor.anchorId}`;
+      const grouped = incomingByKey.get(key) ?? [];
+      grouped.push(anchor);
+      incomingByKey.set(key, grouped);
+    }
+    const filePaths = [];
+    for (const key of [...incomingByKey.keys()].sort(compareDeterministicStrings)) {
+      const grouped = incomingByKey.get(key) ?? [];
+      grouped.sort(compareIncomingCueAnchors);
+      const incoming = grouped.shift();
+      if (!incoming) throw new Error(`cue anchor batch has no anchor: ${key}`);
+      const filePath = path.join(rootDir, incoming.anchorType, `${incoming.anchorId}.json`);
+      let existing;
+      try {
+        existing = validateCueAnchor(await readJsonFile(filePath));
+      } catch (error) {
+        if (!isNotFoundError(error)) throw error;
+      }
+      let merged = mergeCueAnchors(existing, incoming, liveNodes);
+      for (const next of grouped) merged = mergeCueAnchors(merged, next, liveNodes);
+      await writeJsonFileAtomic(filePath, merged);
+      filePaths.push(filePath);
+    }
+    return filePaths;
+  });
+}
+function compareIncomingCueAnchors(left, right) {
+  const recordedAtComparison = Date.parse(left.recordedAt) - Date.parse(right.recordedAt);
+  if (recordedAtComparison < 0) return -1;
+  if (recordedAtComparison > 0) return 1;
+  return compareDeterministicStrings(canonicalCueAnchorKey(left), canonicalCueAnchorKey(right));
+}
+function canonicalMetadata(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata ?? {}).sort(([left], [right]) => compareDeterministicStrings(left, right))
+  );
+}
+function canonicalCueAnchorKey(anchor) {
+  return JSON.stringify({
+    ...anchor,
+    metadata: canonicalMetadata(anchor.metadata)
+  });
+}
+function mergeCueAnchors(existing, incoming, liveNodes) {
+  const incomingIsNewest = !existing || Date.parse(existing.recordedAt) <= Date.parse(incoming.recordedAt);
+  const newest = incomingIsNewest ? incoming : existing;
+  const older = incomingIsNewest ? existing : incoming;
+  const mergedMetadata = canonicalMetadata({
+    ...older?.metadata ?? {},
+    ...newest.metadata ?? {}
+  });
+  const nodeRefs = boundNodeRefs(mergeSortedValues(existing?.nodeRefs, incoming.nodeRefs), liveNodes);
+  return validateCueAnchor({
+    ...newest,
+    nodeRefs,
+    sourceMemoryIdsByNodeRef: boundSourceMemoryIdsByNodeRef(
+      mergeSourceMemoryIdsByNodeRef(existing?.sourceMemoryIdsByNodeRef, incoming.sourceMemoryIdsByNodeRef),
+      nodeRefs,
+      liveNodes
+    ),
+    tags: mergeSortedValues(existing?.tags, incoming.tags),
+    metadata: mergedMetadata
+  });
+}
+async function upsertCueAnchor(options) {
+  const [filePath] = await upsertCueAnchors({ ...options, anchors: [options.anchor] });
+  if (!filePath) throw new Error("cue anchor upsert did not write a file");
+  return filePath;
+}
+async function pruneOrphanCueAnchors(options) {
+  const abstractionNodeStoreDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  return withJsonStoreMutationLock(abstractionNodeStoreDir, async () => {
+    const cueAnchorStoreDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
+    const liveNodes = await readLiveNodes(path.join(abstractionNodeStoreDir, "nodes")) ?? /* @__PURE__ */ new Map();
+    let removed = 0;
+    const anchorFiles = await listJsonFilesStrict(cueAnchorStoreDir, {
+      allowMissingDirectory: true
+    });
+    for (const filePath of anchorFiles) {
+      let anchor;
+      try {
+        anchor = validateCueAnchor(await readJsonFile(filePath));
+      } catch {
+        continue;
+      }
+      const nodeRefs = boundNodeRefs(anchor.nodeRefs, liveNodes);
+      const sourceMemoryIdsByNodeRef = boundSourceMemoryIdsByNodeRef(
+        anchor.sourceMemoryIdsByNodeRef,
+        nodeRefs,
+        liveNodes
+      );
+      if (nodeRefs.length === 0) {
+        try {
+          await unlink(filePath);
+          removed++;
+        } catch (error) {
+          if (!isNotFoundError(error)) throw error;
+        }
+        continue;
+      }
+      if (nodeRefs.length !== anchor.nodeRefs.length || nodeRefs.some((nodeRef, index) => nodeRef !== anchor.nodeRefs[index]) || JSON.stringify(sourceMemoryIdsByNodeRef) !== JSON.stringify(anchor.sourceMemoryIdsByNodeRef)) {
+        await writeJsonFileAtomic(filePath, validateCueAnchor({ ...anchor, nodeRefs, sourceMemoryIdsByNodeRef }));
+      }
+    }
+    return removed;
+  });
+}
+async function getCueAnchorStoreStatus(options) {
+  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path.join(options.memoryDir, "state", "abstraction-nodes");
+  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
+  const files = await listJsonFilesStrict(rootDir, { allowMissingDirectory: true });
+  const anchors = [];
+  const invalidAnchors = [];
+  for (const filePath of files) {
+    try {
+      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidAnchors.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  anchors.sort(
+    (a, b) => Date.parse(b.recordedAt) - Date.parse(a.recordedAt) || compareDeterministicStrings(a.anchorId, b.anchorId)
+  );
+  const byType = {};
+  let totalNodeRefs = 0;
+  for (const anchor of anchors) {
+    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;
+    totalNodeRefs += anchor.nodeRefs.length;
+  }
+  return {
+    enabled: options.enabled,
+    anchorsEnabled: options.anchorsEnabled,
+    rootDir,
+    anchors: {
+      total: files.length,
+      valid: anchors.length,
+      invalid: invalidAnchors.length,
+      byType,
+      totalNodeRefs,
+      latestAnchorId: anchors[0]?.anchorId,
+      latestRecordedAt: anchors[0]?.recordedAt,
+      latestSessionKey: anchors[0]?.sessionKey
+    },
+    latestAnchor: anchors[0],
+    invalidAnchors
+  };
+}
+
+export {
+  resolveCueAnchorStoreDir,
+  validateCueAnchor,
+  recordCueAnchor,
+  upsertCueAnchors,
+  upsertCueAnchor,
+  pruneOrphanCueAnchors,
+  getCueAnchorStoreStatus
+};
+//# sourceMappingURL=chunk-ACPCA4NO.js.map

package/dist/chunk-ACPCA4NO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cue-anchors.ts"],"sourcesContent":["import { mkdir, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { resolveAbstractionNodeStoreDir, validateAbstractionNode, type AbstractionNode } from \"./abstraction-nodes.js\";\nimport { listJsonFilesStrict, readJsonFile, withJsonStoreMutationLock, writeJsonFileAtomic } from \"./json-store.js\";\nimport { compareDeterministicStrings, mergeSortedUniqueStrings } from \"./deterministic-order.js\";\nimport {\n  assertIsoRecordedAt,\n  assertSafePathSegment,\n  assertString,\n  isRecord,\n  optionalStringArray,\n  validateStringRecord,\n} from \"./store-contract.js\";\n\nexport type CueAnchorType = \"entity\" | \"file\" | \"tool\" | \"outcome\" | \"constraint\" | \"date\";\n\nexport interface CueAnchor {\n  schemaVersion: 1;\n  anchorId: string;\n  anchorType: CueAnchorType;\n  anchorValue: string;\n  normalizedCue: string;\n  recordedAt: string;\n  sessionKey: string;\n  nodeRefs: string[];\n  sourceMemoryIdsByNodeRef?: Record<string, string[]>;\n  tags?: string[];\n  metadata?: Record<string, string>;\n}\n\nexport interface CueAnchorStoreStatus {\n  enabled: boolean;\n  anchorsEnabled: boolean;\n  rootDir: string;\n  anchors: {\n    total: number;\n    valid: number;\n    invalid: number;\n    byType: Partial<Record<CueAnchorType, number>>;\n    totalNodeRefs: number;\n    latestAnchorId?: string;\n    latestRecordedAt?: string;\n    latestSessionKey?: string;\n  };\n  latestAnchor?: CueAnchor;\n  invalidAnchors: Array<{\n    path: string;\n    error: string;\n  }>;\n}\n\nfunction validateAnchorType(raw: unknown): CueAnchorType {\n  const value = assertString(raw, \"anchorType\");\n  if (![\"entity\", \"file\", \"tool\", \"outcome\", \"constraint\", \"date\"].includes(value)) {\n    throw new Error(\"anchorType must be one of entity|file|tool|outcome|constraint|date\");\n  }\n  return value as CueAnchorType;\n}\n\nfunction validateNodeRefs(raw: unknown): string[] {\n  const nodeRefs = optionalStringArray(raw, \"nodeRefs\");\n  if (!nodeRefs || nodeRefs.length === 0) {\n    throw new Error(\"nodeRefs must contain at least one node reference\");\n  }\n  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));\n}\n\nfunction validateSourceMemoryIdsByNodeRef(raw: unknown): Record<string, string[]> | undefined {\n  if (raw === undefined) return undefined;\n  if (!isRecord(raw)) throw new Error(\"sourceMemoryIdsByNodeRef must be an object of string arrays\");\n  const entries: Array<[string, string[]]> = [];\n  for (const [rawNodeRef, rawSourceMemoryIds] of Object.entries(raw)) {\n    const nodeRef = assertSafePathSegment(\n      assertString(rawNodeRef, \"sourceMemoryIdsByNodeRef key\"),\n      \"sourceMemoryIdsByNodeRef.nodeRef\"\n    );\n    const sourceMemoryIds = optionalStringArray(rawSourceMemoryIds, `sourceMemoryIdsByNodeRef.${nodeRef}`);\n    if (sourceMemoryIds) entries.push([nodeRef, mergeSortedUniqueStrings(sourceMemoryIds)]);\n  }\n  if (entries.length === 0) return undefined;\n  return Object.fromEntries(entries.sort(([left], [right]) => compareDeterministicStrings(left, right)));\n}\n\nfunction mergeSourceMemoryIdsByNodeRef(\n  existing: Record<string, string[]> | undefined,\n  incoming: Record<string, string[]> | undefined\n): Record<string, string[]> | undefined {\n  const merged = new Map<string, string[]>();\n  for (const [nodeRef, sourceMemoryIds] of Object.entries(existing ?? {})) {\n    merged.set(nodeRef, [...sourceMemoryIds]);\n  }\n  for (const [nodeRef, sourceMemoryIds] of Object.entries(incoming ?? {})) {\n    merged.set(nodeRef, mergeSortedUniqueStrings(merged.get(nodeRef), sourceMemoryIds));\n  }\n  return validateSourceMemoryIdsByNodeRef(Object.fromEntries(merged));\n}\n\nfunction boundSourceMemoryIdsByNodeRef(\n  sourceMemoryIdsByNodeRef: Record<string, string[]> | undefined,\n  nodeRefs: string[],\n  liveNodes?: Map<string, AbstractionNode>\n): Record<string, string[]> | undefined {\n  if (!sourceMemoryIdsByNodeRef) return undefined;\n  const retained = Object.fromEntries(\n    nodeRefs.flatMap((nodeRef) => {\n      const sourceMemoryIds = sourceMemoryIdsByNodeRef[nodeRef];\n      if (!sourceMemoryIds) return [];\n      const liveSourceMemoryIds = liveNodes?.get(nodeRef)?.sourceMemoryIds;\n      if (liveNodes && !liveSourceMemoryIds) return [];\n      const retainedSourceMemoryIds = mergeSortedUniqueStrings(sourceMemoryIds).filter((sourceMemoryId) =>\n        liveSourceMemoryIds ? liveSourceMemoryIds.includes(sourceMemoryId) : true\n      );\n      return retainedSourceMemoryIds.length > 0 ? [[nodeRef, retainedSourceMemoryIds] as const] : [];\n    })\n  );\n  return validateSourceMemoryIdsByNodeRef(retained);\n}\n\nexport function resolveCueAnchorStoreDir(abstractionNodeStoreDir: string, overrideDir?: string): string {\n  if (typeof overrideDir === \"string\" && overrideDir.trim().length > 0) {\n    return overrideDir.trim();\n  }\n  return path.join(abstractionNodeStoreDir, \"anchors\");\n}\n\nexport function validateCueAnchor(raw: unknown): CueAnchor {\n  if (!isRecord(raw)) throw new Error(\"cue anchor must be an object\");\n  if (raw.schemaVersion !== 1) throw new Error(\"schemaVersion must be 1\");\n\n  return {\n    schemaVersion: 1,\n    anchorId: assertSafePathSegment(assertString(raw.anchorId, \"anchorId\"), \"anchorId\"),\n    anchorType: validateAnchorType(raw.anchorType),\n    anchorValue: assertString(raw.anchorValue, \"anchorValue\"),\n    normalizedCue: assertString(raw.normalizedCue, \"normalizedCue\"),\n    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, \"recordedAt\")),\n    sessionKey: assertString(raw.sessionKey, \"sessionKey\"),\n    nodeRefs: validateNodeRefs(raw.nodeRefs),\n    sourceMemoryIdsByNodeRef: validateSourceMemoryIdsByNodeRef(raw.sourceMemoryIdsByNodeRef),\n    tags: optionalStringArray(raw.tags, \"tags\"),\n    metadata: validateStringRecord(raw.metadata, \"metadata\"),\n  };\n}\n\nexport async function recordCueAnchor(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  anchor: CueAnchor;\n}): Promise<string> {\n  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length\n    ? options.abstractionNodeStoreDir.trim()\n    : path.join(options.memoryDir, \"state\", \"abstraction-nodes\");\n  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n  const validated = validateCueAnchor(options.anchor);\n  const boundedNodeRefs = boundNodeRefs(validated.nodeRefs);\n  const bounded = validateCueAnchor({\n    ...validated,\n    nodeRefs: boundedNodeRefs,\n    sourceMemoryIdsByNodeRef: boundSourceMemoryIdsByNodeRef(validated.sourceMemoryIdsByNodeRef, boundedNodeRefs),\n  });\n  const anchorDir = path.join(rootDir, bounded.anchorType);\n  const filePath = path.join(anchorDir, `${bounded.anchorId}.json`);\n  await mkdir(anchorDir, { recursive: true });\n  await writeFile(filePath, JSON.stringify(bounded, null, 2), \"utf8\");\n  return filePath;\n}\n\nfunction mergeSortedValues(existing: string[] | undefined, incoming: string[] | undefined): string[] {\n  return mergeSortedUniqueStrings(existing, incoming);\n}\n\nfunction isNotFoundError(error: unknown): boolean {\n  return (\n    typeof error === \"object\" && error !== null && \"code\" in error && (error as { code?: unknown }).code === \"ENOENT\"\n  );\n}\n\nfunction boundNodeRefs(nodeRefs: string[], liveNodes?: Map<string, AbstractionNode>): string[] {\n  const uniqueRefs = mergeSortedUniqueStrings(nodeRefs);\n  if (!liveNodes) return uniqueRefs.slice(0, 50);\n  return uniqueRefs\n    .filter((nodeRef) => liveNodes.has(nodeRef))\n    .sort(\n      (left, right) =>\n        Date.parse(liveNodes.get(right)?.recordedAt ?? \"\") - Date.parse(liveNodes.get(left)?.recordedAt ?? \"\") ||\n        compareDeterministicStrings(left, right)\n    )\n    .slice(0, 50);\n}\n\nasync function readLiveNodes(nodesDir: string): Promise<Map<string, AbstractionNode> | undefined> {\n  const liveNodes = new Map<string, AbstractionNode>();\n  let nodeFiles: string[];\n  try {\n    nodeFiles = await listJsonFilesStrict(nodesDir);\n  } catch (error) {\n    if (isNotFoundError(error)) return undefined;\n    throw error;\n  }\n  for (const filePath of nodeFiles) {\n    const node = validateAbstractionNode(await readJsonFile(filePath));\n    const previous = liveNodes.get(node.nodeId);\n    if (\n      !previous ||\n      Date.parse(previous.recordedAt) < Date.parse(node.recordedAt) ||\n      (Date.parse(previous.recordedAt) === Date.parse(node.recordedAt) &&\n        compareDeterministicStrings(previous.sessionKey, node.sessionKey) < 0)\n    ) {\n      liveNodes.set(node.nodeId, node);\n    }\n  }\n  return liveNodes;\n}\n\nexport async function upsertCueAnchors(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  anchors: CueAnchor[];\n}): Promise<string[]> {\n  const abstractionNodeStoreDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);\n  const incomingAnchors = options.anchors.map(validateCueAnchor);\n  if (incomingAnchors.length === 0) return [];\n\n  return withJsonStoreMutationLock(abstractionNodeStoreDir, async () => {\n    const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n    const liveNodes = await readLiveNodes(path.join(abstractionNodeStoreDir, \"nodes\"));\n    const incomingByKey = new Map<string, CueAnchor[]>();\n    for (const anchor of incomingAnchors) {\n      const key = `${anchor.anchorType}\\u0000${anchor.anchorId}`;\n      const grouped = incomingByKey.get(key) ?? [];\n      grouped.push(anchor);\n      incomingByKey.set(key, grouped);\n    }\n    const filePaths: string[] = [];\n    for (const key of [...incomingByKey.keys()].sort(compareDeterministicStrings)) {\n      const grouped = incomingByKey.get(key) ?? [];\n      grouped.sort(compareIncomingCueAnchors);\n      const incoming = grouped.shift();\n      if (!incoming) throw new Error(`cue anchor batch has no anchor: ${key}`);\n      const filePath = path.join(rootDir, incoming.anchorType, `${incoming.anchorId}.json`);\n      let existing: CueAnchor | undefined;\n      try {\n        existing = validateCueAnchor(await readJsonFile(filePath));\n      } catch (error) {\n        if (!isNotFoundError(error)) throw error;\n      }\n      let merged = mergeCueAnchors(existing, incoming, liveNodes);\n      for (const next of grouped) merged = mergeCueAnchors(merged, next, liveNodes);\n      await writeJsonFileAtomic(filePath, merged);\n      filePaths.push(filePath);\n    }\n    return filePaths;\n  });\n}\n\nfunction compareIncomingCueAnchors(left: CueAnchor, right: CueAnchor): number {\n  const recordedAtComparison = Date.parse(left.recordedAt) - Date.parse(right.recordedAt);\n  if (recordedAtComparison < 0) return -1;\n  if (recordedAtComparison > 0) return 1;\n  return compareDeterministicStrings(canonicalCueAnchorKey(left), canonicalCueAnchorKey(right));\n}\n\nfunction canonicalMetadata(metadata: Record<string, string> | undefined): Record<string, string> {\n  return Object.fromEntries(\n    Object.entries(metadata ?? {}).sort(([left], [right]) => compareDeterministicStrings(left, right))\n  );\n}\n\nfunction canonicalCueAnchorKey(anchor: CueAnchor): string {\n  return JSON.stringify({\n    ...anchor,\n    metadata: canonicalMetadata(anchor.metadata),\n  });\n}\n\nfunction mergeCueAnchors(\n  existing: CueAnchor | undefined,\n  incoming: CueAnchor,\n  liveNodes: Map<string, AbstractionNode> | undefined\n): CueAnchor {\n  const incomingIsNewest = !existing || Date.parse(existing.recordedAt) <= Date.parse(incoming.recordedAt);\n  const newest = incomingIsNewest ? incoming : existing;\n  const older = incomingIsNewest ? existing : incoming;\n  const mergedMetadata = canonicalMetadata({\n    ...(older?.metadata ?? {}),\n    ...(newest.metadata ?? {}),\n  });\n  const nodeRefs = boundNodeRefs(mergeSortedValues(existing?.nodeRefs, incoming.nodeRefs), liveNodes);\n  return validateCueAnchor({\n    ...newest,\n    nodeRefs,\n    sourceMemoryIdsByNodeRef: boundSourceMemoryIdsByNodeRef(\n      mergeSourceMemoryIdsByNodeRef(existing?.sourceMemoryIdsByNodeRef, incoming.sourceMemoryIdsByNodeRef),\n      nodeRefs,\n      liveNodes\n    ),\n    tags: mergeSortedValues(existing?.tags, incoming.tags),\n    metadata: mergedMetadata,\n  });\n}\n\nexport async function upsertCueAnchor(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  anchor: CueAnchor;\n}): Promise<string> {\n  const [filePath] = await upsertCueAnchors({ ...options, anchors: [options.anchor] });\n  if (!filePath) throw new Error(\"cue anchor upsert did not write a file\");\n  return filePath;\n}\n\nexport async function pruneOrphanCueAnchors(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n}): Promise<number> {\n  const abstractionNodeStoreDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);\n  return withJsonStoreMutationLock(abstractionNodeStoreDir, async () => {\n    const cueAnchorStoreDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n    const liveNodes = (await readLiveNodes(path.join(abstractionNodeStoreDir, \"nodes\"))) ?? new Map();\n    let removed = 0;\n    const anchorFiles = await listJsonFilesStrict(cueAnchorStoreDir, {\n      allowMissingDirectory: true,\n    });\n    for (const filePath of anchorFiles) {\n      let anchor: CueAnchor;\n      try {\n        anchor = validateCueAnchor(await readJsonFile(filePath));\n      } catch {\n        continue;\n      }\n      const nodeRefs = boundNodeRefs(anchor.nodeRefs, liveNodes);\n      const sourceMemoryIdsByNodeRef = boundSourceMemoryIdsByNodeRef(\n        anchor.sourceMemoryIdsByNodeRef,\n        nodeRefs,\n        liveNodes\n      );\n      if (nodeRefs.length === 0) {\n        try {\n          await unlink(filePath);\n          removed++;\n        } catch (error) {\n          if (!isNotFoundError(error)) throw error;\n        }\n        continue;\n      }\n      if (\n        nodeRefs.length !== anchor.nodeRefs.length ||\n        nodeRefs.some((nodeRef, index) => nodeRef !== anchor.nodeRefs[index]) ||\n        JSON.stringify(sourceMemoryIdsByNodeRef) !== JSON.stringify(anchor.sourceMemoryIdsByNodeRef)\n      ) {\n        await writeJsonFileAtomic(filePath, validateCueAnchor({ ...anchor, nodeRefs, sourceMemoryIdsByNodeRef }));\n      }\n    }\n    return removed;\n  });\n}\n\nexport async function getCueAnchorStoreStatus(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  enabled: boolean;\n  anchorsEnabled: boolean;\n}): Promise<CueAnchorStoreStatus> {\n  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length\n    ? options.abstractionNodeStoreDir.trim()\n    : path.join(options.memoryDir, \"state\", \"abstraction-nodes\");\n  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n  const files = await listJsonFilesStrict(rootDir, { allowMissingDirectory: true });\n  const anchors: CueAnchor[] = [];\n  const invalidAnchors: Array<{ path: string; error: string }> = [];\n\n  for (const filePath of files) {\n    try {\n      anchors.push(validateCueAnchor(await readJsonFile(filePath)));\n    } catch (error) {\n      invalidAnchors.push({\n        path: filePath,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  anchors.sort(\n    (a, b) => Date.parse(b.recordedAt) - Date.parse(a.recordedAt) || compareDeterministicStrings(a.anchorId, b.anchorId)\n  );\n\n  const byType: Partial<Record<CueAnchorType, number>> = {};\n  let totalNodeRefs = 0;\n  for (const anchor of anchors) {\n    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;\n    totalNodeRefs += anchor.nodeRefs.length;\n  }\n\n  return {\n    enabled: options.enabled,\n    anchorsEnabled: options.anchorsEnabled,\n    rootDir,\n    anchors: {\n      total: files.length,\n      valid: anchors.length,\n      invalid: invalidAnchors.length,\n      byType,\n      totalNodeRefs,\n      latestAnchorId: anchors[0]?.anchorId,\n      latestRecordedAt: anchors[0]?.recordedAt,\n      latestSessionKey: anchors[0]?.sessionKey,\n    },\n    latestAnchor: anchors[0],\n    invalidAnchors,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-AMTEYNYK.js

@@ -0,0 +1,72 @@
+import {
+  EXTRACTION_RESPONSE_PLACEHOLDERS
+} from "./chunk-EEAMSNSG.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
+
+// src/extraction-normalization.ts
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsExtractionPlaceholder(value) {
+  if (typeof value === "string") return EXTRACTION_RESPONSE_PLACEHOLDERS[value.trim()] === true;
+  if (Array.isArray(value)) return value.some(containsExtractionPlaceholder);
+  return isPlainRecord(value) && Object.values(value).some(containsExtractionPlaceholder);
+}
+function extractionText(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text.length > 0 && !containsExtractionPlaceholder(text) ? text : void 0;
+}
+function extractionAttributes(value) {
+  if (!isPlainRecord(value)) return void 0;
+  const attributes = {};
+  for (const [key, candidate] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
+    const normalizedKey = extractionText(key);
+    const normalizedValue = extractionText(candidate);
+    if (normalizedKey !== void 0 && normalizedValue !== void 0) {
+      attributes[normalizedKey] = normalizedValue;
+    }
+  }
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+}
+var EXTRACTION_CUE_ANCHOR_TYPES = /* @__PURE__ */ new Set(["entity", "file", "tool", "outcome", "constraint", "date"]);
+function extractionCueAnchors(value) {
+  if (!Array.isArray(value)) return void 0;
+  const anchorsByIdentity = /* @__PURE__ */ new Map();
+  for (const candidate of value) {
+    if (!isPlainRecord(candidate)) continue;
+    const type = extractionText(candidate.type);
+    const anchorValue = extractionText(candidate.value);
+    const sanitizedAnchor = anchorValue === void 0 ? void 0 : sanitizeMemoryContent(anchorValue);
+    const sanitizedAnchorValue = sanitizedAnchor?.clean === true ? sanitizedAnchor.text.trim() : void 0;
+    if (type === void 0 || sanitizedAnchorValue === void 0 || sanitizedAnchorValue.length === 0 || sanitizedAnchorValue.length > 120 || !EXTRACTION_CUE_ANCHOR_TYPES.has(type)) {
+      continue;
+    }
+    const normalizedCue = normalizeRecallTokens(sanitizedAnchorValue).join(" ");
+    if (normalizedCue.length === 0) continue;
+    const identity = `${type}:${normalizedCue}`;
+    const existing = anchorsByIdentity.get(identity);
+    if (!existing || sanitizedAnchorValue.localeCompare(existing.value) < 0) {
+      anchorsByIdentity.set(identity, {
+        type,
+        value: sanitizedAnchorValue
+      });
+    }
+  }
+  const anchors = [...anchorsByIdentity.entries()].sort(([left], [right]) => left.localeCompare(right)).slice(0, 3).map(([, anchor]) => anchor);
+  return anchors.length > 0 ? anchors : void 0;
+}
+
+export {
+  isPlainRecord,
+  containsExtractionPlaceholder,
+  extractionText,
+  extractionAttributes,
+  extractionCueAnchors
+};
+//# sourceMappingURL=chunk-AMTEYNYK.js.map

package/dist/chunk-AMTEYNYK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-normalization.ts"],"sourcesContent":["import { EXTRACTION_RESPONSE_PLACEHOLDERS } from \"./extraction-prompt.js\";\nimport { normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport { sanitizeMemoryContent } from \"./sanitize.js\";\nimport type { ExtractedFact } from \"./types.js\";\n\nexport function isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nexport function containsExtractionPlaceholder(value: unknown): boolean {\n  if (typeof value === \"string\") return EXTRACTION_RESPONSE_PLACEHOLDERS[value.trim()] === true;\n  if (Array.isArray(value)) return value.some(containsExtractionPlaceholder);\n  return isPlainRecord(value) && Object.values(value).some(containsExtractionPlaceholder);\n}\n\nexport function extractionText(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const text = value.trim();\n  return text.length > 0 && !containsExtractionPlaceholder(text) ? text : undefined;\n}\n\nexport function extractionAttributes(value: unknown): Record<string, string> | undefined {\n  if (!isPlainRecord(value)) return undefined;\n  const attributes: Record<string, string> = {};\n  for (const [key, candidate] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {\n    const normalizedKey = extractionText(key);\n    const normalizedValue = extractionText(candidate);\n    if (normalizedKey !== undefined && normalizedValue !== undefined) {\n      attributes[normalizedKey] = normalizedValue;\n    }\n  }\n  return Object.keys(attributes).length > 0 ? attributes : undefined;\n}\n\nconst EXTRACTION_CUE_ANCHOR_TYPES = new Set([\"entity\", \"file\", \"tool\", \"outcome\", \"constraint\", \"date\"]);\n\nexport function extractionCueAnchors(value: unknown): NonNullable<ExtractedFact[\"cueAnchors\"]> | undefined {\n  if (!Array.isArray(value)) return undefined;\n  const anchorsByIdentity = new Map<string, NonNullable<ExtractedFact[\"cueAnchors\"]>[number]>();\n  for (const candidate of value) {\n    if (!isPlainRecord(candidate)) continue;\n    const type = extractionText(candidate.type);\n    const anchorValue = extractionText(candidate.value);\n    const sanitizedAnchor = anchorValue === undefined ? undefined : sanitizeMemoryContent(anchorValue);\n    const sanitizedAnchorValue = sanitizedAnchor?.clean === true ? sanitizedAnchor.text.trim() : undefined;\n    if (\n      type === undefined ||\n      sanitizedAnchorValue === undefined ||\n      sanitizedAnchorValue.length === 0 ||\n      sanitizedAnchorValue.length > 120 ||\n      !EXTRACTION_CUE_ANCHOR_TYPES.has(type)\n    ) {\n      continue;\n    }\n    const normalizedCue = normalizeRecallTokens(sanitizedAnchorValue).join(\" \");\n    if (normalizedCue.length === 0) continue;\n    const identity = `${type}:${normalizedCue}`;\n    const existing = anchorsByIdentity.get(identity);\n    if (!existing || sanitizedAnchorValue.localeCompare(existing.value) < 0) {\n      anchorsByIdentity.set(identity, {\n        type: type as NonNullable<ExtractedFact[\"cueAnchors\"]>[number][\"type\"],\n        value: sanitizedAnchorValue,\n      });\n    }\n  }\n  const anchors = [...anchorsByIdentity.entries()]\n    .sort(([left], [right]) => left.localeCompare(right))\n    .slice(0, 3)\n    .map(([, anchor]) => anchor);\n  return anchors.length > 0 ? anchors : undefined;\n}\n"],"mappings":";;;;;;;;;;;AAKO,SAAS,cAAc,OAAkD;AAC9E,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEO,SAAS,8BAA8B,OAAyB;AACrE,MAAI,OAAO,UAAU,SAAU,QAAO,iCAAiC,MAAM,KAAK,CAAC,MAAM;AACzF,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,KAAK,6BAA6B;AACzE,SAAO,cAAc,KAAK,KAAK,OAAO,OAAO,KAAK,EAAE,KAAK,6BAA6B;AACxF;AAEO,SAAS,eAAe,OAAoC;AACjE,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,OAAO,MAAM,KAAK;AACxB,SAAO,KAAK,SAAS,KAAK,CAAC,8BAA8B,IAAI,IAAI,OAAO;AAC1E;AAEO,SAAS,qBAAqB,OAAoD;AACvF,MAAI,CAAC,cAAc,KAAK,EAAG,QAAO;AAClC,QAAM,aAAqC,CAAC;AAC5C,aAAW,CAAC,KAAK,SAAS,KAAK,OAAO,QAAQ,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,cAAc,KAAK,CAAC,GAAG;AACzG,UAAM,gBAAgB,eAAe,GAAG;AACxC,UAAM,kBAAkB,eAAe,SAAS;AAChD,QAAI,kBAAkB,UAAa,oBAAoB,QAAW;AAChE,iBAAW,aAAa,IAAI;AAAA,IAC9B;AAAA,EACF;AACA,SAAO,OAAO,KAAK,UAAU,EAAE,SAAS,IAAI,aAAa;AAC3D;AAEA,IAAM,8BAA8B,oBAAI,IAAI,CAAC,UAAU,QAAQ,QAAQ,WAAW,cAAc,MAAM,CAAC;AAEhG,SAAS,qBAAqB,OAAsE;AACzG,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,QAAO;AAClC,QAAM,oBAAoB,oBAAI,IAA8D;AAC5F,aAAW,aAAa,OAAO;AAC7B,QAAI,CAAC,cAAc,SAAS,EAAG;AAC/B,UAAM,OAAO,eAAe,UAAU,IAAI;AAC1C,UAAM,cAAc,eAAe,UAAU,KAAK;AAClD,UAAM,kBAAkB,gBAAgB,SAAY,SAAY,sBAAsB,WAAW;AACjG,UAAM,uBAAuB,iBAAiB,UAAU,OAAO,gBAAgB,KAAK,KAAK,IAAI;AAC7F,QACE,SAAS,UACT,yBAAyB,UACzB,qBAAqB,WAAW,KAChC,qBAAqB,SAAS,OAC9B,CAAC,4BAA4B,IAAI,IAAI,GACrC;AACA;AAAA,IACF;AACA,UAAM,gBAAgB,sBAAsB,oBAAoB,EAAE,KAAK,GAAG;AAC1E,QAAI,cAAc,WAAW,EAAG;AAChC,UAAM,WAAW,GAAG,IAAI,IAAI,aAAa;AACzC,UAAM,WAAW,kBAAkB,IAAI,QAAQ;AAC/C,QAAI,CAAC,YAAY,qBAAqB,cAAc,SAAS,KAAK,IAAI,GAAG;AACvE,wBAAkB,IAAI,UAAU;AAAA,QAC9B;AAAA,QACA,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF;AACA,QAAM,UAAU,CAAC,GAAG,kBAAkB,QAAQ,CAAC,EAC5C,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,cAAc,KAAK,CAAC,EACnD,MAAM,GAAG,CAAC,EACV,IAAI,CAAC,CAAC,EAAE,MAAM,MAAM,MAAM;AAC7B,SAAO,QAAQ,SAAS,IAAI,UAAU;AACxC;","names":[]}

package/dist/{chunk-R6YJI3HE.js → chunk-AW4QUFQF.js}

@@ -75,4 +75,4 @@ export {
   writeFileAtomically,
   commitPreparedFileAtomically
 };
-//# sourceMappingURL=chunk-R6YJI3HE.js.map
+//# sourceMappingURL=chunk-AW4QUFQF.js.map

package/dist/{chunk-P65YJEEL.js → chunk-AXFWMRKI.js}

@@ -1,6 +1,6 @@
 import {
   writeFileAtomically
-} from "./chunk-R6YJI3HE.js";
+} from "./chunk-AW4QUFQF.js";
 
 // src/maintenance/observation-ledger-utils.ts
 import path from "path";
@@ -50,4 +50,4 @@ export {
   toHourBucketIso,
   backupAndWriteRebuiltObservations
 };
-//# sourceMappingURL=chunk-P65YJEEL.js.map
+//# sourceMappingURL=chunk-AXFWMRKI.js.map

package/dist/{chunk-WG5HSQ4P.js → chunk-BAKXNQ3C.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-35NN3ZFA.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-CGASUJVP.js";
+} from "./chunk-5V6IXHPI.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -399,4 +399,4 @@ export {
   isValidResolutionVerb,
   executeResolution
 };
-//# sourceMappingURL=chunk-WG5HSQ4P.js.map
+//# sourceMappingURL=chunk-BAKXNQ3C.js.map

package/dist/{chunk-NM2WP3B7.js → chunk-BJYET5TX.js}

@@ -1,6 +1,6 @@
 import {
   writeFileAtomically
-} from "./chunk-R6YJI3HE.js";
+} from "./chunk-AW4QUFQF.js";
 import {
   ensureContainedSpillDir,
   listContainedSpillFiles
@@ -633,4 +633,4 @@ export {
   TierMigrationStatusStore,
   RecallHandleHistoryStore
 };
-//# sourceMappingURL=chunk-NM2WP3B7.js.map
+//# sourceMappingURL=chunk-BJYET5TX.js.map

package/dist/{chunk-HLKPRWF4.js → chunk-DATDLJAO.js}

@@ -1,21 +1,21 @@
 import {
   resolveWorkProductLedgerDir,
   validateWorkProductLedgerEntry
-} from "./chunk-ZRWB5D4H.js";
+} from "./chunk-WT6UL3UA.js";
 import {
   TranscriptManager
 } from "./chunk-HYQJQGD3.js";
 import {
   resolveCommitmentLedgerDir,
   validateCommitmentLedgerEntry
-} from "./chunk-LMDRGRJ2.js";
+} from "./chunk-NOB2T2FC.js";
 import {
   parseConfig
-} from "./chunk-RN53QBM4.js";
+} from "./chunk-A4QMKFFO.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
-} from "./chunk-6HMYUWXR.js";
+} from "./chunk-HTP6XRUI.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -28,7 +28,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-LPSF4OQH.js";
+} from "./chunk-P77QX3ID.js";
 
 // src/resume-bundles.ts
 import path from "path";
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-HLKPRWF4.js.map
+//# sourceMappingURL=chunk-DATDLJAO.js.map