@remnic/core 9.49.0 → 9.49.1

package/dist/chunk-DJUKBGAD.js

@@ -0,0 +1,260 @@
+import {
+  compareDeterministicStrings,
+  mergeSortedUniqueStrings
+} from "./chunk-G73MCJKL.js";
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalStringArray,
+  recordStoreDay,
+  validateStringRecord
+} from "./chunk-A2IYSXDQ.js";
+import {
+  listJsonFilesStrict,
+  readJsonFile,
+  withJsonStoreMutationLock,
+  writeJsonFileAtomic
+} from "./chunk-P77QX3ID.js";
+
+// src/abstraction-nodes.ts
+import { mkdir, unlink, writeFile } from "fs/promises";
+import path from "path";
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function validateKind(raw) {
+  const value = assertString(raw, "kind");
+  if (!["episode", "topic", "project", "workflow", "constraint"].includes(value)) {
+    throw new Error("kind must be one of episode|topic|project|workflow|constraint");
+  }
+  return value;
+}
+function validateLevel(raw) {
+  const value = assertString(raw, "abstractionLevel");
+  if (!["micro", "meso", "macro"].includes(value)) {
+    throw new Error("abstractionLevel must be one of micro|meso|macro");
+  }
+  return value;
+}
+function resolveAbstractionNodeStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(memoryDir, "state", "abstraction-nodes");
+}
+function validateAbstractionNode(raw) {
+  if (!isRecord(raw)) throw new Error("abstraction node must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    nodeId: assertSafePathSegment(assertString(raw.nodeId, "nodeId"), "nodeId"),
+    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString(raw.sessionKey, "sessionKey"),
+    kind: validateKind(raw.kind),
+    abstractionLevel: validateLevel(raw.abstractionLevel),
+    title: assertString(raw.title, "title"),
+    summary: assertString(raw.summary, "summary"),
+    sourceMemoryIds: optionalStringArray(raw.sourceMemoryIds, "sourceMemoryIds"),
+    entityRefs: optionalStringArray(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function recordAbstractionNode(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const validated = validateAbstractionNode(options.node);
+  const day = recordStoreDay(validated.recordedAt);
+  const nodesDir = path.join(rootDir, "nodes", day);
+  const filePath = path.join(nodesDir, `${validated.nodeId}.json`);
+  await mkdir(nodesDir, { recursive: true });
+  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  return filePath;
+}
+var MAX_ABSTRACTION_NODE_VALUES = 50;
+function mergeSortedValues(existing, incoming) {
+  return mergeSortedUniqueStrings(existing, incoming).slice(0, MAX_ABSTRACTION_NODE_VALUES);
+}
+var HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY = "remnic.harmonic.sourceMemoryInsertedAt.v1";
+function sourceMemoryInsertedAt(node) {
+  const insertedAtById = /* @__PURE__ */ new Map();
+  if (!node) return insertedAtById;
+  let stored = {};
+  try {
+    const parsed = JSON.parse(node.metadata?.[HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY] ?? "{}");
+    stored = isRecord(parsed) ? parsed : {};
+  } catch {
+    stored = {};
+  }
+  for (const memoryId of node.sourceMemoryIds ?? []) {
+    const insertedAt = stored[memoryId];
+    insertedAtById.set(
+      memoryId,
+      typeof insertedAt === "string" && Number.isFinite(Date.parse(insertedAt)) ? insertedAt : node.recordedAt
+    );
+  }
+  return insertedAtById;
+}
+function mergeRecentSourceMemoryIds(existing, incoming) {
+  const insertedAtById = sourceMemoryInsertedAt(existing);
+  const incomingSources = [...sourceMemoryInsertedAt(incoming).entries()].sort(
+    ([leftId, leftAt], [rightId, rightAt]) => Date.parse(leftAt) - Date.parse(rightAt) || compareDeterministicStrings(leftId, rightId)
+  );
+  let nextInsertedAtMs = Math.max(
+    Date.now(),
+    [...insertedAtById.values()].reduce((latest, insertedAt) => Math.max(latest, Date.parse(insertedAt) + 1), 0)
+  );
+  for (const [memoryId] of incomingSources) {
+    if (insertedAtById.has(memoryId)) continue;
+    insertedAtById.set(memoryId, new Date(nextInsertedAtMs).toISOString());
+    nextInsertedAtMs++;
+  }
+  const retained = [...insertedAtById.entries()].sort(
+    ([leftId, leftAt], [rightId, rightAt]) => Date.parse(rightAt) - Date.parse(leftAt) || compareDeterministicStrings(leftId, rightId)
+  ).slice(0, MAX_ABSTRACTION_NODE_VALUES);
+  const ids = retained.map(([memoryId]) => memoryId).sort(compareDeterministicStrings);
+  const retainedInsertedAt = Object.fromEntries(ids.map((memoryId) => [memoryId, insertedAtById.get(memoryId)]));
+  return { ids, insertedAtJson: JSON.stringify(retainedInsertedAt) };
+}
+function compareNodeFiles(left, right) {
+  return Date.parse(right.node.recordedAt) - Date.parse(left.node.recordedAt) || compareDeterministicStrings(left.filePath, right.filePath);
+}
+function compareIncomingNodes(left, right) {
+  return Date.parse(left.recordedAt) - Date.parse(right.recordedAt) || compareDeterministicStrings(canonicalNodeKey(left), canonicalNodeKey(right));
+}
+function canonicalMetadata(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata ?? {}).sort(([left], [right]) => compareDeterministicStrings(left, right))
+  );
+}
+function canonicalNodeKey(node) {
+  return JSON.stringify({
+    ...node,
+    metadata: canonicalMetadata(node.metadata)
+  });
+}
+function mergeAbstractionNodes(existing, incoming) {
+  const incomingIsNewest = !existing || Date.parse(existing.recordedAt) <= Date.parse(incoming.recordedAt);
+  const newest = incomingIsNewest ? incoming : existing;
+  const older = incomingIsNewest ? existing : incoming;
+  if (!newest) throw new Error("abstraction node merge requires a node");
+  const retainedSources = mergeRecentSourceMemoryIds(existing, incoming);
+  const mergedMetadata = canonicalMetadata({
+    ...older?.metadata ?? {},
+    ...newest.metadata ?? {},
+    [HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY]: retainedSources.insertedAtJson
+  });
+  return validateAbstractionNode({
+    ...newest,
+    sourceMemoryIds: retainedSources.ids,
+    entityRefs: mergeSortedValues(existing?.entityRefs, incoming.entityRefs),
+    tags: mergeSortedValues(existing?.tags, incoming.tags),
+    metadata: mergedMetadata
+  });
+}
+async function upsertAbstractionNodes(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const incomingNodes = options.nodes.map(validateAbstractionNode);
+  if (incomingNodes.length === 0) return [];
+  return withJsonStoreMutationLock(rootDir, async () => {
+    const nodesDir = path.join(rootDir, "nodes");
+    const nodeFiles = await listJsonFilesStrict(nodesDir, { allowMissingDirectory: true });
+    const existingNodes = await Promise.all(
+      nodeFiles.map(async (filePath) => ({
+        filePath,
+        node: validateAbstractionNode(await readJsonFile(filePath))
+      }))
+    );
+    const existingById = /* @__PURE__ */ new Map();
+    for (const existing of existingNodes) {
+      const records = existingById.get(existing.node.nodeId) ?? [];
+      records.push(existing);
+      existingById.set(existing.node.nodeId, records);
+    }
+    const incomingById = /* @__PURE__ */ new Map();
+    for (const incoming of incomingNodes) {
+      const records = incomingById.get(incoming.nodeId) ?? [];
+      records.push(incoming);
+      incomingById.set(incoming.nodeId, records);
+    }
+    const filePaths = [];
+    for (const nodeId of [...incomingById.keys()].sort(compareDeterministicStrings)) {
+      const existing = (existingById.get(nodeId) ?? []).sort(compareNodeFiles);
+      const incoming = (incomingById.get(nodeId) ?? []).sort(compareIncomingNodes);
+      let merged;
+      for (const next of [...existing].reverse()) merged = mergeAbstractionNodes(merged, next.node);
+      for (const next of incoming) merged = mergeAbstractionNodes(merged, next);
+      if (!merged) throw new Error(`abstraction node batch has no node: ${nodeId}`);
+      const filePath = existing[0]?.filePath ?? path.join(nodesDir, recordStoreDay(merged.recordedAt), `${merged.nodeId}.json`);
+      await writeJsonFileAtomic(filePath, merged);
+      for (const duplicate of existing.slice(1)) {
+        await unlink(duplicate.filePath).catch((error) => {
+          if (!isNotFoundError(error)) throw error;
+        });
+      }
+      filePaths.push(filePath);
+    }
+    return filePaths;
+  });
+}
+async function upsertAbstractionNode(options) {
+  const [filePath] = await upsertAbstractionNodes({ ...options, nodes: [options.node] });
+  if (!filePath) throw new Error("abstraction node upsert did not write a file");
+  return filePath;
+}
+async function getAbstractionNodeStoreStatus(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const nodesDir = path.join(rootDir, "nodes");
+  const files = await listJsonFilesStrict(nodesDir, { allowMissingDirectory: true });
+  const nodes = [];
+  const invalidNodes = [];
+  for (const filePath of files) {
+    try {
+      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidNodes.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  nodes.sort(
+    (a, b) => Date.parse(b.recordedAt) - Date.parse(a.recordedAt) || compareDeterministicStrings(a.nodeId, b.nodeId)
+  );
+  const byKind = {};
+  const byLevel = {};
+  for (const node of nodes) {
+    byKind[node.kind] = (byKind[node.kind] ?? 0) + 1;
+    byLevel[node.abstractionLevel] = (byLevel[node.abstractionLevel] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    anchorsEnabled: options.anchorsEnabled,
+    rootDir,
+    nodesDir,
+    nodes: {
+      total: files.length,
+      valid: nodes.length,
+      invalid: invalidNodes.length,
+      byKind,
+      byLevel,
+      latestNodeId: nodes[0]?.nodeId,
+      latestRecordedAt: nodes[0]?.recordedAt,
+      latestSessionKey: nodes[0]?.sessionKey
+    },
+    latestNode: nodes[0],
+    invalidNodes
+  };
+}
+
+export {
+  resolveAbstractionNodeStoreDir,
+  validateAbstractionNode,
+  recordAbstractionNode,
+  HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY,
+  upsertAbstractionNodes,
+  upsertAbstractionNode,
+  getAbstractionNodeStoreStatus
+};
+//# sourceMappingURL=chunk-DJUKBGAD.js.map

package/dist/chunk-DJUKBGAD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/abstraction-nodes.ts"],"sourcesContent":["import { mkdir, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\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  recordStoreDay,\n  validateStringRecord,\n} from \"./store-contract.js\";\n\nfunction isNotFoundError(error: unknown): boolean {\n  return typeof error === \"object\" && error !== null && \"code\" in error && error.code === \"ENOENT\";\n}\n\nexport type AbstractionNodeKind = \"episode\" | \"topic\" | \"project\" | \"workflow\" | \"constraint\";\nexport type AbstractionLevel = \"micro\" | \"meso\" | \"macro\";\n\nexport interface AbstractionNode {\n  schemaVersion: 1;\n  nodeId: string;\n  recordedAt: string;\n  sessionKey: string;\n  kind: AbstractionNodeKind;\n  abstractionLevel: AbstractionLevel;\n  title: string;\n  summary: string;\n  sourceMemoryIds?: string[];\n  entityRefs?: string[];\n  tags?: string[];\n  metadata?: Record<string, string>;\n}\n\nexport interface AbstractionNodeStoreStatus {\n  enabled: boolean;\n  anchorsEnabled: boolean;\n  rootDir: string;\n  nodesDir: string;\n  nodes: {\n    total: number;\n    valid: number;\n    invalid: number;\n    byKind: Partial<Record<AbstractionNodeKind, number>>;\n    byLevel: Partial<Record<AbstractionLevel, number>>;\n    latestNodeId?: string;\n    latestRecordedAt?: string;\n    latestSessionKey?: string;\n  };\n  latestNode?: AbstractionNode;\n  invalidNodes: Array<{\n    path: string;\n    error: string;\n  }>;\n}\n\nfunction validateKind(raw: unknown): AbstractionNodeKind {\n  const value = assertString(raw, \"kind\");\n  if (![\"episode\", \"topic\", \"project\", \"workflow\", \"constraint\"].includes(value)) {\n    throw new Error(\"kind must be one of episode|topic|project|workflow|constraint\");\n  }\n  return value as AbstractionNodeKind;\n}\n\nfunction validateLevel(raw: unknown): AbstractionLevel {\n  const value = assertString(raw, \"abstractionLevel\");\n  if (![\"micro\", \"meso\", \"macro\"].includes(value)) {\n    throw new Error(\"abstractionLevel must be one of micro|meso|macro\");\n  }\n  return value as AbstractionLevel;\n}\n\nexport function resolveAbstractionNodeStoreDir(memoryDir: string, overrideDir?: string): string {\n  if (typeof overrideDir === \"string\" && overrideDir.trim().length > 0) {\n    return overrideDir.trim();\n  }\n  return path.join(memoryDir, \"state\", \"abstraction-nodes\");\n}\n\nexport function validateAbstractionNode(raw: unknown): AbstractionNode {\n  if (!isRecord(raw)) throw new Error(\"abstraction node must be an object\");\n  if (raw.schemaVersion !== 1) throw new Error(\"schemaVersion must be 1\");\n\n  return {\n    schemaVersion: 1,\n    nodeId: assertSafePathSegment(assertString(raw.nodeId, \"nodeId\"), \"nodeId\"),\n    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, \"recordedAt\")),\n    sessionKey: assertString(raw.sessionKey, \"sessionKey\"),\n    kind: validateKind(raw.kind),\n    abstractionLevel: validateLevel(raw.abstractionLevel),\n    title: assertString(raw.title, \"title\"),\n    summary: assertString(raw.summary, \"summary\"),\n    sourceMemoryIds: optionalStringArray(raw.sourceMemoryIds, \"sourceMemoryIds\"),\n    entityRefs: optionalStringArray(raw.entityRefs, \"entityRefs\"),\n    tags: optionalStringArray(raw.tags, \"tags\"),\n    metadata: validateStringRecord(raw.metadata, \"metadata\"),\n  };\n}\n\nexport async function recordAbstractionNode(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  node: AbstractionNode;\n}): Promise<string> {\n  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);\n  const validated = validateAbstractionNode(options.node);\n  const day = recordStoreDay(validated.recordedAt);\n  const nodesDir = path.join(rootDir, \"nodes\", day);\n  const filePath = path.join(nodesDir, `${validated.nodeId}.json`);\n  await mkdir(nodesDir, { recursive: true });\n  await writeFile(filePath, JSON.stringify(validated, null, 2), \"utf8\");\n  return filePath;\n}\n\nconst MAX_ABSTRACTION_NODE_VALUES = 50;\n\nfunction mergeSortedValues(existing: string[] | undefined, incoming: string[] | undefined): string[] {\n  return mergeSortedUniqueStrings(existing, incoming).slice(0, MAX_ABSTRACTION_NODE_VALUES);\n}\n\nexport const HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY = \"remnic.harmonic.sourceMemoryInsertedAt.v1\";\n\nfunction sourceMemoryInsertedAt(node: AbstractionNode | undefined): Map<string, string> {\n  const insertedAtById = new Map<string, string>();\n  if (!node) return insertedAtById;\n  let stored: Record<string, unknown> = {};\n  try {\n    const parsed = JSON.parse(node.metadata?.[HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY] ?? \"{}\") as unknown;\n    stored = isRecord(parsed) ? parsed : {};\n  } catch {\n    stored = {};\n  }\n  for (const memoryId of node.sourceMemoryIds ?? []) {\n    const insertedAt = stored[memoryId];\n    insertedAtById.set(\n      memoryId,\n      typeof insertedAt === \"string\" && Number.isFinite(Date.parse(insertedAt)) ? insertedAt : node.recordedAt\n    );\n  }\n  return insertedAtById;\n}\n\nfunction mergeRecentSourceMemoryIds(\n  existing: AbstractionNode | undefined,\n  incoming: AbstractionNode\n): { ids: string[]; insertedAtJson: string } {\n  const insertedAtById = sourceMemoryInsertedAt(existing);\n  const incomingSources = [...sourceMemoryInsertedAt(incoming).entries()].sort(\n    ([leftId, leftAt], [rightId, rightAt]) =>\n      Date.parse(leftAt) - Date.parse(rightAt) || compareDeterministicStrings(leftId, rightId)\n  );\n  let nextInsertedAtMs = Math.max(\n    Date.now(),\n    [...insertedAtById.values()].reduce((latest, insertedAt) => Math.max(latest, Date.parse(insertedAt) + 1), 0)\n  );\n  for (const [memoryId] of incomingSources) {\n    if (insertedAtById.has(memoryId)) continue;\n    insertedAtById.set(memoryId, new Date(nextInsertedAtMs).toISOString());\n    nextInsertedAtMs++;\n  }\n  const retained = [...insertedAtById.entries()]\n    .sort(\n      ([leftId, leftAt], [rightId, rightAt]) =>\n        Date.parse(rightAt) - Date.parse(leftAt) || compareDeterministicStrings(leftId, rightId)\n    )\n    .slice(0, MAX_ABSTRACTION_NODE_VALUES);\n  const ids = retained.map(([memoryId]) => memoryId).sort(compareDeterministicStrings);\n  const retainedInsertedAt = Object.fromEntries(ids.map((memoryId) => [memoryId, insertedAtById.get(memoryId)]));\n  return { ids, insertedAtJson: JSON.stringify(retainedInsertedAt) };\n}\n\ntype AbstractionNodeFile = {\n  filePath: string;\n  node: AbstractionNode;\n};\n\nfunction compareNodeFiles(left: AbstractionNodeFile, right: AbstractionNodeFile): number {\n  return (\n    Date.parse(right.node.recordedAt) - Date.parse(left.node.recordedAt) ||\n    compareDeterministicStrings(left.filePath, right.filePath)\n  );\n}\n\nfunction compareIncomingNodes(left: AbstractionNode, right: AbstractionNode): number {\n  return (\n    Date.parse(left.recordedAt) - Date.parse(right.recordedAt) ||\n    compareDeterministicStrings(canonicalNodeKey(left), canonicalNodeKey(right))\n  );\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 canonicalNodeKey(node: AbstractionNode): string {\n  return JSON.stringify({\n    ...node,\n    metadata: canonicalMetadata(node.metadata),\n  });\n}\n\nfunction mergeAbstractionNodes(existing: AbstractionNode | undefined, incoming: AbstractionNode): AbstractionNode {\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  if (!newest) throw new Error(\"abstraction node merge requires a node\");\n  const retainedSources = mergeRecentSourceMemoryIds(existing, incoming);\n  const mergedMetadata = canonicalMetadata({\n    ...(older?.metadata ?? {}),\n    ...(newest.metadata ?? {}),\n    [HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY]: retainedSources.insertedAtJson,\n  });\n  return validateAbstractionNode({\n    ...newest,\n    sourceMemoryIds: retainedSources.ids,\n    entityRefs: mergeSortedValues(existing?.entityRefs, incoming.entityRefs),\n    tags: mergeSortedValues(existing?.tags, incoming.tags),\n    metadata: mergedMetadata,\n  });\n}\n\nexport async function upsertAbstractionNodes(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  nodes: AbstractionNode[];\n}): Promise<string[]> {\n  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);\n  const incomingNodes = options.nodes.map(validateAbstractionNode);\n  if (incomingNodes.length === 0) return [];\n  return withJsonStoreMutationLock(rootDir, async () => {\n    const nodesDir = path.join(rootDir, \"nodes\");\n    const nodeFiles = await listJsonFilesStrict(nodesDir, { allowMissingDirectory: true });\n    const existingNodes = await Promise.all(\n      nodeFiles.map(async (filePath) => ({\n        filePath,\n        node: validateAbstractionNode(await readJsonFile(filePath)),\n      }))\n    );\n    const existingById = new Map<string, AbstractionNodeFile[]>();\n    for (const existing of existingNodes) {\n      const records = existingById.get(existing.node.nodeId) ?? [];\n      records.push(existing);\n      existingById.set(existing.node.nodeId, records);\n    }\n    const incomingById = new Map<string, AbstractionNode[]>();\n    for (const incoming of incomingNodes) {\n      const records = incomingById.get(incoming.nodeId) ?? [];\n      records.push(incoming);\n      incomingById.set(incoming.nodeId, records);\n    }\n\n    const filePaths: string[] = [];\n    for (const nodeId of [...incomingById.keys()].sort(compareDeterministicStrings)) {\n      const existing = (existingById.get(nodeId) ?? []).sort(compareNodeFiles);\n      const incoming = (incomingById.get(nodeId) ?? []).sort(compareIncomingNodes);\n      let merged: AbstractionNode | undefined;\n      for (const next of [...existing].reverse()) merged = mergeAbstractionNodes(merged, next.node);\n      for (const next of incoming) merged = mergeAbstractionNodes(merged, next);\n      if (!merged) throw new Error(`abstraction node batch has no node: ${nodeId}`);\n      const filePath =\n        existing[0]?.filePath ?? path.join(nodesDir, recordStoreDay(merged.recordedAt), `${merged.nodeId}.json`);\n      await writeJsonFileAtomic(filePath, merged);\n      for (const duplicate of existing.slice(1)) {\n        await unlink(duplicate.filePath).catch((error) => {\n          if (!isNotFoundError(error)) throw error;\n        });\n      }\n      filePaths.push(filePath);\n    }\n    return filePaths;\n  });\n}\n\nexport async function upsertAbstractionNode(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  node: AbstractionNode;\n}): Promise<string> {\n  const [filePath] = await upsertAbstractionNodes({ ...options, nodes: [options.node] });\n  if (!filePath) throw new Error(\"abstraction node upsert did not write a file\");\n  return filePath;\n}\n\nexport async function getAbstractionNodeStoreStatus(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  enabled: boolean;\n  anchorsEnabled: boolean;\n}): Promise<AbstractionNodeStoreStatus> {\n  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);\n  const nodesDir = path.join(rootDir, \"nodes\");\n  const files = await listJsonFilesStrict(nodesDir, { allowMissingDirectory: true });\n  const nodes: AbstractionNode[] = [];\n  const invalidNodes: Array<{ path: string; error: string }> = [];\n\n  for (const filePath of files) {\n    try {\n      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));\n    } catch (error) {\n      invalidNodes.push({\n        path: filePath,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  nodes.sort(\n    (a, b) => Date.parse(b.recordedAt) - Date.parse(a.recordedAt) || compareDeterministicStrings(a.nodeId, b.nodeId)\n  );\n\n  const byKind: Partial<Record<AbstractionNodeKind, number>> = {};\n  const byLevel: Partial<Record<AbstractionLevel, number>> = {};\n  for (const node of nodes) {\n    byKind[node.kind] = (byKind[node.kind] ?? 0) + 1;\n    byLevel[node.abstractionLevel] = (byLevel[node.abstractionLevel] ?? 0) + 1;\n  }\n\n  return {\n    enabled: options.enabled,\n    anchorsEnabled: options.anchorsEnabled,\n    rootDir,\n    nodesDir,\n    nodes: {\n      total: files.length,\n      valid: nodes.length,\n      invalid: invalidNodes.length,\n      byKind,\n      byLevel,\n      latestNodeId: nodes[0]?.nodeId,\n      latestRecordedAt: nodes[0]?.recordedAt,\n      latestSessionKey: nodes[0]?.sessionKey,\n    },\n    latestNode: nodes[0],\n    invalidNodes,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-DX3XRGLH.js → chunk-DQTCGVFK.js}

@@ -1,7 +1,7 @@
 import {
   backupAndWriteRebuiltObservations,
   toHourBucketIso
-} from "./chunk-P65YJEEL.js";
+} from "./chunk-AXFWMRKI.js";
 
 // src/maintenance/rebuild-observations.ts
 import path from "path";
@@ -124,4 +124,4 @@ async function rebuildObservations(options) {
 export {
   rebuildObservations
 };
-//# sourceMappingURL=chunk-DX3XRGLH.js.map
+//# sourceMappingURL=chunk-DQTCGVFK.js.map

package/dist/{chunk-IPBNC77A.js → chunk-E633OXMH.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-L6DCVUCA.js";
+} from "./chunk-O76MWTVS.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-I3YHVVT4.js";
+} from "./chunk-SHYIMIX5.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -24,10 +24,10 @@ import {
   runEvalBaselineDeltaReport,
   runEvalBenchmarkCiGate,
   validateEvalBenchmarkPack
-} from "./chunk-3PY7VHV7.js";
+} from "./chunk-MCA2X4WH.js";
 import {
   runConsolidationProvenanceCheck
-} from "./chunk-FMXJ555A.js";
+} from "./chunk-EURCX6PS.js";
 import {
   resolveCuratedIncludeFilesStatePath,
   resolveNativeKnowledgeStatePath,
@@ -38,23 +38,23 @@ import {
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-RN53QBM4.js";
+} from "./chunk-A4QMKFFO.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-MZZR3J6M.js";
+} from "./chunk-FV7YQTN3.js";
 import {
   listNamespaces
-} from "./chunk-5AGR7SAI.js";
+} from "./chunk-GSEPRIZC.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-SMPVHGHG.js";
+} from "./chunk-WPZX7MEA.js";
 import {
   analyzeGraphHealth
 } from "./chunk-L2DPF4DF.js";
 import {
   StorageManager
-} from "./chunk-EY64JLOM.js";
+} from "./chunk-24BKGKGO.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -1109,7 +1109,7 @@ async function summarizeGraphEdgeDecayStatus(config) {
 }
 async function summarizeTierDistribution(storage) {
   try {
-    const { summarizeTiers } = await import("./tier-stats-OPTSBNRH.js");
+    const { summarizeTiers } = await import("./tier-stats-2JCZYEF7.js");
     const summary = await summarizeTiers(storage);
     const storageDir = storage.dir ?? "";
     const journalPath = storageDir.length > 0 ? path.join(storageDir, "state", "tier-migration-journal.jsonl") : null;
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-IPBNC77A.js.map
+//# sourceMappingURL=chunk-E633OXMH.js.map

package/dist/{chunk-J7T4MX7P.js → chunk-EEAMSNSG.js}

@@ -15,6 +15,7 @@ var EXTRACTION_RESPONSE_SHAPE = `{
     "confidence": 0.0,
     "tags": ["<tag>"],
     "entityRef": "<optional normalized-name>",
+    "cueAnchors": [{"type": "<anchor-type>", "value": "<entity-or-topic plus key aspect>"}],
     "promptedByQuestion": "<optional source-grounded question>",
     "quote": "<optional exact contiguous source span>",
     "scope": "<optional project-or-global>",
@@ -37,12 +38,18 @@ var EXTRACTION_RESPONSE_SHAPE = `{
   "profileUpdates": ["<source-grounded profile update>"],
   "questions": [{"question": "<source-grounded unresolved question>", "context": "<source-grounded context>", "priority": 0.0}],
   "identityReflection": "<conversation-grounded agent reflection>",
+  "episodeTitle": "<six-to-eight word conversation segment title>",
   "relationships": [{"source": "<normalized-name>", "target": "<normalized-name>", "label": "<source-grounded relationship>"}]
 }`;
 var EXTRACTION_RESPONSE_PLACEHOLDERS = {};
 for (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\r\n]+>/g) ?? []) {
   EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;
 }
+var CUE_ANCHOR_PROMPT_INSTRUCTION = `- For each fact, emit at most 3 "cueAnchors".
+- Each cue anchor value must be a source-grounded search hook of at most 120 characters, in the form "<main entity or topic> <key aspect>".
+- Set each cue anchor type to entity, file, tool, outcome, constraint, or date.
+- Omit cue anchors when the conversation does not support a useful search hook.
+- Example: "Alice booked Bistro Max for Mike's surprise party" can use {"type":"entity","value":"Mike surprise party"} and {"type":"entity","value":"Alice restaurant booking"}.`;
 function eventTimePromptInstruction(config) {
   if (!config.temporalBiTemporal) return "";
   return `
@@ -79,6 +86,7 @@ Rules:
 - Entity references should use normalized names (lowercase, hyphenated: "jane-doe", "acme-corp")
 - CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: "acme-corp" NOT "acmecorp" or "acme". "jane-doe" NOT "janedoe" or "jane". If unsure, prefer the most specific full name.
 - Avoid creating entities typed as "other" when a more specific type fits (company, project, tool, person, place)
+${CUE_ANCHOR_PROMPT_INSTRUCTION}
 - When entity facts clearly belong under a durable named heading, add them to entity.structuredSections as {key, title, facts}. Example person headings: "Beliefs", "Communication Style", "Building / Working On". Leave structuredSections empty when no stable heading fits.
 - Tags should be concise and reusable (e.g., "coding-style", "personal", "tools")
 - When a fact contains measurable, categorical, or precisely valued data, include a "structuredAttributes" field with key-value string pairs (e.g., {"price": "29.99", "brand": "Sony"}, {"date": "2024-03-15", "location": "SF"}, {"chosen": "PostgreSQL", "rejected": "MongoDB"}). Only for concrete values, not narrative content.
@@ -117,6 +125,8 @@ Also extract relationships between entities mentioned in the conversation.
 - Only include clear, durable relationships (e.g., "works at", "created", "manages", "uses")
 - Use normalized entity names (e.g., "person-jane-doe", "company-acme-corp")
 
+
+Also emit "episodeTitle" as a six-to-eight word title for this conversation segment.
 Questions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.
 
 Finally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;
@@ -125,7 +135,8 @@ Finally, write a brief identity reflection about the agent who had this conversa
 export {
   EXTRACTION_RESPONSE_SHAPE,
   EXTRACTION_RESPONSE_PLACEHOLDERS,
+  CUE_ANCHOR_PROMPT_INSTRUCTION,
   eventTimePromptInstruction,
   buildExtractionInstructions
 };
-//# sourceMappingURL=chunk-J7T4MX7P.js.map
+//# sourceMappingURL=chunk-EEAMSNSG.js.map

package/dist/chunk-EEAMSNSG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-prompt.ts"],"sourcesContent":["/**\n * Extraction prompt construction (issue #1995 sibling extraction).\n *\n * The system prompt, its JSON response shape, and the placeholder table\n * derived from that shape are prompt DATA, not engine behavior. They live here\n * so `extraction.ts` holds the pipeline and one module owns the text every\n * extraction path — local LLM, direct client, gateway fallback — sends.\n */\n\nimport { AMBIENT_CAPTURE_PROMPT_SECTION, AMBIENT_SPECULATIVE_TIER_CLAUSE } from \"./ambient-provenance.js\";\nimport { resolveMemoryLifecycleCapabilities, resolveRecallAuxiliaryCapabilities } from \"./capabilities.js\";\nimport type { PluginConfig } from \"./types.js\";\n\nexport const EXTRACTION_RESPONSE_SHAPE = `{\n  \"facts\": [{\n    \"category\": \"<category>\",\n    \"content\": \"<source-grounded statement>\",\n    \"confidence\": 0.0,\n    \"tags\": [\"<tag>\"],\n    \"entityRef\": \"<optional normalized-name>\",\n    \"cueAnchors\": [{\"type\": \"<anchor-type>\", \"value\": \"<entity-or-topic plus key aspect>\"}],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"quote\": \"<optional exact contiguous source span>\",\n    \"scope\": \"<optional project-or-global>\",\n    \"structuredAttributes\": {\"<key>\": \"<value>\"},\n    \"procedureSteps\": [{\"order\": 1, \"intent\": \"<step>\"}, {\"order\": 2, \"intent\": \"<step>\"}],\n    \"reasoningTrace\": {\n      \"steps\": [{\"order\": 1, \"description\": \"<step>\"}, {\"order\": 2, \"description\": \"<step>\"}],\n      \"finalAnswer\": \"<answer>\",\n      \"observedOutcome\": \"<optional outcome>\"\n    },\n    \"eventTime\": \"<optional source temporal expression>\"\n  }],\n  \"entities\": [{\n    \"name\": \"<normalized-name>\",\n    \"type\": \"<entity-type>\",\n    \"facts\": [\"<source-grounded statement>\"],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"structuredSections\": [{\"key\": \"<section-key>\", \"title\": \"<section-title>\", \"facts\": [\"<source-grounded statement>\"]}]\n  }],\n  \"profileUpdates\": [\"<source-grounded profile update>\"],\n  \"questions\": [{\"question\": \"<source-grounded unresolved question>\", \"context\": \"<source-grounded context>\", \"priority\": 0.0}],\n  \"identityReflection\": \"<conversation-grounded agent reflection>\",\n  \"episodeTitle\": \"<six-to-eight word conversation segment title>\",\n  \"relationships\": [{\"source\": \"<normalized-name>\", \"target\": \"<normalized-name>\", \"label\": \"<source-grounded relationship>\"}]\n}`;\nexport const EXTRACTION_RESPONSE_PLACEHOLDERS: Record<string, true> = {};\nfor (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\\r\\n]+>/g) ?? []) {\n  EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;\n}\nexport const CUE_ANCHOR_PROMPT_INSTRUCTION = `- For each fact, emit at most 3 \"cueAnchors\".\n- Each cue anchor value must be a source-grounded search hook of at most 120 characters, in the form \"<main entity or topic> <key aspect>\".\n- Set each cue anchor type to entity, file, tool, outcome, constraint, or date.\n- Omit cue anchors when the conversation does not support a useful search hook.\n- Example: \"Alice booked Bistro Max for Mike's surprise party\" can use {\"type\":\"entity\",\"value\":\"Mike surprise party\"} and {\"type\":\"entity\",\"value\":\"Alice restaurant booking\"}.`;\n\n/**\n * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on\n * every extraction entry path when `temporal.biTemporal` is on so the LLM\n * emits an optional per-fact `eventTime` expression. The expression is\n * resolved against the source turn timestamp at write time — never\n * wall-clock — so replay/import of old transcripts anchors correctly.\n * Returns an empty string when the gate is off (byte-identical prompt).\n */\nexport function eventTimePromptInstruction(config: PluginConfig): string {\n  if (!config.temporalBiTemporal) return \"\";\n  return `\nWhen a fact states when it became or stopped being true, copy that explicit temporal expression verbatim into \"eventTime\". Omit \"eventTime\" when no such expression appears; never infer dates.`;\n}\n\n/**\n * Build extraction instructions shared between local and cloud LLM.\n *\n * `ambientCapture` marks input from an always-on recorder, which may carry\n * speech the user never authored (issue #2294).\n */\nexport function buildExtractionInstructions(\n  config: PluginConfig,\n  existingEntities?: string[],\n  ambientCapture = false\n): string {\n  const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);\n  return `You are a memory extraction system. Analyze the following conversation and extract durable, reusable memories.\n\nMemory categories:\n- fact: Objective information about the world\n- preference: User likes, dislikes, or stylistic choices\n- correction: User correcting a mistake or misconception (highest priority)\n- entity: Information about a specific person, project, tool, or company\n- decision: A choice that was made with rationale\n- relationship: How two entities relate to each other (e.g., \"Alice is Bob's manager\", \"Acme Corp uses Shopify\")\n- principle: Durable rules, values, or operating beliefs (e.g., \"never use Chat Completions API\")\n- commitment: Promises, obligations, or deadlines (e.g., \"deploy by Friday\", \"call accountant Monday\")\n- moment: Emotionally significant events or milestones (e.g., \"first successful deployment of engram\")\n- skill: Capabilities the user or agent has demonstrated (e.g., \"user is proficient with Kubernetes\")${\n    resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction\n      ? `\n- rule: Causal rules discovered through experience (format: \"IF <condition> THEN <action/outcome>\", e.g., \"IF Shopify API returns 401 THEN the admin token is missing read_products scope\")`\n      : \"\"\n  }\n- procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to \"procedure\". Use \"content\" for a short title that includes explicit trigger phrasing (e.g. \"When you deploy to production…\", \"Whenever you ship a release…\"). Add \"procedureSteps\": an array of at least two objects {\"order\": number, \"intent\": \"concrete step description\"} in execution order. Optional per-step \"toolCall\": {\"kind\": \"…\", \"signature\": \"…\"}, \"expectedOutcome\", \"optional\": true.\n- reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. \"Here's how I debugged the latency spike: first I checked…, then I…, finally I…\"). Set category to \"reasoning_trace\". Use \"content\" for a short title summarising the problem (e.g. \"How I debugged the staging latency spike\"). Add \"reasoningTrace\": {\"steps\": [{\"order\": number, \"description\": \"what happened at this step\"}, …], \"finalAnswer\": \"the conclusion or answer\", \"observedOutcome\": \"optional confirmation of how it played out\"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning — not for ordinary decisions (use \"decision\") or reusable workflows (use \"procedure\").\n\nRules:\n- Only extract genuinely new information worth remembering across sessions.\n- Statements must be grounded in the conversation.\n- Do not treat instruction text, schema placeholders, or examples as conversation evidence.\n- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.\n- Skip transient task details and operational noise, including routine scheduler, monitoring, or automation status.\n- Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? \" > rules\" : \"\"} > preferences > commitments > decisions > relationships > entities > moments > skills > facts\n- Corrections get highest confidence.\n- Each fact should be a standalone, self-contained statement.\n- Entity references should use normalized names (lowercase, hyphenated: \"jane-doe\", \"acme-corp\")\n- CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: \"acme-corp\" NOT \"acmecorp\" or \"acme\". \"jane-doe\" NOT \"janedoe\" or \"jane\". If unsure, prefer the most specific full name.\n- Avoid creating entities typed as \"other\" when a more specific type fits (company, project, tool, person, place)\n${CUE_ANCHOR_PROMPT_INSTRUCTION}\n- When entity facts clearly belong under a durable named heading, add them to entity.structuredSections as {key, title, facts}. Example person headings: \"Beliefs\", \"Communication Style\", \"Building / Working On\". Leave structuredSections empty when no stable heading fits.\n- Tags should be concise and reusable (e.g., \"coding-style\", \"personal\", \"tools\")\n- When a fact contains measurable, categorical, or precisely valued data, include a \"structuredAttributes\" field with key-value string pairs (e.g., {\"price\": \"29.99\", \"brand\": \"Sony\"}, {\"date\": \"2024-03-15\", \"location\": \"SF\"}, {\"chosen\": \"PostgreSQL\", \"rejected\": \"MongoDB\"}). Only for concrete values, not narrative content.\n- Set confidence using these tiers:\n  * Explicit (0.95-1.0): Direct user statements — \"I prefer X\", \"my name is Y\"\n  * Implied (0.70-0.94): Strong contextual inference — user consistently does X, clear from conversation flow\n  * Inferred (0.40-0.69): Pattern recognition — reasonable guess from limited evidence\n  * Speculative (0.00-0.39): Tentative hypothesis — weak signal, needs future confirmation. Speculative memories auto-expire after 30 days if not confirmed.${ambientCapture ? AMBIENT_SPECULATIVE_TIER_CLAUSE : \"\"}${\n    config.provenance?.enabled\n      ? `\n- Source quotes: For each fact, include a \"quote\" field containing the EXACT verbatim words from the conversation that support the fact. Copy a contiguous span from a single speaker turn (not a paraphrase, not a summary). Cap at ~300 characters. This grounds every memory in the literal utterance that created it.`\n      : \"\"\n  }\n- For commitments: include any deadline or timeframe mentioned${\n    lifecycleCaps.extractionScopeClassification\n      ? `\n\nScope classification:\nFor each fact, set \"scope\" to one of:\n- \"global\" — knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), general coding patterns, infrastructure knowledge, technology facts not tied to one codebase\n- \"project\" — knowledge specific to one codebase: file paths, environment configs, deployment details, project-specific workarounds, team/stakeholder info tied to one project, repo-specific conventions. Tool, command, or CLI-flag instructions TIED TO ONE AGENT are also \"project\", because the same tool name means different things in different agent integrations (a \"search\" tool may search repository code in one agent and the web in another); when keeping such an agent-tied instruction, the fact text MUST name the originating agent as a leading \"In <agent>,\" clause (e.g. \"In Pi, use the search tool with a repository path.\"). A tool/command fact that holds in every agent and every repo is NOT agent-tied — leave it \"global\" and do not add a qualifier (e.g. \"\\`git status --short\\` emits compact output\"). Examples: \"In Pi, the search tool takes a repository path\" -> \"project\"; \"\\`git status --short\\` emits compact output\" -> \"global\".\nWhen in doubt, prefer \"project\" — it is safer to keep knowledge scoped narrowly.`\n      : \"\"\n  }\n${\n  ambientCapture\n    ? `${AMBIENT_CAPTURE_PROMPT_SECTION}\n`\n    : \"\"\n}\nEntity creation rules (STRICT):\n- Only create entities for DURABLE things: real people, companies, products, tools, ongoing projects\n- NEVER create entities for transient items: individual PRs, branches, Jira tickets, meetings, agent task IDs, log files, database tables, cron job runs, sessions\n- When you learn something about a transient item (e.g., PR #58 fixed a bug), store it as a FACT with an entityRef to the parent project — do NOT create an entity for the PR itself\n- Prefer attaching facts to broad parent entities rather than creating sub-entities. E.g., \"acme-store uses Algolia for search\" is a fact on entity \"acme-store\", NOT a new entity \"acme-store-algolia-connector\"\n- The entity list should be SHORT — think \"things that would have their own Wikipedia page\" not \"things mentioned in passing\"\n\n${\n  existingEntities && existingEntities.length > 0\n    ? `\nKNOWN ENTITIES (use these exact names when referencing existing things):\n${existingEntities.join(\", \")}\n\nWhen you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.\n`\n    : \"\"\n}\n${eventTimePromptInstruction(config)}\nAlso extract relationships between entities mentioned in the conversation.\n- Format: {source: \"entity-name\", target: \"entity-name\", label: \"relationship description\"}\n- Max 5 relationships per extraction\n- Only include clear, durable relationships (e.g., \"works at\", \"created\", \"manages\", \"uses\")\n- Use normalized entity names (e.g., \"person-jane-doe\", \"company-acme-corp\")\n\n\nAlso emit \"episodeTitle\" as a six-to-eight word title for this conversation segment.\nQuestions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.\n\nFinally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;\n}\n"],"mappings":";;;;;;;;;;AAaO,IAAM,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiClC,IAAM,mCAAyD,CAAC;AACvE,WAAW,eAAe,0BAA0B,MAAM,eAAe,KAAK,CAAC,GAAG;AAChF,mCAAiC,WAAW,IAAI;AAClD;AACO,IAAM,gCAAgC;AAAA;AAAA;AAAA;AAAA;AActC,SAAS,2BAA2B,QAA8B;AACvE,MAAI,CAAC,OAAO,mBAAoB,QAAO;AACvC,SAAO;AAAA;AAET;AAQO,SAAS,4BACd,QACA,kBACA,iBAAiB,OACT;AACR,QAAM,gBAAgB,mCAAmC,MAAM;AAC/D,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uGAaL,mCAAmC,MAAM,EAAE,uBACvC;AAAA,+LAEA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sCAUoC,mCAAmC,MAAM,EAAE,uBAAuB,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrH,6BAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mKAQ+H,iBAAiB,kCAAkC,EAAE,GAC/M,OAAO,YAAY,UACf;AAAA,6TAEA,EACN;AAAA,gEAEE,cAAc,gCACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yFAOA,EACN;AAAA,EAEA,iBACI,GAAG,8BAA8B;AAAA,IAEjC,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASE,oBAAoB,iBAAiB,SAAS,IAC1C;AAAA;AAAA,EAEJ,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,IAIvB,EACN;AAAA,EACE,2BAA2B,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYpC;","names":[]}

