@remnic/core 9.45.3 → 9.45.4

package/dist/chunk-VHFXP27N.js

@@ -0,0 +1,250 @@
+import {
+  summarizeReconcilePlan
+} from "./chunk-G7A5HLUS.js";
+import {
+  inferMemoryStatus
+} from "./chunk-7RJUVTVF.js";
+import {
+  ContentHashIndex
+} from "./chunk-BQIFZ2MP.js";
+import {
+  RECALL_FALLBACK_DIRS
+} from "./chunk-VS2IYZRU.js";
+
+// src/reconcile/manifest.ts
+import { createHash } from "crypto";
+var RECONCILE_MANIFEST_FORMAT = "remnic-reconcile-manifest";
+var RECONCILE_MANIFEST_SCHEMA_VERSION = 1;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/i;
+var MEMORY_DIRS = new Set(RECALL_FALLBACK_DIRS);
+function isMemoryPath(filePath) {
+  if (!filePath.endsWith(".md")) return false;
+  const segments = filePath.split("/");
+  let index = 0;
+  if (segments[index] === "cold" || segments[index] === "archive") index += 1;
+  return MEMORY_DIRS.has(segments[index] ?? "");
+}
+function parsedMemoryIdentity(filePath, raw, parseMemory) {
+  if (!isMemoryPath(filePath)) return void 0;
+  const parsed = parseMemory(Buffer.isBuffer(raw) ? raw.toString("utf8") : raw);
+  if (!parsed?.frontmatter.id) return void 0;
+  const storedHash = parsed.frontmatter.contentHash;
+  const contentHash = storedHash && SHA256_PATTERN.test(storedHash) ? storedHash.toLowerCase() : ContentHashIndex.computeHash(parsed.content);
+  return {
+    id: parsed.frontmatter.id,
+    category: parsed.frontmatter.category,
+    contentHash,
+    status: inferMemoryStatus(parsed.frontmatter, filePath)
+  };
+}
+async function buildReconcileManifestFile(file, readFile, parseMemory) {
+  let raw = null;
+  if (isMemoryPath(file.path)) {
+    try {
+      raw = await readFile(file);
+    } catch {
+      raw = null;
+    }
+  }
+  if (raw !== null && createHash("sha256").update(raw).digest("hex") !== file.sha256.toLowerCase()) {
+    raw = null;
+  }
+  const memory = raw === null ? void 0 : parsedMemoryIdentity(file.path, raw, parseMemory);
+  return { ...file, ...memory ? { memory } : {} };
+}
+async function buildReconcileManifest(options) {
+  const cachedByPath = /* @__PURE__ */ new Map();
+  for (const cached of options.cachedFiles ?? []) {
+    cachedByPath.set(cached.path, cached);
+  }
+  const files = [];
+  for (const file of options.files) {
+    const cached = cachedByPath.get(file.path);
+    if (cached?.sha256.toLowerCase() === file.sha256.toLowerCase()) {
+      files.push({ ...file, ...cached.memory ? { memory: cached.memory } : {} });
+      continue;
+    }
+    files.push(await buildReconcileManifestFile(file, options.readFile, options.parseMemory));
+  }
+  files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+  return {
+    format: RECONCILE_MANIFEST_FORMAT,
+    schemaVersion: RECONCILE_MANIFEST_SCHEMA_VERSION,
+    files
+  };
+}
+function activeFactByPath(manifest) {
+  const result = /* @__PURE__ */ new Map();
+  for (const file of manifest?.files ?? []) {
+    if (file.memory?.category === "fact" && file.memory.status === "active") {
+      result.set(file.path, file);
+    }
+  }
+  return result;
+}
+function contentHashRows(files) {
+  const rows = [];
+  for (const file of files) {
+    rows.push({ path: file.path, contentHash: file.memory.contentHash });
+  }
+  return rows;
+}
+function comparePlanEntries(left, right) {
+  if (left.namespace !== right.namespace) return left.namespace < right.namespace ? -1 : 1;
+  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
+}
+function semanticAgreementKey(agreement) {
+  return `${agreement.local.path}\0${agreement.peer.path}`;
+}
+function classifySemanticChange(current, prior) {
+  if (!prior) return "unchanged";
+  const localChanged = current.local.sha256 !== prior.local.sha256;
+  const peerChanged = current.peer.sha256 !== prior.peer.sha256;
+  if (localChanged && peerChanged) return "both_modified";
+  if (localChanged) return "local_changed";
+  if (peerChanged) return "peer_changed";
+  return "unchanged";
+}
+function collapseActiveFactDuplicates(plan, localManifests, peerManifests, priorSemanticAgreements) {
+  const entriesByNamespace = /* @__PURE__ */ new Map();
+  for (const entry of plan.entries) {
+    const entries2 = entriesByNamespace.get(entry.namespace) ?? [];
+    entries2.push({ ...entry });
+    entriesByNamespace.set(entry.namespace, entries2);
+  }
+  let changed = false;
+  for (const namespace of /* @__PURE__ */ new Set([...localManifests.keys(), ...peerManifests.keys()])) {
+    const entries2 = entriesByNamespace.get(namespace) ?? [];
+    const localManifest = localManifests.get(namespace);
+    const peerManifest = peerManifests.get(namespace);
+    const localByPath = activeFactByPath(localManifest);
+    const peerByPath = activeFactByPath(peerManifest);
+    const localFilesByPath = new Map((localManifest?.files ?? []).map((file) => [file.path, file]));
+    const peerFilesByPath = new Map((peerManifest?.files ?? []).map((file) => [file.path, file]));
+    const priorSemanticByPathPair = new Map(
+      (priorSemanticAgreements?.get(namespace) ?? []).map((agreement) => [
+        semanticAgreementKey(agreement),
+        agreement
+      ])
+    );
+    const localByHash = /* @__PURE__ */ new Map();
+    const peerByHash = /* @__PURE__ */ new Map();
+    for (const file of localByPath.values()) {
+      const hash = file.memory.contentHash;
+      const bucket = localByHash.get(hash) ?? [];
+      bucket.push(file);
+      localByHash.set(hash, bucket);
+    }
+    for (const file of peerByPath.values()) {
+      const hash = file.memory.contentHash;
+      const bucket = peerByHash.get(hash) ?? [];
+      bucket.push(file);
+      peerByHash.set(hash, bucket);
+    }
+    const removed = /* @__PURE__ */ new Set();
+    const replacements = [];
+    for (const hash of /* @__PURE__ */ new Set([...localByHash.keys(), ...peerByHash.keys()])) {
+      const localCandidates = (localByHash.get(hash) ?? []).filter((file) => {
+        const opposite = peerFilesByPath.get(file.path);
+        const activeOpposite = peerByPath.get(file.path);
+        return opposite === void 0 || activeOpposite?.memory.contentHash === hash;
+      });
+      const peerCandidates = (peerByHash.get(hash) ?? []).filter((file) => {
+        const opposite = localFilesByPath.get(file.path);
+        const activeOpposite = localByPath.get(file.path);
+        return opposite === void 0 || activeOpposite?.memory.contentHash === hash;
+      });
+      const localPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(localCandidates));
+      const peerPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(peerCandidates));
+      if (localPath && peerPath && localPath !== peerPath) {
+        const localFile = localByPath.get(localPath);
+        const peerFile = peerByPath.get(peerPath);
+        if (!localFile || !peerFile) continue;
+        const duplicatePaths = /* @__PURE__ */ new Set([
+          ...localCandidates.map((file) => file.path),
+          ...peerCandidates.map((file) => file.path)
+        ]);
+        const authoritativeSamePathEntries = new Set(entries2.filter(
+          (entry) => duplicatePaths.has(entry.path) && localFilesByPath.has(entry.path) && peerFilesByPath.has(entry.path) && entry.action !== "identical"
+        ));
+        if (authoritativeSamePathEntries.size > 0) {
+          for (const entry of entries2) {
+            if (duplicatePaths.has(entry.path) && !authoritativeSamePathEntries.has(entry) && (entry.action === "pull" || entry.action === "push" || entry.action === "identical")) {
+              removed.add(entry);
+              changed = true;
+            }
+          }
+          continue;
+        }
+        const unsafeEntry = entries2.some(
+          (entry) => duplicatePaths.has(entry.path) && (entry.action === "suppress" || entry.action === "conflict")
+        );
+        if (unsafeEntry) continue;
+        for (const entry of entries2) {
+          if (duplicatePaths.has(entry.path) && (entry.action === "pull" || entry.action === "push" || entry.action === "identical")) {
+            removed.add(entry);
+          }
+        }
+        const semanticAgreement = {
+          local: { path: localPath, sha256: localFile.sha256 },
+          peer: { path: peerPath, sha256: peerFile.sha256 }
+        };
+        replacements.push({
+          path: localPath < peerPath ? localPath : peerPath,
+          namespace,
+          action: "identical",
+          reason: "semantic_duplicate",
+          semanticAgreement,
+          semanticChange: classifySemanticChange(
+            semanticAgreement,
+            priorSemanticByPathPair.get(semanticAgreementKey(semanticAgreement))
+          )
+        });
+        changed = true;
+        continue;
+      }
+      const sameSideEntries = entries2.filter((entry) => {
+        if (localPath && entry.reason === "local_only") {
+          return localCandidates.some((file) => file.path === entry.path);
+        }
+        if (peerPath && entry.reason === "peer_only") {
+          return peerCandidates.some((file) => file.path === entry.path);
+        }
+        return false;
+      });
+      const canonicalPath = localPath ?? peerPath;
+      const hasSharedCanonical = localPath !== void 0 && localPath === peerPath;
+      if (!canonicalPath || sameSideEntries.length === 0 || !hasSharedCanonical && sameSideEntries.length < 2) {
+        continue;
+      }
+      for (const entry of sameSideEntries) {
+        if (entry.path !== canonicalPath) {
+          removed.add(entry);
+          changed = true;
+        }
+      }
+    }
+    if (removed.size > 0 || replacements.length > 0) {
+      entriesByNamespace.set(
+        namespace,
+        [...entries2.filter((entry) => !removed.has(entry)), ...replacements].sort(comparePlanEntries)
+      );
+    }
+  }
+  if (!changed) return plan;
+  const entries = [...entriesByNamespace.values()].flat().sort(comparePlanEntries);
+  return {
+    entries,
+    byNamespace: summarizeReconcilePlan(entries),
+    converged: entries.every((entry) => entry.action === "identical")
+  };
+}
+
+export {
+  RECONCILE_MANIFEST_FORMAT,
+  RECONCILE_MANIFEST_SCHEMA_VERSION,
+  buildReconcileManifestFile,
+  buildReconcileManifest,
+  collapseActiveFactDuplicates
+};
+//# sourceMappingURL=chunk-VHFXP27N.js.map

