@remnic/core 9.3.622 → 9.3.624

package/dist/{chunk-4MHHUPNH.js → chunk-UGEBPVNI.js}

@@ -1,13 +1,13 @@
 import {
   hasCodexMaterializeSentinel,
   materializeForNamespace
-} from "./chunk-JFEKNTX7.js";
+} from "./chunk-LN4YGHTM.js";
 import {
   resolveNamespaceChildRoot
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-DXBCNDVD.js";
+} from "./chunk-PJGB7XRR.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -118,4 +118,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-4MHHUPNH.js.map
+//# sourceMappingURL=chunk-UGEBPVNI.js.map

package/dist/{chunk-4WMCPJWX.js → chunk-UQ7RN5HK.js}

@@ -9,20 +9,29 @@ function estimateTokens(text) {
 }
 function splitSentences(text) {
   const sentences = [];
-  const sentenceRegex = /[^.!?]*[.!?]+(?:\s+|$)/g;
-  let match;
-  let lastIndex = 0;
-  while ((match = sentenceRegex.exec(text)) !== null) {
-    sentences.push(match[0].trim());
-    lastIndex = sentenceRegex.lastIndex;
-  }
-  if (lastIndex < text.length) {
-    const remaining = text.slice(lastIndex).trim();
-    if (remaining) {
-      sentences.push(remaining);
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== "." && ch !== "!" && ch !== "?") continue;
+    let end = i;
+    while (end + 1 < text.length) {
+      const n = text[end + 1];
+      if (n !== "." && n !== "!" && n !== "?") break;
+      end++;
+    }
+    const after = text[end + 1];
+    if (after === void 0 || /\s/.test(after)) {
+      const sentence = text.slice(start, end + 1).trim();
+      if (sentence.length > 0) sentences.push(sentence);
+      start = end + 1;
     }
+    i = end;
+  }
+  if (start < text.length) {
+    const remaining = text.slice(start).trim();
+    if (remaining.length > 0) sentences.push(remaining);
   }
-  return sentences.filter((s) => s.length > 0);
+  return sentences;
 }
 function chunkContent(content, config = DEFAULT_CHUNKING_CONFIG) {
   const totalTokens = estimateTokens(content);
@@ -114,4 +123,4 @@ export {
   chunkContent,
   reassembleChunks
 };
-//# sourceMappingURL=chunk-4WMCPJWX.js.map
+//# sourceMappingURL=chunk-UQ7RN5HK.js.map

package/dist/chunk-UQ7RN5HK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chunking.ts"],"sourcesContent":["/**\n * Automatic Chunking with Overlap (Phase 2A)\n *\n * Sentence-boundary chunking for long memories.\n * Preserves coherent thoughts by never splitting mid-sentence.\n */\n\nexport interface ChunkingConfig {\n  /** Target tokens per chunk (default 200) */\n  targetTokens: number;\n  /** Minimum tokens to trigger chunking (default 150) */\n  minTokens: number;\n  /** Number of sentences to overlap between chunks (default 2) */\n  overlapSentences: number;\n}\n\nexport interface Chunk {\n  /** Chunk content */\n  content: string;\n  /** 0-based index */\n  index: number;\n  /** Approximate token count */\n  tokenCount: number;\n}\n\nexport interface ChunkResult {\n  /** Whether content was chunked */\n  chunked: boolean;\n  /** Array of chunks (length 1 if not chunked) */\n  chunks: Chunk[];\n}\n\n/** Default chunking configuration */\nexport const DEFAULT_CHUNKING_CONFIG: ChunkingConfig = {\n  targetTokens: 200,\n  minTokens: 150,\n  overlapSentences: 2,\n};\n\n/**\n * Estimate token count for text.\n * Rough approximation: ~4 characters per token for English.\n */\nfunction estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Split text into sentences.\n * Handles common abbreviations and edge cases.\n */\nfunction splitSentences(text: string): string[] {\n  // Split on sentence-ending punctuation (. ! ?) that is followed by whitespace\n  // or end of string; the punctuation stays with the sentence.\n  //\n  // Implemented as a single linear scan rather than a regex. Every regex form of\n  // this split is either polynomial (CodeQL js/polynomial-redos) or — once\n  // bounded/anchored to satisfy CodeQL — mishandles long runs or non-boundary\n  // punctuation (a global match silently drops a skipped prefix; a sticky match\n  // stops at the first interior `.` that is not a real boundary, e.g. \"v1.2.3\"\n  // or \"example.com\", emitting the whole document as one chunk). A character\n  // scan is O(n), allocation-free, drops nothing, and treats interior\n  // punctuation correctly. Normal prose splits identically to the previous\n  // /[^.!?]*[.!?]+(?:\\s+|$)/g form.\n  const sentences: string[] = [];\n  let start = 0;\n  for (let i = 0; i < text.length; i++) {\n    const ch = text[i];\n    if (ch !== \".\" && ch !== \"!\" && ch !== \"?\") continue;\n    // Consume a run of terminators (e.g. \"?!\", \"...\").\n    let end = i;\n    while (end + 1 < text.length) {\n      const n = text[end + 1];\n      if (n !== \".\" && n !== \"!\" && n !== \"?\") break;\n      end++;\n    }\n    const after = text[end + 1];\n    // A real boundary only if the terminator run ends the string or is followed\n    // by whitespace. Interior punctuation (no following whitespace) is left in\n    // place and the scan continues.\n    if (after === undefined || /\\s/.test(after)) {\n      const sentence = text.slice(start, end + 1).trim();\n      if (sentence.length > 0) sentences.push(sentence);\n      start = end + 1;\n    }\n    i = end;\n  }\n  // Trailing text without a closing terminator.\n  if (start < text.length) {\n    const remaining = text.slice(start).trim();\n    if (remaining.length > 0) sentences.push(remaining);\n  }\n  return sentences;\n}\n\n/**\n * Chunk content into overlapping segments at sentence boundaries.\n *\n * @param content - The text content to chunk\n * @param config - Chunking configuration\n * @returns ChunkResult with chunks array\n */\nexport function chunkContent(\n  content: string,\n  config: ChunkingConfig = DEFAULT_CHUNKING_CONFIG,\n): ChunkResult {\n  const totalTokens = estimateTokens(content);\n\n  // Don't chunk if below minimum threshold\n  if (totalTokens < config.minTokens) {\n    return {\n      chunked: false,\n      chunks: [{\n        content,\n        index: 0,\n        tokenCount: totalTokens,\n      }],\n    };\n  }\n\n  const sentences = splitSentences(content);\n\n  // If we couldn't split into multiple sentences, don't chunk\n  if (sentences.length <= 1) {\n    return {\n      chunked: false,\n      chunks: [{\n        content,\n        index: 0,\n        tokenCount: totalTokens,\n      }],\n    };\n  }\n\n  const chunks: Chunk[] = [];\n  let currentChunkSentences: string[] = [];\n  let currentTokens = 0;\n  let chunkIndex = 0;\n\n  for (let i = 0; i < sentences.length; i++) {\n    const sentence = sentences[i];\n    const sentenceTokens = estimateTokens(sentence);\n\n    // Add sentence to current chunk\n    currentChunkSentences.push(sentence);\n    currentTokens += sentenceTokens;\n\n    // Check if we've reached target size (with some flexibility)\n    // Allow going over by up to 50% to avoid tiny final chunks\n    const atTarget = currentTokens >= config.targetTokens;\n    const isLastSentence = i === sentences.length - 1;\n\n    if (atTarget || isLastSentence) {\n      // Create chunk from accumulated sentences\n      const chunkContent = currentChunkSentences.join(\" \");\n      chunks.push({\n        content: chunkContent,\n        index: chunkIndex,\n        tokenCount: estimateTokens(chunkContent),\n      });\n      chunkIndex++;\n\n      // Start new chunk with overlap (if not at end)\n      if (!isLastSentence) {\n        // Keep last N sentences for overlap.\n        // Guard: slice(-0) === slice(0), which returns the ENTIRE array\n        // (CLAUDE.md gotcha #27). When overlapSentences is 0, clear fully.\n        const overlapCount = Math.min(config.overlapSentences, currentChunkSentences.length);\n        if (overlapCount <= 0) {\n          currentChunkSentences = [];\n          currentTokens = 0;\n        } else {\n          currentChunkSentences = currentChunkSentences.slice(-overlapCount);\n          currentTokens = currentChunkSentences.reduce((sum, s) => sum + estimateTokens(s), 0);\n        }\n      }\n    }\n  }\n\n  // Only consider it \"chunked\" if we got multiple chunks\n  return {\n    chunked: chunks.length > 1,\n    chunks,\n  };\n}\n\n/**\n * Get parent content by reassembling chunks.\n * Useful for displaying full context when a chunk is retrieved.\n *\n * @param chunks - Array of chunk contents in order\n * @returns Reassembled parent content (with overlap removed)\n */\nexport function reassembleChunks(chunks: string[]): string {\n  if (chunks.length === 0) return \"\";\n  if (chunks.length === 1) return chunks[0];\n\n  // For overlapping chunks, we need to deduplicate\n  // Simple approach: use full first chunk, then non-overlapping parts of subsequent chunks\n  // This is imperfect but handles most cases\n  const result: string[] = [chunks[0]];\n\n  for (let i = 1; i < chunks.length; i++) {\n    const prevChunk = chunks[i - 1];\n    const currChunk = chunks[i];\n\n    // Find overlap by looking for common suffix/prefix\n    // Try to find where the previous chunk ends in the current chunk\n    const prevSentences = splitSentences(prevChunk);\n    const currSentences = splitSentences(currChunk);\n\n    // Find how many sentences from prev are at the start of curr\n    let overlapCount = 0;\n    for (let j = 0; j < Math.min(prevSentences.length, currSentences.length); j++) {\n      // Check if last N sentences of prev match first N sentences of curr\n      const prevEnd = prevSentences.slice(-(j + 1));\n      const currStart = currSentences.slice(0, j + 1);\n\n      if (prevEnd.join(\" \") === currStart.join(\" \")) {\n        overlapCount = j + 1;\n      }\n    }\n\n    // Add non-overlapping portion\n    if (overlapCount > 0 && overlapCount < currSentences.length) {\n      result.push(currSentences.slice(overlapCount).join(\" \"));\n    } else if (overlapCount === 0) {\n      // No detected overlap, add full chunk\n      result.push(currChunk);\n    }\n    // If overlapCount === currSentences.length, skip (fully contained)\n  }\n\n  return result.join(\" \");\n}\n"],"mappings":"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","names":["chunkContent"]}

package/dist/{chunk-ZUNNG6PC.js → chunk-W3BKVM64.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ZFXCQPNO.js";
 import {
   StorageManager
-} from "./chunk-DXBCNDVD.js";
+} from "./chunk-PJGB7XRR.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -161,4 +161,4 @@ export {
   getCategoryDir,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-ZUNNG6PC.js.map
+//# sourceMappingURL=chunk-W3BKVM64.js.map

package/dist/{chunk-K5O2QY6T.js → chunk-YTWNKQ2G.js}

@@ -7,7 +7,7 @@ import {
 
 // src/temporal-supersession.ts
 function normalizeSupersessionKey(raw) {
-  return raw.trim().toLowerCase().replace(/[\s\-]+/g, "-").replace(/^-+|-+$/g, "");
+  return raw.trim().toLowerCase().replace(/[\s\-]+/g, "-").replace(/^-|-$/g, "");
 }
 function computeSupersessionKey(entityRef, attributeName) {
   if (!entityRef || typeof entityRef !== "string") return null;
@@ -238,4 +238,4 @@ export {
   applyTemporalSupersession,
   shouldFilterSupersededFromRecall
 };
-//# sourceMappingURL=chunk-K5O2QY6T.js.map
+//# sourceMappingURL=chunk-YTWNKQ2G.js.map

package/dist/chunk-YTWNKQ2G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/temporal-supersession.ts"],"sourcesContent":["/**\n * Temporal Supersession (issue #375)\n *\n * When a new fact lands with `structuredAttributes` keyed on a known\n * `entityRef`, any prior fact whose supersession key collides with the new\n * fact's key is marked `status: \"superseded\"` and linked via\n * `supersededBy` / `supersededAt`.  Recall filters those superseded memories\n * by default so agents see only the \"current\" value per entity attribute.\n *\n * The algorithm is intentionally O(N) over the memory corpus per write, but\n * skips cheaply when the new fact has no structuredAttributes.  It reuses the\n * cached `readAllMemories()` path so cost is amortized with the rest of the\n * write pipeline.\n */\nimport type { MemoryFile, MemoryFrontmatter } from \"./types.js\";\nimport type { StorageManager } from \"./storage.js\";\nimport { log } from \"./logger.js\";\nimport { effectiveValidAt } from \"./temporal-validity.js\";\n\n/**\n * Shared normalization for supersession key components.\n *\n * Trims surrounding whitespace, lowercases, then collapses any run of\n * whitespace OR hyphens to a single hyphen, and strips any leading/trailing\n * hyphens that result.  Both `computeSupersessionKey` and\n * `lookupAttributeByNormalizedKey` must use this so that keys produced at\n * write time and keys used at lookup time are identical regardless of how\n * the LLM encoded whitespace, hyphens, or casing (Finding B fix).\n *\n * Symmetry guarantee: `\"foo bar\"`, `\"foo-bar\"`, `\"foo - bar\"`, and\n * `\"foo  bar\"` all canonicalize to `\"foo-bar\"`.\n *\n * Exported so external tests can verify the canonical form.\n */\nexport function normalizeSupersessionKey(raw: string): string {\n  return raw\n    .trim()\n    .toLowerCase()\n    .replace(/[\\s\\-]+/g, \"-\")\n    // The previous line already collapsed runs to single hyphens, so ^-|-$ is\n    // equivalent to ^-+|-+$ here and drops the anchored quantifier flagged by\n    // CodeQL js/polynomial-redos.\n    .replace(/^-|-$/g, \"\");\n}\n\n/**\n * Stable supersession key for an (entityRef, attributeName) pair.\n *\n * The algorithm is:\n *  - normalize the entityRef (trim, lower-case, collapse whitespace)\n *  - normalize the attributeName the same way\n *  - join with `::`\n *\n * Exported so tests and tools can recompute it without depending on storage.\n */\nexport function computeSupersessionKey(\n  entityRef: string | undefined,\n  attributeName: string,\n): string | null {\n  if (!entityRef || typeof entityRef !== \"string\") return null;\n  if (!attributeName || typeof attributeName !== \"string\") return null;\n  const entity = normalizeSupersessionKey(entityRef);\n  const attr = normalizeSupersessionKey(attributeName);\n  if (entity.length === 0 || attr.length === 0) return null;\n  return `${entity}::${attr}`;\n}\n\n/**\n * Compute the full set of supersession keys for a fact with structured\n * attributes.  Returns an empty array if no keys can be derived.\n */\nexport function supersessionKeysForFact(spec: {\n  entityRef?: string;\n  structuredAttributes?: Record<string, string>;\n}): string[] {\n  if (!spec.entityRef) return [];\n  if (!spec.structuredAttributes) return [];\n  const keys: string[] = [];\n  for (const attrName of Object.keys(spec.structuredAttributes)) {\n    const key = computeSupersessionKey(spec.entityRef, attrName);\n    if (key) keys.push(key);\n  }\n  return keys;\n}\n\n/**\n * Look up a structured-attribute value by a raw key, normalizing both sides\n * with `normalizeSupersessionKey` before comparing.  This ensures that keys\n * written by the LLM with mixed case, surrounding whitespace, or internal\n * whitespace (e.g. `\"City\"`, `\" city \"`, `\"job   title\"`, `\"job-title\"`)\n * are all matched against normalized keys produced by `computeSupersessionKey`\n * (Finding B fix — uses the same helper so both sides are identical).\n *\n * The storage format is NOT changed — we only normalize at lookup time.\n */\nexport function lookupAttributeByNormalizedKey(\n  attributes: Record<string, unknown>,\n  rawKey: string,\n): unknown {\n  const normalizedTarget = normalizeSupersessionKey(rawKey);\n  for (const [k, v] of Object.entries(attributes)) {\n    if (normalizeSupersessionKey(k) === normalizedTarget) return v;\n  }\n  return undefined;\n}\n\n/**\n * Decide whether an existing memory should be superseded by a newly-written\n * memory that carries the supplied supersession key set.\n *\n * Only memories that:\n *  - are currently `active`\n *  - share an `entityRef` with the new fact\n *  - share at least one supersession key with the new fact\n *  - are older than the new fact\n *  - have a conflicting value (different string) for the overlapping key\n * are eligible.  This keeps supersession local to the attribute that actually\n * changed — if fact A sets `{city: Austin, tool: vim}` and fact B sets\n * `{city: NYC}`, only the city attribute is superseded, not the tool.\n */\nexport function shouldSupersedeExisting(args: {\n  candidate: MemoryFrontmatter;\n  newEntityRef: string;\n  newAttributes: Record<string, string>;\n  newCreatedAt: string;\n  newMemoryId: string;\n}): { matchedKeys: string[] } | null {\n  const { candidate, newEntityRef, newAttributes, newCreatedAt, newMemoryId } = args;\n\n  if (candidate.id === newMemoryId) return null;\n  if (candidate.status && candidate.status !== \"active\") return null;\n  if (!candidate.entityRef) return null;\n  if (!candidate.structuredAttributes) return null;\n\n  // Reuse the shared `normalizeSupersessionKey` helper so this comparison\n  // cannot drift from the canonical form used to build supersession keys\n  // elsewhere in this file.\n  const candidateEntityNorm = normalizeSupersessionKey(candidate.entityRef);\n  const newEntityNorm = normalizeSupersessionKey(newEntityRef);\n  if (candidateEntityNorm !== newEntityNorm) return null;\n\n  // Must be older than the new fact's effective validity start — equal\n  // timestamps are ignored to avoid races within the same millisecond. When\n  // replay/import supplies source time, valid_at must drive ordering instead\n  // of wall-clock persistence time.\n  const candidateCreated = Date.parse(effectiveValidAt(candidate));\n  const newCreated = Date.parse(newCreatedAt);\n  if (!Number.isFinite(candidateCreated) || !Number.isFinite(newCreated)) return null;\n  if (candidateCreated >= newCreated) return null;\n\n  const matchedKeys: string[] = [];\n  for (const [attrName, newValue] of Object.entries(newAttributes)) {\n    // Use normalized key lookup so mixed-case or whitespace-padded keys\n    // stored by the LLM are matched correctly (Finding 2 fix).\n    const candidateValue = lookupAttributeByNormalizedKey(\n      candidate.structuredAttributes,\n      attrName,\n    );\n    if (candidateValue === undefined) continue;\n    // Only supersede on conflicting values — identical values are a no-op.\n    if (normalizeValue(String(candidateValue)) === normalizeValue(newValue)) continue;\n    const key = computeSupersessionKey(newEntityRef, attrName);\n    if (key) matchedKeys.push(key);\n  }\n\n  return matchedKeys.length > 0 ? { matchedKeys } : null;\n}\n\nfunction normalizeValue(v: string): string {\n  return v.trim().toLowerCase();\n}\n\nasync function expireChildChunksForSupersededParent(args: {\n  storage: StorageManager;\n  allCandidates: MemoryFile[];\n  parentId: string;\n  newMemoryId: string;\n  supersededAt: string;\n  invalidAt?: string;\n}): Promise<void> {\n  const processedChunkIds = new Set<string>();\n  const chunks = args.allCandidates.filter(\n    (candidate) => candidate.frontmatter.parentId === args.parentId,\n  );\n\n  for (const chunk of chunks) {\n    const chunkKey = chunk.frontmatter.id ?? chunk.path;\n    if (processedChunkIds.has(chunkKey)) continue;\n\n    try {\n      const freshChunk = await args.storage.readMemoryByPath(chunk.path);\n      if (!freshChunk) continue;\n      processedChunkIds.add(chunkKey);\n      const freshStatus = freshChunk.frontmatter.status ?? \"active\";\n      if (freshStatus !== \"active\" || freshChunk.frontmatter.supersededBy) continue;\n\n      await args.storage.writeMemoryFrontmatter(\n        freshChunk,\n        {\n          status: \"superseded\",\n          supersededBy: args.newMemoryId,\n          supersededAt: args.supersededAt,\n          updated: args.supersededAt,\n          ...(args.invalidAt && !freshChunk.frontmatter.invalid_at\n            ? { invalid_at: args.invalidAt }\n            : {}),\n        },\n        {\n          actor: \"temporal-supersession\",\n          reasonCode: \"structured-attribute-update-child-chunk\",\n          relatedMemoryIds: [args.newMemoryId, args.parentId],\n        },\n      );\n    } catch (err) {\n      log.warn(\n        `temporal-supersession: failed to expire child chunk ${chunk.frontmatter.id} for parent ${args.parentId}: ${err}`,\n      );\n    }\n  }\n}\n\nexport interface TemporalSupersessionResult {\n  supersededIds: string[];\n  matchedKeys: string[];\n}\n\n/**\n * Scan existing memories and mark any that are superseded by the\n * just-written memory.  Fails open on I/O errors — the new memory is already\n * on disk, and supersession is a best-effort hygiene step.\n */\nexport async function applyTemporalSupersession(args: {\n  storage: StorageManager;\n  newMemoryId: string;\n  entityRef?: string;\n  structuredAttributes?: Record<string, string>;\n  createdAt: string;\n  enabled: boolean;\n  /**\n   * When true, skip the persisted `frontmatter.created` lookup and use\n   * `args.createdAt` directly as the ordering anchor.  Set this on the\n   * hash-dedup short-circuit path where `newMemoryId` points to an existing\n   * OLD fact (no new file is written) and its persisted timestamp would be\n   * stale relative to the incoming promotion event (PR #402 Finding Uyui).\n   */\n  useCallerTimestamp?: boolean;\n}): Promise<TemporalSupersessionResult> {\n  const empty: TemporalSupersessionResult = { supersededIds: [], matchedKeys: [] };\n  if (!args.enabled) return empty;\n  if (!args.entityRef) return empty;\n  if (!args.structuredAttributes) return empty;\n  if (Object.keys(args.structuredAttributes).length === 0) return empty;\n\n  const newKeys = supersessionKeysForFact({\n    entityRef: args.entityRef,\n    structuredAttributes: args.structuredAttributes,\n  });\n  if (newKeys.length === 0) return empty;\n\n  let hotMemories: MemoryFile[];\n  try {\n    hotMemories = await args.storage.readAllMemories();\n  } catch (err) {\n    log.warn(`temporal-supersession: readAllMemories failed: ${err}`);\n    return empty;\n  }\n\n  // Finding 1 fix: use the on-disk effective validity start of the\n  // newly-written memory rather than a wall-clock timestamp sampled after\n  // `writeMemory` returns.  In concurrent writers the two can differ by enough\n  // to cause wrong-direction supersession.  If source replay/import provided\n  // valid_at, it must drive ordering; otherwise created remains the legacy\n  // fallback.  If the memory is not yet visible in the cache (edge case during\n  // fast concurrent writes) fall back to args.createdAt.\n  //\n  // PR #402 round-12 (Finding Uyui): on the hash-dedup early-return path the\n  // caller supplies the OLD matching fact's id as `newMemoryId` (no new file is\n  // written).  That makes `newMemoryFile.frontmatter.created` an arbitrarily\n  // old timestamp.  When `args.useCallerTimestamp` is set the caller explicitly\n  // opts out of the persisted-timestamp lookup so `args.createdAt` (the\n  // incoming event time: source valid_at when present, otherwise wall-clock) is\n  // used directly, keeping ordering correct regardless of how old the matching\n  // fact is.\n  const newMemoryFile = hotMemories.find((m) => m.frontmatter.id === args.newMemoryId);\n  const persistedCreatedAt = args.useCallerTimestamp\n    ? args.createdAt\n    : (newMemoryFile ? effectiveValidAt(newMemoryFile.frontmatter) : args.createdAt);\n\n  const supersededIds: string[] = [];\n  const matchedKeys = new Set<string>();\n\n  // Process hot then cold.  Hot-then-cold ordering is safer because hot\n  // writes are more frequent and the CAS re-read guards against double-writes.\n  // A Set<string> of already-processed ids ensures that a memory visible in\n  // both tiers (same logical memory with different filesystem paths during a\n  // migration race) is processed at most once.  Keying on `frontmatter.id`\n  // is correct because the same logical memory has the same id regardless of\n  // which tier's directory it currently lives in (PR #402 Finding 1 fix).\n  // Fall back to path-based keying when id is absent (defensive).\n  const processedIds = new Set<string>();\n\n  // Finding UOGi fix (round-6): readAllColdMemories() performs a full uncached\n  // recursive directory scan of cold/.  After Finding UTsP broadened the scan\n  // to cover the entire cold root (not just facts/+corrections/), the per-call\n  // cost grows with the cold tree size.\n  //\n  // The fix is a TTL-based in-memory cache inside StorageManager\n  // (readAllColdMemories caches its result for COLD_SCAN_CACHE_TTL_MS) that is\n  // shared across consecutive supersession calls within the same write burst.\n  // The cache is invalidated automatically on any hot→cold demotion (which\n  // calls invalidateAllMemoriesCache, which also clears the cold cache) and\n  // expires after the TTL as a safety net.\n  //\n  // This means back-to-back structured-attribute writes in the same burst\n  // (e.g. batch extraction) pay the cold I/O cost at most once, not N times.\n  // Correctness is preserved because the cache TTL ensures eventual consistency\n  // and the invalidation hook covers the hot→cold path.\n\n  let coldMemories: MemoryFile[];\n  try {\n    coldMemories = await args.storage.readAllColdMemories();\n  } catch (err) {\n    log.warn(`temporal-supersession: readAllColdMemories failed: ${err}`);\n    coldMemories = [];\n  }\n\n  // Combine hot and cold memories into a single scan.  New memory itself is\n  // excluded inline.  We do NOT skip cold scan when hot produced zero\n  // supersessions — the P1 finding is precisely that stale cold facts leak\n  // when hot has no hits.\n  const allCandidates: MemoryFile[] = [...hotMemories, ...coldMemories];\n\n  for (const memory of allCandidates) {\n    if (memory.frontmatter.id === args.newMemoryId) continue;\n    const dedupeKey = memory.frontmatter.id ?? memory.path;\n    if (processedIds.has(dedupeKey)) continue;\n    const snapshotStatus = memory.frontmatter.status ?? \"active\";\n    if (snapshotStatus !== \"active\") {\n      // A stale non-active snapshot entry must not suppress an active copy of\n      // the same logical memory that appears later in another tier.  This can\n      // happen during hot/cold migration races where the hot snapshot is already\n      // superseded but the cold copy is still active and should be evaluated.\n      continue;\n    }\n    // NOTE: do NOT call processedIds.add(dedupeKey) here.  We defer marking\n    // the id as processed until AFTER the CAS re-read succeeds.  If we mark\n    // it here and the re-read fails (e.g. the hot entry has already been\n    // migrated to cold storage), the same logical id that appears later in\n    // the cold tier scan would be silently skipped, leaving a stale cold\n    // fact unsuperseded.  Deferring ensures that a failed primary-tier read\n    // grants the alternate tier a chance to process the same id (PR #402\n    // round-6 Finding 1 fix).\n\n    const decision = shouldSupersedeExisting({\n      candidate: memory.frontmatter,\n      newEntityRef: args.entityRef,\n      newAttributes: args.structuredAttributes,\n      newCreatedAt: persistedCreatedAt,\n      newMemoryId: args.newMemoryId,\n    });\n    if (!decision) {\n      // No supersession decision — safe to mark as processed now so the\n      // alternate tier doesn't re-evaluate an identical non-matching entry.\n      processedIds.add(dedupeKey);\n      continue;\n    }\n\n    try {\n      // CAS-style re-read immediately before the write.  `readAllMemories()`\n      // is a snapshot — with concurrent writers, another run may have already\n      // superseded this candidate since we loaded it.  If we blindly trust the\n      // snapshot we can clobber a newer `supersededBy` link with a stale one.\n      //\n      // File storage offers no true locking, so the best we can do is:\n      //   1. re-read the exact file we're about to mutate\n      //   2. verify status is still \"active\" and no `supersededBy` is set\n      //   3. only then issue the write\n      // If the re-read shows a newer concurrent writer beat us to it, skip.\n      // This CAS pattern applies equally to hot and cold tier candidates.\n      // Mark as processed AFTER confirming the candidate is readable so that\n      // a migration-race read failure on the hot entry does not silently\n      // prevent the cold entry from being evaluated (Finding 1, round 6).\n      const fresh = await args.storage.readMemoryByPath(memory.path);\n      if (!fresh) {\n        log.debug(\n          `[engram] temporal supersession skipped candidate ${memory.frontmatter.id}: no longer readable at ${memory.path} — leaving id available for alternate tier`,\n        );\n        // Do NOT add to processedIds — allow the cold-tier copy to be\n        // evaluated in the next iteration of the same scan.\n        continue;\n      }\n      // Candidate is readable — mark the id as processed now to prevent the\n      // alternate tier from double-writing.\n      processedIds.add(dedupeKey);\n      const freshStatus = fresh.frontmatter.status ?? \"active\";\n      if (freshStatus !== \"active\" || fresh.frontmatter.supersededBy) {\n        log.debug(\n          `[engram] temporal supersession skipped candidate ${memory.frontmatter.id}: already superseded by concurrent writer`,\n        );\n        continue;\n      }\n\n      // Finding 2 fix: the `supersededAt` / `updated` timestamps written to the\n      // old fact must never run backwards relative to its own persisted\n      // `created` timestamp.  If the caller-supplied `args.createdAt` (which\n      // represents \"when the new replacing fact was authored\") is earlier than\n      // either the new fact's persisted `created` (T_new) or the old fact's\n      // persisted `created` (T_old), we'd be writing a nonsensical\n      // `supersededAt` that precedes the old memory's own creation.  Clamp to\n      // the monotonic maximum so time only moves forward.\n      // This monotonic clamp is applied for both hot and cold tier writes.\n      const oldCreatedMs = new Date(fresh.frontmatter.created).getTime();\n      const newCreatedMs = new Date(persistedCreatedAt).getTime();\n      const argCreatedMs = new Date(args.createdAt).getTime();\n      const maxMs = Math.max(\n        Number.isFinite(oldCreatedMs) ? oldCreatedMs : 0,\n        Number.isFinite(newCreatedMs) ? newCreatedMs : 0,\n        Number.isFinite(argCreatedMs) ? argCreatedMs : 0,\n      );\n      const supersededAt = new Date(maxMs).toISOString();\n\n      // Issue #680 — explicit fact lifecycle.  When the new fact\n      // supersedes this one, set the predecessor's `invalid_at` to the\n      // successor's effective valid_at.  Skip when the predecessor\n      // already carries an `invalid_at` so manual / earlier values\n      // are preserved (idempotent).\n      //\n      // Codex P1 on PR #713: in the hash-dedup early-return path\n      // (`useCallerTimestamp: true`), `newMemoryFile` is actually the\n      // OLD matching fact — no new file was written — so its\n      // `valid_at` is the predecessor's own old timestamp, not the\n      // successor's effective time. Use `persistedCreatedAt`\n      // directly in that path so the predecessor's invalid_at lines\n      // up with the caller's wall-clock, not the matching fact's old\n      // valid_at. The non-dedup path keeps the previous behavior\n      // (prefer the new file's explicit valid_at, fall back to its\n      // persisted created).\n      let invalidAtPatch: string | undefined;\n      if (!fresh.frontmatter.invalid_at) {\n        if (args.useCallerTimestamp) {\n          invalidAtPatch = persistedCreatedAt;\n        } else {\n          const newValidAt = newMemoryFile?.frontmatter.valid_at?.trim();\n          invalidAtPatch =\n            newValidAt && newValidAt.length > 0 ? newValidAt : persistedCreatedAt;\n        }\n      }\n      const wrote = await args.storage.writeMemoryFrontmatter(\n        fresh,\n        {\n          status: \"superseded\",\n          supersededBy: args.newMemoryId,\n          supersededAt,\n          updated: supersededAt,\n          ...(invalidAtPatch ? { invalid_at: invalidAtPatch } : {}),\n        },\n        {\n          actor: \"temporal-supersession\",\n          reasonCode: \"structured-attribute-update\",\n          relatedMemoryIds: [args.newMemoryId],\n        },\n      );\n      if (wrote) {\n        supersededIds.push(memory.frontmatter.id);\n        for (const key of decision.matchedKeys) matchedKeys.add(key);\n        await expireChildChunksForSupersededParent({\n          storage: args.storage,\n          allCandidates,\n          parentId: fresh.frontmatter.id,\n          newMemoryId: args.newMemoryId,\n          supersededAt,\n          invalidAt: invalidAtPatch ?? fresh.frontmatter.invalid_at,\n        });\n      }\n    } catch (err) {\n      log.warn(\n        `temporal-supersession: failed to mark ${memory.frontmatter.id} superseded: ${err}`,\n      );\n    }\n  }\n\n  if (supersededIds.length > 0) {\n    log.debug(\n      `temporal-supersession: marked ${supersededIds.length} memories superseded by ${args.newMemoryId} (keys=${Array.from(matchedKeys).join(\",\")})`,\n    );\n  }\n\n  return { supersededIds, matchedKeys: Array.from(matchedKeys) };\n}\n\n/**\n * Recall-side filter: returns true when the candidate should be excluded\n * from recall because it has been temporally superseded.  When\n * `includeInRecall` is true, this always returns false (the fact is kept),\n * matching the audit/history opt-in described in the config.\n */\nexport function shouldFilterSupersededFromRecall(\n  frontmatter: MemoryFrontmatter,\n  options: { enabled: boolean; includeInRecall: boolean },\n): boolean {\n  if (!options.enabled) return false;\n  if (options.includeInRecall) return false;\n  return frontmatter.status === \"superseded\";\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-2SGJY2UY.js → chunk-Z3CCEP6F.js}

@@ -1,9 +1,9 @@
 import {
   gatewayTaskChainOptions
-} from "./chunk-DEVUWMME.js";
+} from "./chunk-KGIGRNR6.js";
 import {
   extractJsonCandidates
-} from "./chunk-UZB5KHKX.js";
+} from "./chunk-RGMVMVMF.js";
 import {
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
@@ -486,4 +486,4 @@ export {
   createVerdictCache,
   createDeferCountMap
 };
-//# sourceMappingURL=chunk-2SGJY2UY.js.map
+//# sourceMappingURL=chunk-Z3CCEP6F.js.map

package/dist/{chunk-UCGCSZP2.js → chunk-ZZPIJPPD.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-DXBCNDVD.js";
+} from "./chunk-PJGB7XRR.js";
 
 // src/semantic-rule-promotion.ts
 import { createHash, randomUUID } from "crypto";
@@ -529,4 +529,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-UCGCSZP2.js.map
+//# sourceMappingURL=chunk-ZZPIJPPD.js.map

package/dist/chunking.js

@@ -2,7 +2,7 @@ import {
   DEFAULT_CHUNKING_CONFIG,
   chunkContent,
   reassembleChunks
-} from "./chunk-4WMCPJWX.js";
+} from "./chunk-UQ7RN5HK.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_CHUNKING_CONFIG,

package/dist/cli.js

@@ -89,7 +89,7 @@ import {
   runWorkProductStatusCliCommand,
   runWorkProjectCliCommand,
   runWorkTaskCliCommand
-} from "./chunk-VNR3K2R3.js";
+} from "./chunk-7TPH6UZL.js";
 import "./chunk-MC4FJXPA.js";
 import "./chunk-LQHDIS7L.js";
 import "./chunk-7F7Z6MOS.js";
@@ -111,18 +111,18 @@ import "./chunk-PYIFUBRK.js";
 import "./chunk-WMWVO45V.js";
 import "./chunk-D6RIFG4O.js";
 import "./chunk-JCK7V6SN.js";
-import "./chunk-GA3PMY73.js";
-import "./chunk-LMZ7XQBB.js";
+import "./chunk-O4UNM6OR.js";
+import "./chunk-GLWW3EJQ.js";
 import "./chunk-KJTKLXTH.js";
 import "./chunk-H2NCNXMS.js";
 import "./chunk-PU44GBL4.js";
 import "./chunk-YR6GIWWY.js";
-import "./chunk-UCGCSZP2.js";
+import "./chunk-ZZPIJPPD.js";
 import "./chunk-FH3PPO42.js";
 import "./chunk-3QSU4NFF.js";
 import "./chunk-TGQ2NTWH.js";
-import "./chunk-3GM7ZY6H.js";
-import "./chunk-AVHPSLQ2.js";
+import "./chunk-FMGWXIES.js";
+import "./chunk-AYHXQR53.js";
 import "./chunk-3T74IZB3.js";
 import "./chunk-HL4DB7TO.js";
 import "./chunk-YNDLCWXS.js";
@@ -135,9 +135,9 @@ import "./chunk-2PRQG7PV.js";
 import "./chunk-X6IRLNOO.js";
 import "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
-import "./chunk-CCNZM5UM.js";
+import "./chunk-R3OQGYOU.js";
 import "./chunk-W4RVMTHR.js";
-import "./chunk-YPNGPHNZ.js";
+import "./chunk-2UFQYU5F.js";
 import "./chunk-ZRWB5D4H.js";
 import "./chunk-A6D7A2FW.js";
 import "./chunk-FF4KLI5W.js";
@@ -152,7 +152,7 @@ import "./chunk-CYEPCZN5.js";
 import "./chunk-DCGT4FPP.js";
 import "./chunk-Q4CAQGKQ.js";
 import "./chunk-CINZGPSJ.js";
-import "./chunk-ZUNNG6PC.js";
+import "./chunk-W3BKVM64.js";
 import "./chunk-ZFXCQPNO.js";
 import "./chunk-Q6YIJGXJ.js";
 import "./chunk-ORFGK3XI.js";
@@ -175,7 +175,7 @@ import "./chunk-3ONXXHQO.js";
 import "./chunk-LMDRGRJ2.js";
 import "./chunk-OKTXM5H4.js";
 import "./chunk-3UXOZBHV.js";
-import "./chunk-4WMCPJWX.js";
+import "./chunk-UQ7RN5HK.js";
 import "./chunk-5GOMXHLC.js";
 import "./chunk-PHK3HARR.js";
 import "./chunk-Z5LAYHGJ.js";
@@ -183,7 +183,7 @@ import "./chunk-LBJBNWS2.js";
 import "./chunk-HQ6NIBL6.js";
 import "./chunk-PVGDJXVK.js";
 import "./chunk-OADWQ5CR.js";
-import "./chunk-4NS2ELXF.js";
+import "./chunk-FG76RDVI.js";
 import "./chunk-SEDEKFYQ.js";
 import "./chunk-2QSZNTDO.js";
 import "./chunk-RSUYKGGZ.js";
@@ -191,10 +191,10 @@ import "./chunk-42NQ7AVG.js";
 import "./chunk-TMSXWOBZ.js";
 import "./chunk-J64TK33U.js";
 import "./chunk-7RXCMVFQ.js";
-import "./chunk-XQUIHXNI.js";
+import "./chunk-I6UCUHLK.js";
 import "./chunk-6L46YAEZ.js";
 import "./chunk-D24OXEPB.js";
-import "./chunk-EOLCAPOU.js";
+import "./chunk-KQFQ3IS5.js";
 import "./chunk-GDASG7NC.js";
 import "./chunk-GDB4J2H3.js";
 import "./chunk-DGNQRNLL.js";
@@ -202,7 +202,7 @@ import "./chunk-PSUB67YB.js";
 import "./chunk-SOBJ6NEY.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-H7XKCNR6.js";
-import "./chunk-2GRRN7SZ.js";
+import "./chunk-GYTVOLNX.js";
 import "./chunk-EDQVAMQI.js";
 import "./chunk-JGSKJHF7.js";
 import "./chunk-BPSGLMQ4.js";
@@ -215,15 +215,15 @@ import "./chunk-EI6V5UXY.js";
 import "./chunk-QY7YA7OL.js";
 import "./chunk-NNVTUXEB.js";
 import "./chunk-QDW3E4RD.js";
-import "./chunk-IMA6GU4Y.js";
+import "./chunk-H3PHZLMF.js";
 import "./chunk-ODPLEWB6.js";
 import "./chunk-XL7FK7PJ.js";
 import "./chunk-2LSZVONP.js";
 import "./chunk-DEUNUKTD.js";
-import "./chunk-4G2RQTAE.js";
-import "./chunk-DXBCNDVD.js";
+import "./chunk-OZXVGYGZ.js";
+import "./chunk-PJGB7XRR.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-4H5ZJHEN.js";
+import "./chunk-J6A3CX5N.js";
 import "./chunk-4R4KTDIE.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
@@ -231,7 +231,7 @@ import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-CPPS65WS.js";
 import "./chunk-DM2T26WE.js";
-import "./chunk-QSVPYQPG.js";
+import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-ALEPI75L.js";

package/dist/compounding/engine.js

@@ -1,11 +1,11 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "../chunk-UK727RHF.js";
+} from "../chunk-2L54V4ZO.js";
 import "../chunk-DRD2Q7HQ.js";