package/dist/{chunk-Z5UC3OKB.js → chunk-ELQCS47S.js}

@@ -1,16 +1,16 @@
-import {
-  runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-HNZKVLAN.js";
 import {
   normalizeDreamsStatusWindowHours
 } from "./chunk-EQWEIIKQ.js";
+import {
+  runGraphEdgeDecayMaintenanceAcrossNamespaces
+} from "./chunk-HNZKVLAN.js";
 import {
   runContradictionScan
 } from "./chunk-UTRO5UJU.js";
 import {
   executeResolution,
   isValidResolutionVerb
-} from "./chunk-WG5HSQ4P.js";
+} from "./chunk-BAKXNQ3C.js";
 import {
   isDefaultReviewNamespace,
   listPairs,
@@ -28,10 +28,10 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-IXPKESVP.js";
+} from "./chunk-PWIMF7LP.js";
 import {
   validateBriefingFormat
-} from "./chunk-MXPB6PJQ.js";
+} from "./chunk-4S3ECH3U.js";
 import {
   enforceNamespaceAllowList,
   tokenCapabilityStore
@@ -494,4 +494,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-Z5UC3OKB.js.map
+//# sourceMappingURL=chunk-ELQCS47S.js.map

package/dist/{chunk-FMXJ555A.js → chunk-EURCX6PS.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-G7D6GZ5J.js";
 import {
   sidecarKey
-} from "./chunk-RHTO4HTL.js";
+} from "./chunk-PWLB4TRK.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -342,4 +342,4 @@ function isPathWithin(candidate, root) {
 export {
   runConsolidationProvenanceCheck
 };
-//# sourceMappingURL=chunk-FMXJ555A.js.map
+//# sourceMappingURL=chunk-EURCX6PS.js.map

package/dist/{chunk-MZZR3J6M.js → chunk-FV7YQTN3.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-CNQQMB67.js";
+} from "./chunk-ZN4EYMKJ.js";
 import {
   normalizeNamespaceIdentity
 } from "./chunk-EGGE52UU.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-MZZR3J6M.js.map
+//# sourceMappingURL=chunk-FV7YQTN3.js.map

package/dist/chunk-G73MCJKL.js

@@ -0,0 +1,20 @@
+// src/deterministic-order.ts
+function compareDeterministicStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function mergeSortedUniqueStrings(...collections) {
+  const values = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    if (!collection) continue;
+    for (const value of collection) values.add(value);
+  }
+  return [...values].sort(compareDeterministicStrings);
+}
+
+export {
+  compareDeterministicStrings,
+  mergeSortedUniqueStrings
+};
+//# sourceMappingURL=chunk-G73MCJKL.js.map