package/dist/chunk-VHFXP27N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reconcile/manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { inferMemoryStatus } from \"../memory-lifecycle-ledger-utils.js\";\nimport { ContentHashIndex, type ContentHashPathEntry } from \"../storage/content-hash-index.js\";\nimport type { MemoryFrontmatter, MemoryStatus } from \"../types.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport {\n  type ReconcileFileState,\n  type ReconcilePlan,\n  type ReconcilePlanEntry,\n  type ReconcileSemanticAgreement,\n  type ReconcileSemanticChange,\n  summarizeReconcilePlan,\n} from \"./plan.js\";\n\nexport const RECONCILE_MANIFEST_FORMAT = \"remnic-reconcile-manifest\";\nexport const RECONCILE_MANIFEST_SCHEMA_VERSION = 1;\n\nexport interface ReconcileMemoryIdentity {\n  id: string;\n  category: string;\n  contentHash: string;\n  status: MemoryStatus;\n}\n\nexport interface ReconcileManifestFile extends ReconcileFileState {\n  memory?: ReconcileMemoryIdentity;\n}\n\ntype ActiveFactManifestFile = ReconcileManifestFile & { memory: ReconcileMemoryIdentity };\n\nexport interface ReconcileManifest {\n  format: typeof RECONCILE_MANIFEST_FORMAT;\n  schemaVersion: typeof RECONCILE_MANIFEST_SCHEMA_VERSION;\n  files: ReconcileManifestFile[];\n}\n\nexport type ReconcileMemoryParser = (\n  raw: string,\n) => { frontmatter: MemoryFrontmatter; content: string } | null;\n\nexport interface BuildReconcileManifestOptions {\n  files: Iterable<ReconcileFileState>;\n  readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>;\n  parseMemory: ReconcileMemoryParser;\n  cachedFiles?: Iterable<ReconcileManifestFile>;\n}\n\nconst SHA256_PATTERN = /^[a-f0-9]{64}$/i;\nconst MEMORY_DIRS = new Set(RECALL_FALLBACK_DIRS);\n\nfunction isMemoryPath(filePath: string): boolean {\n  if (!filePath.endsWith(\".md\")) return false;\n  const segments = filePath.split(\"/\");\n  let index = 0;\n  if (segments[index] === \"cold\" || segments[index] === \"archive\") index += 1;\n  return MEMORY_DIRS.has(segments[index] ?? \"\");\n}\n\n\nfunction parsedMemoryIdentity(\n  filePath: string,\n  raw: Buffer | string,\n  parseMemory: ReconcileMemoryParser,\n): ReconcileMemoryIdentity | undefined {\n  if (!isMemoryPath(filePath)) return undefined;\n  const parsed = parseMemory(Buffer.isBuffer(raw) ? raw.toString(\"utf8\") : raw);\n  if (!parsed?.frontmatter.id) return undefined;\n  const storedHash = parsed.frontmatter.contentHash;\n  const contentHash =\n    storedHash && SHA256_PATTERN.test(storedHash)\n      ? storedHash.toLowerCase()\n      : ContentHashIndex.computeHash(parsed.content);\n  return {\n    id: parsed.frontmatter.id,\n    category: parsed.frontmatter.category,\n    contentHash,\n    status: inferMemoryStatus(parsed.frontmatter, filePath),\n  };\n}\n\nexport async function buildReconcileManifestFile(\n  file: ReconcileFileState,\n  readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>,\n  parseMemory: ReconcileMemoryParser,\n): Promise<ReconcileManifestFile> {\n  let raw: Buffer | string | null = null;\n  if (isMemoryPath(file.path)) {\n    try {\n      raw = await readFile(file);\n    } catch {\n      raw = null;\n    }\n  }\n  if (raw !== null && createHash(\"sha256\").update(raw).digest(\"hex\") !== file.sha256.toLowerCase()) {\n    raw = null;\n  }\n  const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw, parseMemory);\n  return { ...file, ...(memory ? { memory } : {}) };\n}\n\nexport async function buildReconcileManifest(options: BuildReconcileManifestOptions): Promise<ReconcileManifest> {\n  const cachedByPath = new Map<string, ReconcileManifestFile>();\n  for (const cached of options.cachedFiles ?? []) {\n    cachedByPath.set(cached.path, cached);\n  }\n\n  const files: ReconcileManifestFile[] = [];\n  for (const file of options.files) {\n    const cached = cachedByPath.get(file.path);\n    if (cached?.sha256.toLowerCase() === file.sha256.toLowerCase()) {\n      files.push({ ...file, ...(cached.memory ? { memory: cached.memory } : {}) });\n      continue;\n    }\n\n    files.push(await buildReconcileManifestFile(file, options.readFile, options.parseMemory));\n  }\n  files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));\n  return {\n    format: RECONCILE_MANIFEST_FORMAT,\n    schemaVersion: RECONCILE_MANIFEST_SCHEMA_VERSION,\n    files,\n  };\n}\n\nfunction activeFactByPath(manifest: ReconcileManifest | undefined): Map<string, ActiveFactManifestFile> {\n  const result = new Map<string, ActiveFactManifestFile>();\n  for (const file of manifest?.files ?? []) {\n    if (file.memory?.category === \"fact\" && file.memory.status === \"active\") {\n      result.set(file.path, file as ActiveFactManifestFile);\n    }\n  }\n  return result;\n}\n\nfunction contentHashRows(files: Iterable<ActiveFactManifestFile>): ContentHashPathEntry[] {\n  const rows: ContentHashPathEntry[] = [];\n  for (const file of files) {\n    rows.push({ path: file.path, contentHash: file.memory.contentHash });\n  }\n  return rows;\n}\n\nfunction comparePlanEntries(left: ReconcilePlanEntry, right: ReconcilePlanEntry): number {\n  if (left.namespace !== right.namespace) return left.namespace < right.namespace ? -1 : 1;\n  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;\n}\n\nfunction semanticAgreementKey(agreement: ReconcileSemanticAgreement): string {\n  return `${agreement.local.path}\\0${agreement.peer.path}`;\n}\n\nfunction classifySemanticChange(\n  current: ReconcileSemanticAgreement,\n  prior: ReconcileSemanticAgreement | undefined\n): ReconcileSemanticChange {\n  if (!prior) return \"unchanged\";\n  const localChanged = current.local.sha256 !== prior.local.sha256;\n  const peerChanged = current.peer.sha256 !== prior.peer.sha256;\n  if (localChanged && peerChanged) return \"both_modified\";\n  if (localChanged) return \"local_changed\";\n  if (peerChanged) return \"peer_changed\";\n  return \"unchanged\";\n}\n\nexport function collapseActiveFactDuplicates(\n  plan: ReconcilePlan,\n  localManifests: ReadonlyMap<string, ReconcileManifest>,\n  peerManifests: ReadonlyMap<string, ReconcileManifest>,\n  priorSemanticAgreements?: ReadonlyMap<string, readonly ReconcileSemanticAgreement[]>,\n): ReconcilePlan {\n  const entriesByNamespace = new Map<string, ReconcilePlanEntry[]>();\n  for (const entry of plan.entries) {\n    const entries = entriesByNamespace.get(entry.namespace) ?? [];\n    entries.push({ ...entry });\n    entriesByNamespace.set(entry.namespace, entries);\n  }\n\n  let changed = false;\n  for (const namespace of new Set([...localManifests.keys(), ...peerManifests.keys()])) {\n    const entries = entriesByNamespace.get(namespace) ?? [];\n    const localManifest = localManifests.get(namespace);\n    const peerManifest = peerManifests.get(namespace);\n    const localByPath = activeFactByPath(localManifest);\n    const peerByPath = activeFactByPath(peerManifest);\n    const localFilesByPath = new Map((localManifest?.files ?? []).map((file) => [file.path, file]));\n    const peerFilesByPath = new Map((peerManifest?.files ?? []).map((file) => [file.path, file]));\n    const priorSemanticByPathPair = new Map(\n      (priorSemanticAgreements?.get(namespace) ?? []).map((agreement) => [\n        semanticAgreementKey(agreement),\n        agreement,\n      ])\n    );\n    const localByHash = new Map<string, ActiveFactManifestFile[]>();\n    const peerByHash = new Map<string, ActiveFactManifestFile[]>();\n\n    for (const file of localByPath.values()) {\n      const hash = file.memory.contentHash;\n      const bucket = localByHash.get(hash) ?? [];\n      bucket.push(file);\n      localByHash.set(hash, bucket);\n    }\n    for (const file of peerByPath.values()) {\n      const hash = file.memory.contentHash;\n      const bucket = peerByHash.get(hash) ?? [];\n      bucket.push(file);\n      peerByHash.set(hash, bucket);\n    }\n\n    const removed = new Set<ReconcilePlanEntry>();\n    const replacements: ReconcilePlanEntry[] = [];\n    for (const hash of new Set([...localByHash.keys(), ...peerByHash.keys()])) {\n      const localCandidates = (localByHash.get(hash) ?? []).filter((file) => {\n        const opposite = peerFilesByPath.get(file.path);\n        const activeOpposite = peerByPath.get(file.path);\n        return opposite === undefined || activeOpposite?.memory.contentHash === hash;\n      });\n      const peerCandidates = (peerByHash.get(hash) ?? []).filter((file) => {\n        const opposite = localFilesByPath.get(file.path);\n        const activeOpposite = localByPath.get(file.path);\n        return opposite === undefined || activeOpposite?.memory.contentHash === hash;\n      });\n      const localPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(localCandidates));\n      const peerPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(peerCandidates));\n\n      if (localPath && peerPath && localPath !== peerPath) {\n        const localFile = localByPath.get(localPath);\n        const peerFile = peerByPath.get(peerPath);\n        if (!localFile || !peerFile) continue;\n        const duplicatePaths = new Set([\n          ...localCandidates.map((file) => file.path),\n          ...peerCandidates.map((file) => file.path),\n        ]);\n        const authoritativeSamePathEntries = new Set(entries.filter(\n          (entry) =>\n            duplicatePaths.has(entry.path)\n            && localFilesByPath.has(entry.path)\n            && peerFilesByPath.has(entry.path)\n            && entry.action !== \"identical\"\n        ));\n        if (authoritativeSamePathEntries.size > 0) {\n          for (const entry of entries) {\n            if (\n              duplicatePaths.has(entry.path)\n              && !authoritativeSamePathEntries.has(entry)\n              && (entry.action === \"pull\" || entry.action === \"push\" || entry.action === \"identical\")\n            ) {\n              removed.add(entry);\n              changed = true;\n            }\n          }\n          continue;\n        }\n        const unsafeEntry = entries.some(\n          (entry) => duplicatePaths.has(entry.path) && (entry.action === \"suppress\" || entry.action === \"conflict\")\n        );\n        if (unsafeEntry) continue;\n        for (const entry of entries) {\n          if (\n            duplicatePaths.has(entry.path) &&\n            (entry.action === \"pull\" || entry.action === \"push\" || entry.action === \"identical\")\n          ) {\n            removed.add(entry);\n          }\n        }\n        const semanticAgreement: ReconcileSemanticAgreement = {\n          local: { path: localPath, sha256: localFile.sha256 },\n          peer: { path: peerPath, sha256: peerFile.sha256 },\n        };\n        replacements.push({\n          path: localPath < peerPath ? localPath : peerPath,\n          namespace,\n          action: \"identical\",\n          reason: \"semantic_duplicate\",\n          semanticAgreement,\n          semanticChange: classifySemanticChange(\n            semanticAgreement,\n            priorSemanticByPathPair.get(semanticAgreementKey(semanticAgreement))\n          ),\n        });\n        changed = true;\n        continue;\n      }\n\n      const sameSideEntries = entries.filter((entry) => {\n        if (localPath && entry.reason === \"local_only\") {\n          return localCandidates.some((file) => file.path === entry.path);\n        }\n        if (peerPath && entry.reason === \"peer_only\") {\n          return peerCandidates.some((file) => file.path === entry.path);\n        }\n        return false;\n      });\n      const canonicalPath = localPath ?? peerPath;\n      const hasSharedCanonical = localPath !== undefined && localPath === peerPath;\n      if (!canonicalPath || sameSideEntries.length === 0 || (!hasSharedCanonical && sameSideEntries.length < 2)) {\n        continue;\n      }\n      for (const entry of sameSideEntries) {\n        if (entry.path !== canonicalPath) {\n          removed.add(entry);\n          changed = true;\n        }\n      }\n    }\n\n    if (removed.size > 0 || replacements.length > 0) {\n      entriesByNamespace.set(\n        namespace,\n        [...entries.filter((entry) => !removed.has(entry)), ...replacements].sort(comparePlanEntries)\n      );\n    }\n  }\n\n  if (!changed) return plan;\n  const entries = [...entriesByNamespace.values()].flat().sort(comparePlanEntries);\n  return {\n    entries,\n    byNamespace: summarizeReconcilePlan(entries),\n    converged: entries.every((entry) => entry.action === \"identical\"),\n  };\n}\n"],"mappings":"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","names":["entries"]}