-import "../chunk-DXBCNDVD.js";
+import "../chunk-PJGB7XRR.js";
 import "../chunk-5UZXUTVO.js";
-import "../chunk-4H5ZJHEN.js";
+import "../chunk-J6A3CX5N.js";
 import "../chunk-4R4KTDIE.js";
 import "../chunk-RULE4VG5.js";
 import "../chunk-SCU65EZI.js";
@@ -13,7 +13,7 @@ import "../chunk-MB5RSUW6.js";
 import "../chunk-6KYMPV2O.js";
 import "../chunk-CPPS65WS.js";
 import "../chunk-DM2T26WE.js";
-import "../chunk-QSVPYQPG.js";
+import "../chunk-LDXUBPMO.js";
 import "../chunk-FVQJYWH7.js";
 import "../chunk-G7D6GZ5J.js";
 import "../chunk-ALEPI75L.js";

package/dist/connectors/codex-materialize-runner.js

@@ -1,12 +1,12 @@
 import {
   runCodexMaterialize,
   runPostConsolidationMaterialize
-} from "../chunk-4MHHUPNH.js";
-import "../chunk-JFEKNTX7.js";
+} from "../chunk-UGEBPVNI.js";
+import "../chunk-LN4YGHTM.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-DXBCNDVD.js";
+import "../chunk-PJGB7XRR.js";
 import "../chunk-5UZXUTVO.js";