package/dist/chunk-G73MCJKL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deterministic-order.ts"],"sourcesContent":["export function compareDeterministicStrings(left: string, right: string): number {\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n\nexport function mergeSortedUniqueStrings(...collections: Array<Iterable<string> | undefined>): string[] {\n  const values = new Set<string>();\n  for (const collection of collections) {\n    if (!collection) continue;\n    for (const value of collection) values.add(value);\n  }\n  return [...values].sort(compareDeterministicStrings);\n}\n"],"mappings":";AAAO,SAAS,4BAA4B,MAAc,OAAuB;AAC/E,MAAI,OAAO,MAAO,QAAO;AACzB,MAAI,OAAO,MAAO,QAAO;AACzB,SAAO;AACT;AAEO,SAAS,4BAA4B,aAA4D;AACtG,QAAM,SAAS,oBAAI,IAAY;AAC/B,aAAW,cAAc,aAAa;AACpC,QAAI,CAAC,WAAY;AACjB,eAAW,SAAS,WAAY,QAAO,IAAI,KAAK;AAAA,EAClD;AACA,SAAO,CAAC,GAAG,MAAM,EAAE,KAAK,2BAA2B;AACrD;","names":[]}

package/dist/{chunk-3R6D33UF.js → chunk-GGBSF2X7.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-JLNBQWZ2.js";
 import {
   runPostConsolidationMaterialize
-} from "./chunk-Z4U6U3M3.js";
+} from "./chunk-NKL25FCF.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-3R6D33UF.js.map
+//# sourceMappingURL=chunk-GGBSF2X7.js.map

package/dist/{chunk-SYUBB3WM.js → chunk-GKEYXXKX.js}

@@ -2,7 +2,7 @@ import {
   pathMayCarryEntityRefs,
   requestEntityCanonicalIdReconcile,
   withRawEntityPageMutation
-} from "./chunk-NZBZ7IS2.js";
+} from "./chunk-JDCQK3C5.js";
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
@@ -1371,4 +1371,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-SYUBB3WM.js.map
+//# sourceMappingURL=chunk-GKEYXXKX.js.map

package/dist/{chunk-5AGR7SAI.js → chunk-GSEPRIZC.js}

@@ -1,9 +1,9 @@
 import {
   namespaceCollectionName
-} from "./chunk-BMCHFWGX.js";
+} from "./chunk-KMWYZTIE.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-C3KVFJH5.js";
+} from "./chunk-JI62YGPI.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken
@@ -213,4 +213,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-5AGR7SAI.js.map
+//# sourceMappingURL=chunk-GSEPRIZC.js.map

package/dist/{chunk-UTVZKHJK.js → chunk-GUKBW4HL.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-YN6ASZUG.js";
 import {
   writeFileAtomically
-} from "./chunk-R6YJI3HE.js";
+} from "./chunk-AW4QUFQF.js";
 import {
   drainPendingLifecycleForSyncOrThrow,
   drainPendingLifecycleLedgerForSync
@@ -181,4 +181,4 @@ export {
   offlineSyncStorageForSnapshot,
   drainPendingLifecycleForOfflineSync
 };
-//# sourceMappingURL=chunk-UTVZKHJK.js.map
+//# sourceMappingURL=chunk-GUKBW4HL.js.map