package/dist/{chunk-3Y224NYC.js → chunk-VYISFWVX.js}

@@ -1,6 +1,6 @@
 import {
   reportSearchDegradation
-} from "./chunk-YV32N67O.js";
+} from "./chunk-URS5GSM7.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -121,4 +121,4 @@ var RemoteSearchBackend = class {
 export {
   RemoteSearchBackend
 };
-//# sourceMappingURL=chunk-3Y224NYC.js.map
+//# sourceMappingURL=chunk-VYISFWVX.js.map

package/dist/{chunk-TIHMZFIV.js → chunk-W3IC7QOY.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-3TBLDMJA.js";
+} from "./chunk-O4KMGRXE.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-J7VGGECD.js";
+} from "./chunk-DZPFMQZ7.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-TIHMZFIV.js.map
+//# sourceMappingURL=chunk-W3IC7QOY.js.map

package/dist/{chunk-NRV4Y3PM.js → chunk-W4FBGYGK.js}

@@ -216,4 +216,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-NRV4Y3PM.js.map
+//# sourceMappingURL=chunk-W4FBGYGK.js.map

package/dist/{chunk-P2BM76KT.js → chunk-WAS4HV46.js}

@@ -6,7 +6,7 @@ function isInterrogativeSourceSentence(sentence) {
   );
   const embeddedQuestionMarkerIndex = normalized.search(/\b(?:whether|if)\b/iu);
   const hasEmbeddedQuestion = embeddedQuestionVerbIndex >= 0 && embeddedQuestionMarkerIndex > embeddedQuestionVerbIndex;