-import "../chunk-4H5ZJHEN.js";
+import "../chunk-J6A3CX5N.js";
 import "../chunk-4R4KTDIE.js";
 import "../chunk-RULE4VG5.js";
 import "../chunk-SCU65EZI.js";
@@ -14,7 +14,7 @@ import "../chunk-MB5RSUW6.js";
 import "../chunk-6KYMPV2O.js";
 import "../chunk-CPPS65WS.js";
 import "../chunk-DM2T26WE.js";
-import "../chunk-QSVPYQPG.js";
+import "../chunk-LDXUBPMO.js";
 import "../chunk-FVQJYWH7.js";
 import "../chunk-G7D6GZ5J.js";
 import "../chunk-ALEPI75L.js";

package/dist/connectors/codex-materialize.js

@@ -14,7 +14,7 @@ import {
   resolveCodexMemoriesDir,
   truncateToTokenBudget,
   validateMemoryMd
-} from "../chunk-JFEKNTX7.js";
+} from "../chunk-LN4YGHTM.js";
 import "../chunk-EYIEWJNI.js";
 import "../chunk-JUC24CTX.js";
 import "../chunk-2ODBA7MQ.js";

package/dist/connectors/index.js

@@ -27,7 +27,7 @@ import {
 import "../chunk-G56P5RLD.js";
 import {
   runCodexMaterialize
-} from "../chunk-4MHHUPNH.js";
+} from "../chunk-UGEBPVNI.js";
 import {
   MATERIALIZE_VERSION,
   SENTINEL_FILE,
@@ -42,15 +42,15 @@ import {
   renderRolloutSummary,
   truncateToTokenBudget,
   validateMemoryMd
-} from "../chunk-JFEKNTX7.js";
+} from "../chunk-LN4YGHTM.js";
 import "../chunk-3UXOZBHV.js";
 import {
   coerceInstallExtension
 } from "../chunk-PHK3HARR.js";
 import "../chunk-NNVTUXEB.js";
-import "../chunk-DXBCNDVD.js";
+import "../chunk-PJGB7XRR.js";
 import "../chunk-5UZXUTVO.js";
-import "../chunk-4H5ZJHEN.js";
+import "../chunk-J6A3CX5N.js";
 import "../chunk-4R4KTDIE.js";
 import "../chunk-RULE4VG5.js";
 import "../chunk-SCU65EZI.js";
@@ -58,7 +58,7 @@ import "../chunk-MB5RSUW6.js";
 import "../chunk-6KYMPV2O.js";
 import "../chunk-CPPS65WS.js";
 import "../chunk-DM2T26WE.js";
-import "../chunk-QSVPYQPG.js";
+import "../chunk-LDXUBPMO.js";
 import "../chunk-FVQJYWH7.js";
 import "../chunk-G7D6GZ5J.js";
 import "../chunk-ALEPI75L.js";

package/dist/contradiction/index.js

@@ -6,7 +6,7 @@ import {
   judgeContradictionPairs,
   runContradictionScan,
   verdictCacheSize
-} from "../chunk-6GMPIJAZ.js";
+} from "../chunk-C3IW2F5Z.js";
 import {
   executeResolution,
   isValidResolutionVerb
@@ -20,7 +20,7 @@ import {
   writePair,
   writePairs
 } from "../chunk-35NN3ZFA.js";
-import "../chunk-UZB5KHKX.js";
+import "../chunk-RGMVMVMF.js";
 import "../chunk-2ODBA7MQ.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/{contradiction-scan-GD7KUFWS.js → contradiction-scan-AZTGFMPY.js}

@@ -1,13 +1,13 @@
 import {
   ACTIVE_STATUSES,
   runContradictionScan
-} from "./chunk-6GMPIJAZ.js";
+} from "./chunk-C3IW2F5Z.js";
 import "./chunk-35NN3ZFA.js";