-  return normalized.endsWith("?") || hasEmbeddedQuestion || !normalized.includes(":") && /^(?:suppose|assuming|assume|maybe|perhaps|hypothetically|if|whether|imagine|imagining|presume|presuming|supposing|is|are|am|was|were|do|does|did|can|could|will|would|should|has|have|had|what|which|when|where|why|how|who)\b/iu.test(
+  return normalized.endsWith("?") || hasEmbeddedQuestion || !normalized.includes(":") && /^(?:suppose|assuming|assume|maybe|perhaps|hypothetically|if|whether|imagine|imagining|presume|presuming|supposing|is|are|am|was|were|do|does|did|can|could|will|would|should|has|have|had|what|which|when|where|why|how|who|whom)\b/iu.test(
     normalized
   );
 }
@@ -17,16 +17,46 @@ function containsContiguousGroundingTokens(candidateTokens, sourceTokens) {
   );
 }
 function hasExplicitRoleSubjectToken(candidateRole, sourceTokensBySentence) {
-  return candidateRole !== void 0 && sourceTokensBySentence.some((tokens) => tokens.includes(candidateRole));
+  return candidateRole !== void 0 && sourceTokensBySentence.some((tokens) => tokens.some((token) => token.replace(/^[\u0000\u0001]/u, "") === candidateRole));
 }