-import "./chunk-UZB5KHKX.js";
+import "./chunk-RGMVMVMF.js";
 import "./chunk-2ODBA7MQ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   ACTIVE_STATUSES,
   runContradictionScan
 };
-//# sourceMappingURL=contradiction-scan-GD7KUFWS.js.map
+//# sourceMappingURL=contradiction-scan-AZTGFMPY.js.map

package/dist/entity-retrieval.js

@@ -3,11 +3,11 @@ import {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-LANHQ7EN.js";
+} from "./chunk-BNW5NJJH.js";
 import "./chunk-BEUDU7Y4.js";
-import "./chunk-DXBCNDVD.js";
+import "./chunk-PJGB7XRR.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-4H5ZJHEN.js";
+import "./chunk-J6A3CX5N.js";
 import "./chunk-4R4KTDIE.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
@@ -15,7 +15,7 @@ import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-CPPS65WS.js";
 import "./chunk-DM2T26WE.js";
-import "./chunk-QSVPYQPG.js";
+import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-ALEPI75L.js";

package/dist/explicit-capture.js

@@ -7,7 +7,7 @@ import {
   shouldSkipImplicitExtraction,
   stripInlineExplicitCaptureNotes,
   validateExplicitCaptureInput
-} from "./chunk-IMA6GU4Y.js";
+} from "./chunk-H3PHZLMF.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-U3PN77QT.js";
 import "./chunk-PZ5AY32C.js";

package/dist/extraction-judge.js

@@ -9,12 +9,12 @@ import {
   normalizeCachedVerdict,
   validateProcedureExtraction,
   verdictCacheSize
-} from "./chunk-2SGJY2UY.js";
-import "./chunk-DEVUWMME.js";
+} from "./chunk-Z3CCEP6F.js";
+import "./chunk-KGIGRNR6.js";
 import "./chunk-B5XMS73R.js";
 import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
-import "./chunk-UZB5KHKX.js";
+import "./chunk-RGMVMVMF.js";
 import "./chunk-RK6F44Y6.js";
 import "./chunk-QDW3E4RD.js";
 import "./chunk-EYIEWJNI.js";

package/dist/extraction.js

@@ -1,6 +1,6 @@
 import {
   ExtractionEngine
-} from "./chunk-WB3LYXC5.js";
+} from "./chunk-MON3LMO7.js";
 import "./chunk-4RA3C3EV.js";
 import "./chunk-ROZJACKP.js";
 import "./chunk-54V4BZWP.js";
@@ -9,11 +9,11 @@ import "./chunk-77NAFXUD.js";
 import "./chunk-WLEB7WCG.js";
 import "./chunk-VEWZZM3H.js";
 import "./chunk-JLNBQWZ2.js";
-import "./chunk-DEVUWMME.js";
+import "./chunk-KGIGRNR6.js";
 import "./chunk-B5XMS73R.js";
 import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
-import "./chunk-UZB5KHKX.js";
+import "./chunk-RGMVMVMF.js";
 import "./chunk-RK6F44Y6.js";
 import "./chunk-EI6V5UXY.js";
 import "./chunk-QY7YA7OL.js";

package/dist/fallback-llm.js

@@ -2,11 +2,11 @@ import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
-} from "./chunk-DEVUWMME.js";
+} from "./chunk-KGIGRNR6.js";
 import "./chunk-B5XMS73R.js";
 import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
-import "./chunk-UZB5KHKX.js";
+import "./chunk-RGMVMVMF.js";
 import "./chunk-RK6F44Y6.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";

package/dist/identity-continuity.js

@@ -6,7 +6,7 @@ import {
   reviewContinuityLoopInMarkdown,
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
-} from "./chunk-QSVPYQPG.js";
+} from "./chunk-LDXUBPMO.js";
 import "./chunk-PZ5AY32C.js";
 export {
   closeContinuityIncidentRecord,