-function splitGroundingClauses(sentences) {
-  return sentences.flatMap(
-    (sentence) => sentence.split(/,\s+(?=[\p{L}][\p{L}\p{N}'’-]*\s+\S)/gu).flatMap(
+function splitGroundingClauses(sentences, inheritCoordinatedSubjects = false) {
+  return sentences.flatMap((sentence) => {
+    const clauses = sentence.split(/,\s+(?=[\p{L}][\p{L}\p{N}'’-]*\s+\S)/gu).flatMap(
       (commaClause) => commaClause.split(/\s*(?::|[—–])\s+|\s+\/\s+/u).flatMap(
         (delimiterClause) => delimiterClause.split(/\s+(?:and|but|or|while|although|because)\s+/gu).map((clause) => clause.trim()).filter((clause) => clause.length > 0)
       )
-    )
-  );
+    );
+    if (!inheritCoordinatedSubjects || clauses.length < 2) return clauses;
+    const firstLexemes = groundingLexemes(clauses[0]).filter(({ token }) => GROUNDING_STOPWORDS[token] !== true);
+    const firstPredicateIndex = firstLexemes.findIndex(({ isPredicate }) => isPredicate);
+    let subjectLexemes = firstLexemes.slice(0, firstPredicateIndex < 1 ? 1 : firstPredicateIndex).filter(({ token }) => !token.endsWith("ly"));
+    let subject = subjectLexemes.map(({ surface }) => surface).join(" ");
+    let predicate = firstLexemes[firstPredicateIndex < 1 ? 1 : firstPredicateIndex]?.surface;
+    if (subject.length === 0 || predicate === void 0) return clauses;
+    const sourceSpans = [clauses[0]];
+    for (const clause of clauses.slice(1)) {
+      const clauseLexemes = groundingLexemes(clause).filter(({ token }) => GROUNDING_STOPWORDS[token] !== true);
+      const clausePredicateIndex = clauseLexemes.findIndex(({ isPredicate }) => isPredicate);
+      const clauseSubjectLexemes = clausePredicateIndex > 0 ? clauseLexemes.slice(0, clausePredicateIndex).filter(({ token }) => !token.endsWith("ly")) : [];
+      const repeatsSubject = clauseSubjectLexemes.length === subjectLexemes.length && subjectLexemes.every(
+        ({ token }, index) => clauseSubjectLexemes[index]?.token === token
+      );
+      if (repeatsSubject) {
+        sourceSpans.push(clause);
+        continue;
+      }
+      if (clauseSubjectLexemes.length > 0) {
+        subjectLexemes = clauseSubjectLexemes;
+        subject = subjectLexemes.map(({ surface }) => surface).join(" ");
+        predicate = clauseLexemes[clausePredicateIndex]?.surface;
+        sourceSpans.push(clause);
+        continue;
+      }
+      const prefix = clausePredicateIndex === -1 ? `${subject} ${predicate}` : subject;
+      sourceSpans.push(clause, `${prefix} ${clause}`);
+    }
+    return sourceSpans;
+  });
 }
 var GROUNDING_STOPWORDS = {
   a: true,
@@ -103,6 +133,7 @@ var GROUNDING_STOPWORDS = {
   where: true,
   which: true,
   who: true,
+  whom: true,
   will: true,
   with: true,
   would: true,
@@ -187,36 +218,107 @@ var GROUNDING_ENTITY_TYPE_PREFIXES = /* @__PURE__ */ new Set([
   "place",
   "other"
 ]);
-var GROUNDING_COMMON_VERB_FORMS = /* @__PURE__ */ new Set([
-  "contains",
-  "employs",
-  "gives",
-  "has",
-  "hosts",
-  "likes",
-  "makes",
-  "needs",
-  "owns",
-  "prefers",
-  "requires",
-  "runs",
-  "shares",
-  "supports",
-  "takes",
-  "uses",
-  "wants",
-  "works"
-]);
+var GROUNDING_COMMON_VERB_FORMS = {
+  add: true,
+  adds: true,
+  call: true,
+  calls: true,
+  contain: true,
+  contains: true,
+  employ: true,
+  deploy: true,
+  deploys: true,
+  design: true,
+  designs: true,
+  employs: true,
+  fill: true,
+  fills: true,
+  go: true,
+  goes: true,
+  gone: true,
+  went: true,
+  give: true,
+  gives: true,
+  has: true,
+  host: true,
+  hosts: true,
+  like: true,
+  likes: true,
+  manage: true,
+  manages: true,
+  make: true,
+  makes: true,
+  need: true,
+  needs: true,
+  own: true,
+  owns: true,
+  plan: true,
+  plans: true,
+  prefer: true,
+  prefers: true,
+  require: true,
+  requires: true,
+  run: true,
+  runs: true,
+  sleep: true,
+  sleeps: true,
+  stop: true,
+  stops: true,
+  swim: true,
+  swims: true,
+  share: true,
+  shares: true,
+  support: true,
+  supports: true,
+  take: true,
+  takes: true,
+  try: true,
+  tries: true,
+  use: true,
+  uses: true,
+  want: true,
+  wants: true,
+  work: true,
+  works: true
+};
 function groundingLexemes(text) {
-  return text.normalize("NFKC").match(
+  const rawTokens = text.normalize("NFKC").match(
     /[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)?(?:\+\+[\p{L}\p{N}]*|#[\p{L}\p{N}]*)?/gu
-  )?.map((rawToken) => {
-    const token = rawToken.replaceAll("\u2019", "'").toLocaleLowerCase();
+  ) ?? [];
+  const tokens = rawTokens.map((rawToken) => rawToken.replaceAll("\u2019", "'").toLocaleLowerCase());
+  let predicateIndex = tokens.findIndex((token, index) => {
+    const previousToken = tokens[index - 1];
+    const followsAuxiliary = previousToken !== void 0 && GROUNDING_AUXILIARY_TOKENS.has(previousToken);
+    let previousMeaningfulIndex = index - 1;
+    while (previousMeaningfulIndex >= 0 && !GROUNDING_COPULAR_FORMS.has(tokens[previousMeaningfulIndex] ?? "") && (GROUNDING_STOPWORDS[tokens[previousMeaningfulIndex] ?? ""] === true || (tokens[previousMeaningfulIndex] ?? "").endsWith("ly"))) {
+      previousMeaningfulIndex -= 1;
+    }
+    const followsCopularAuxiliary = GROUNDING_COPULAR_FORMS.has(
+      tokens[previousMeaningfulIndex] ?? ""
+    );
+    const capitalized = /^\p{Lu}/u.test(rawTokens[index] ?? "");
+    const terminalSInflection = index > 0 && token.endsWith("s") && !token.endsWith("ss") && !GROUNDING_AUXILIARY_TOKENS.has(token);
+    const capitalizedSubjectHasLaterPredicate = index === 0 && tokens.some((laterToken, laterIndex) => laterIndex > 0 && !/^\p{Lu}/u.test(rawTokens[laterIndex] ?? "") && (GROUNDING_AUXILIARY_TOKENS.has(laterToken) || GROUNDING_COMMON_VERB_FORMS[laterToken] === true || laterToken.endsWith("ed") || laterToken.endsWith("ing")));
+    if (capitalized && (index !== 0 || capitalizedSubjectHasLaterPredicate)) return false;
+    if (followsCopularAuxiliary && terminalSInflection) return false;
+    return GROUNDING_COMMON_VERB_FORMS[token] === true || token.endsWith("ed") || token.endsWith("ing") || followsAuxiliary && !followsCopularAuxiliary || terminalSInflection;
+  });
+  if (predicateIndex === -1) {
+    const leadingSubjectLength = rawTokens.findIndex((rawToken) => !/^\p{Lu}/u.test(rawToken));
+    if (leadingSubjectLength > 0) {
+      predicateIndex = tokens.findIndex((token, index) => index >= leadingSubjectLength && (GROUNDING_AUXILIARY_TOKENS.has(token) || GROUNDING_STOPWORDS[token] !== true && !/^\p{Lu}/u.test(rawTokens[index] ?? "")));
+    }
+  }
+  return rawTokens.map((rawToken, index) => {
+    const token = tokens[index];
+    const isPredicate = index === predicateIndex;
     return {
       token,
-      preserveTerminalS: /^\p{Lu}/u.test(rawToken) && !GROUNDING_COMMON_VERB_FORMS.has(token)
+      surface: rawToken,
+      preserveTerminalS: !isPredicate && (/^\p{Lu}/u.test(rawToken) || token.endsWith("s")),
+      isPredicate
     };
-  }) ?? [];
+  });
 }
 function tokenSequence(text) {
   return groundingLexemes(text).map(({ token }) => token);
@@ -250,23 +352,39 @@ function isNegatedAt(tokens, index) {
 }
 var GROUNDING_MIN_SHARED_TOKENS = 2;
 var GROUNDING_MIN_COVERAGE = 0.5;
-function stemToken(token, preserveTerminalS = false) {
+var STRICT_GROUNDING_TOKEN_PREFIX = "\0";
+var INFLECTED_GROUNDING_TOKEN_PREFIX = "
";
+function stemToken(token, preserveTerminalS = false, markExact = false) {
   if (token.endsWith("'s")) return token.slice(0, -2);
-  if (preserveTerminalS) return token;
+  if (preserveTerminalS) {
+    if (!markExact) return token;
+    return `${STRICT_GROUNDING_TOKEN_PREFIX}${token}`;
+  }
   if (token.length > 5 && token.endsWith("ing")) {
     const stem = token.slice(0, -3);
-    return /(.)\1$/u.test(stem) ? stem.slice(0, -1) : stem;
+    const inflectionDoubled = /(.)\1$/u.test(stem) && stem.length > 3 && !/[lsz]$/u.test(stem);
+    const normalized = inflectionDoubled ? stem.slice(0, -1) : stem;
+    return markExact ? `${INFLECTED_GROUNDING_TOKEN_PREFIX}${normalized}` : normalized;
+  }
+  if (token.length > 4 && token.endsWith("ied")) {
+    const normalized = `${token.slice(0, -3)}y`;
+    return markExact ? `${INFLECTED_GROUNDING_TOKEN_PREFIX}${normalized}` : normalized;
+  }
+  if (token.length > 4 && token.endsWith("ed")) {
+    const stem = token.slice(0, -2);
+    const inflectionDoubled = /(.)\1$/u.test(stem) && stem.length > 3 && !/[lsz]$/u.test(stem);
+    const normalized = inflectionDoubled ? stem.slice(0, -1) : stem;
+    return markExact ? `${INFLECTED_GROUNDING_TOKEN_PREFIX}${normalized}` : normalized;
   }
-  if (token.length > 4 && token.endsWith("ed")) return token.slice(0, -2);
-  if (!preserveTerminalS && token.length > 3 && token.endsWith("s") && !token.endsWith("ss") && GROUNDING_COMMON_VERB_FORMS.has(token)) {
-    return token.slice(0, -1);
+  if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss")) {
+    return token.endsWith("ies") ? `${token.slice(0, -3)}y` : token.slice(0, -1);
   }
   return token;
 }
 function tokenize(text) {
   const tokens = /* @__PURE__ */ new Set();
   for (const { token, preserveTerminalS } of groundingLexemes(text)) {
-    if (GROUNDING_STOPWORDS[token] !== true) tokens.add(stemToken(token, preserveTerminalS));
+    if (GROUNDING_STOPWORDS[token] !== true) tokens.add(stemToken(token, preserveTerminalS, true));
   }
   return tokens;
 }
@@ -297,7 +415,7 @@ function groundingTokenSequence(text) {
   while (lexemes.length > 0 && GROUNDING_AUXILIARY_TOKENS.has(lexemes[0].token)) {
     lexemes = lexemes.slice(1);
   }
-  return lexemes.filter(({ token }) => GROUNDING_STOPWORDS[token] !== true).map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS));
+  return lexemes.filter(({ token }) => GROUNDING_STOPWORDS[token] !== true).map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS, true));
 }
 function normalizedGroundingAlignmentTokenSequence(text) {
   const normalized = normalizedGroundingTokenSequence(text);
@@ -305,13 +423,26 @@ function normalizedGroundingAlignmentTokenSequence(text) {
   if (firstLexeme === void 0 || !GROUNDING_SUBJECT_PRONOUNS.has(firstLexeme.token)) {
     return normalized;
   }
-  return [stemToken(firstLexeme.token, firstLexeme.preserveTerminalS), ...normalized];
+  return [stemToken(firstLexeme.token, firstLexeme.preserveTerminalS, true), ...normalized];
 }
 function normalizedGroundingTokenSequence(text) {
   return groundingTokenSequence(text).map((token) => token.replace(/'$/u, ""));
 }
 function areGroundingTokensCompatible(left, right) {
-  return left === right || `${left}e` === right || left === `${right}e`;
+  const leftPrefix = left[0];
+  const rightPrefix = right[0];
+  const leftMarked = leftPrefix === STRICT_GROUNDING_TOKEN_PREFIX || leftPrefix === INFLECTED_GROUNDING_TOKEN_PREFIX;
+  const rightMarked = rightPrefix === STRICT_GROUNDING_TOKEN_PREFIX || rightPrefix === INFLECTED_GROUNDING_TOKEN_PREFIX;
+  const leftToken = leftMarked ? left.slice(1) : left;
+  const rightToken = rightMarked ? right.slice(1) : right;
+  if (leftToken === rightToken) {
+    const strictToInflected = leftPrefix === STRICT_GROUNDING_TOKEN_PREFIX && rightPrefix === INFLECTED_GROUNDING_TOKEN_PREFIX || rightPrefix === STRICT_GROUNDING_TOKEN_PREFIX && leftPrefix === INFLECTED_GROUNDING_TOKEN_PREFIX;
+    return !strictToInflected;
+  }
+  if (leftPrefix === STRICT_GROUNDING_TOKEN_PREFIX || rightPrefix === STRICT_GROUNDING_TOKEN_PREFIX) {
+    return false;
+  }
+  return `${leftToken}e` === rightToken || leftToken === `${rightToken}e`;
 }
 var GROUNDING_DENIAL_REPORTING_VERBS = /* @__PURE__ */ new Set([
   "deny",
@@ -525,4 +656,4 @@ export {
   areGroundingTokensCompatible,
   hasContradictoryPolarity
 };
-//# sourceMappingURL=chunk-P2BM76KT.js.map
+//# sourceMappingURL=chunk-WAS4HV46.js.map