@remnic/core 9.51.0 → 9.52.0

package/dist/chunk-5WITETWU.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, MemoryLifecycleEvent } from \"./types.js\";\n\nimport { createHash } from \"node:crypto\";\nimport { log } from \"./logger.js\";\nimport { effectiveValidAt } from \"./temporal-validity.js\";\nimport type {\n  DependencyPropagationDeliveryPort,\n  DependencyPropagationPreparationToken,\n} from \"./orchestration/dependency-propagation-delivery.js\";\nimport type { PropagationEvent } from \"./orchestration/dependency-propagation.js\";\nexport interface TemporalSupersessionStorage {\n  readAllMemories(): Promise<MemoryFile[]>;\n  readAllColdMemories(): Promise<MemoryFile[]>;\n  readMemoryByPath(memoryPath: string): Promise<MemoryFile | null>;\n  writeMemoryFrontmatterIfUnchanged?: (\n    memory: MemoryFile,\n    patch: Partial<MemoryFrontmatter>,\n    lifecycle?: {\n      actor?: string;\n      reasonCode?: string;\n      relatedMemoryIds?: string[];\n      correlationId?: string;\n    },\n  ) => Promise<boolean>;\n  appendTombstone(input: {\n    reason: \"supersession\";\n    createdBy: \"supersession\";\n    sourceMemoryId: string;\n    rawContent: string;\n    entityRef?: string;\n    supersessionKey?: string;\n    createdAt?: string;\n    contentHash?: string;\n    operationKey?: string;\n  }): Promise<string | null>;\n  hasExactTombstone?: (input: {\n    sourceMemoryId: string;\n    contentHash?: string;\n    entityRef?: string;\n    supersessionKey?: string;\n    createdAt?: string;\n    operationKey?: string;\n  }) => Promise<boolean>;\n  getMemoryTimeline: (memoryId: string, limit?: number) => Promise<MemoryLifecycleEvent[]>;\n  isTombstonesEnabled?: () => boolean;\n}\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}\nfunction temporalSupersessionOperationKey(\n  sourceMemoryId: string,\n  replacementId: string,\n  mutation: TemporalSupersessionMutation,\n): string {\n  return createHash(\"sha256\")\n    .update(\n      JSON.stringify({\n        sourceMemoryId,\n        replacementId,\n        cause: \"temporal_supersession\",\n        supersededAt: mutation.supersededAt,\n        invalidAt: mutation.invalidAt ?? null,\n        matchedKeys: [...mutation.matchedKeys].sort(compareByteStable),\n      }),\n    )\n    .digest(\"hex\");\n}\ntype TemporalMemorySnapshot = Pick<MemoryFile, \"content\" | \"frontmatter\">;\nfunction compareByteStable(left: string, right: string): number {\n  return Buffer.from(left, \"utf8\").compare(Buffer.from(right, \"utf8\"));\n}\n\nfunction canonicalTemporalValue(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map((entry) => canonicalTemporalValue(entry));\n  if (value && typeof value === \"object\") {\n    return Object.fromEntries(\n      Object.entries(value as Record<string, unknown>)\n        .sort(([left], [right]) => compareByteStable(left, right))\n        .map(([key, entry]) => [key, canonicalTemporalValue(entry)]),\n    );\n  }\n  return value;\n}\n\nfunction temporalSnapshotKey(memory: TemporalMemorySnapshot): string {\n  return JSON.stringify(\n    canonicalTemporalValue({\n      content: memory.content,\n      frontmatter: memory.frontmatter,\n    }),\n  );\n}\n\nfunction temporalMutationPatch(\n  replacementId: string,\n  mutation: TemporalSupersessionMutation,\n): Partial<MemoryFrontmatter> {\n  return {\n    status: \"superseded\",\n    supersededBy: replacementId,\n    supersededAt: mutation.supersededAt,\n    updated: mutation.supersededAt,\n    ...(mutation.invalidAt ? { invalid_at: mutation.invalidAt } : {}),\n  };\n}\n\ntype TemporalPrimaryCommitState = \"committed\" | \"not-committed\" | \"unknown\";\n\nasync function classifyTemporalPrimaryMutation(args: {\n  storage: TemporalSupersessionStorage;\n  path: string;\n  before: TemporalMemorySnapshot;\n  patch: Partial<MemoryFrontmatter>;\n}): Promise<TemporalPrimaryCommitState> {\n  let current: MemoryFile | null;\n  try {\n    current = await args.storage.readMemoryByPath(args.path);\n  } catch {\n    return \"unknown\";\n  }\n  if (!current) return \"unknown\";\n  const beforeKey = temporalSnapshotKey(args.before);\n  const committedKey = temporalSnapshotKey({\n    content: args.before.content,\n    frontmatter: { ...args.before.frontmatter, ...args.patch },\n  });\n  const currentKey = temporalSnapshotKey(current);\n  if (currentKey === committedKey) return \"committed\";\n  if (currentKey === beforeKey) return \"not-committed\";\n  return \"unknown\";\n}\ntype PreparedTemporalPropagation = {\n  delivery: DependencyPropagationDeliveryPort;\n  event: PropagationEvent;\n  token: DependencyPropagationPreparationToken | null;\n};\n\nasync function settleTemporalPropagationAfterPrimaryFailure(\n  pending: PreparedTemporalPropagation,\n  commitState: TemporalPrimaryCommitState,\n  memoryId: string,\n): Promise<void> {\n  let token = pending.token;\n  if (commitState === \"not-committed\") {\n    if (token !== null) {\n      try {\n        await pending.delivery.cancel(token);\n      } catch (error) {\n        log.warn(\n          `temporal-supersession: dependency propagation cancellation failed for ${memoryId}: ${error}`,\n        );\n      }\n    }\n    return;\n  }\n  if (token === null && (commitState === \"committed\" || commitState === \"unknown\")) {\n    try {\n      token = await pending.delivery.prepare(pending.event);\n    } catch (error) {\n      log.warn(\n        `temporal-supersession: dependency propagation recovery preparation failed for ${memoryId}: ${error}`,\n      );\n    }\n  }\n  if (token !== null) {\n    try {\n      await pending.delivery.deferPrepared(token);\n    } catch (error) {\n      log.warn(`temporal-supersession: dependency propagation defer failed for ${memoryId}: ${error}`);\n    }\n    return;\n  }\n  if (commitState === \"committed\") {\n    try {\n      await pending.delivery.afterMutation(null, pending.event);\n    } catch (error) {\n      log.warn(`temporal-supersession: dependency propagation fallback failed for ${memoryId}: ${error}`);\n    }\n  }\n}\n\n\nasync function hasTemporalLifecycleEffect(args: {\n  storage: TemporalSupersessionStorage;\n  memoryId: string;\n  timestamp: string;\n  operationKey: string;\n  reasonCode: string;\n  relatedMemoryIds: string[];\n}): Promise<boolean> {\n  const events = await args.storage.getMemoryTimeline(args.memoryId, 200);\n  return events.some((event) => {\n    if (\n      event.memoryId !== args.memoryId ||\n      (event.eventType !== \"superseded\" && event.eventType !== \"updated\") ||\n      event.timestamp !== args.timestamp ||\n      event.after?.status !== \"superseded\"\n    ) {\n      return false;\n    }\n    if (event.correlationId !== undefined) return event.correlationId === args.operationKey;\n    // Rows written before correlation IDs existed can be replayed only with\n    // their complete legacy identity. New rows always take the exact branch.\n    return (\n      event.reasonCode === args.reasonCode &&\n      Array.isArray(event.relatedMemoryIds) &&\n      event.relatedMemoryIds.length === args.relatedMemoryIds.length &&\n      event.relatedMemoryIds.every((memoryId, index) => memoryId === args.relatedMemoryIds[index])\n    );\n  });\n}\n\nasync function hasTemporalTombstoneEffect(args: {\n  storage: TemporalSupersessionStorage;\n  oldMemory: MemoryFile;\n  supersessionKey?: string;\n  operationKey: string;\n  createdAt: string;\n}): Promise<boolean> {\n  if (!args.storage.hasExactTombstone) return false;\n  return args.storage.hasExactTombstone({\n    sourceMemoryId: args.oldMemory.frontmatter.id,\n    ...(args.oldMemory.frontmatter.contentHash\n      ? { contentHash: args.oldMemory.frontmatter.contentHash }\n      : {}),\n    ...(args.oldMemory.frontmatter.entityRef\n      ? { entityRef: args.oldMemory.frontmatter.entityRef }\n      : {}),\n    ...(args.supersessionKey ? { supersessionKey: args.supersessionKey } : {}),\n    createdAt: args.createdAt,\n    operationKey: args.operationKey,\n  });\n}\n\n\nasync function ensureTemporalLifecycleEffect(args: {\n  storage: TemporalSupersessionStorage;\n  memory: MemoryFile;\n  replacementId: string;\n  mutation: TemporalSupersessionMutation;\n  operationKey: string;\n  child?: boolean;\n}): Promise<boolean> {\n  const reasonCode = args.child\n    ? \"structured-attribute-update-child-chunk\"\n    : \"structured-attribute-update\";\n  const relatedMemoryIds = args.child\n    ? [args.replacementId, args.memory.frontmatter.parentId ?? \"\"].filter(Boolean)\n    : [args.replacementId];\n  const lifecycleEffect = await hasTemporalLifecycleEffect({\n    storage: args.storage,\n    memoryId: args.memory.frontmatter.id,\n    timestamp: args.mutation.supersededAt,\n    operationKey: args.operationKey,\n    reasonCode,\n    relatedMemoryIds,\n  });\n  if (lifecycleEffect === undefined) return false;\n  if (lifecycleEffect === true) return true;\n  if (lifecycleEffect === false || args.memory.frontmatter.status !== \"superseded\") {\n    if (!args.storage.writeMemoryFrontmatterIfUnchanged) return false;\n    const wrote = await args.storage.writeMemoryFrontmatterIfUnchanged(\n      args.memory,\n      {\n        status: \"superseded\",\n        supersededBy: args.replacementId,\n        supersededAt: args.mutation.supersededAt,\n        updated: args.mutation.supersededAt,\n        ...(args.mutation.invalidAt && !args.memory.frontmatter.invalid_at\n          ? { invalid_at: args.mutation.invalidAt }\n          : {}),\n      },\n      {\n        actor: \"temporal-supersession\",\n        reasonCode: args.child\n          ? \"structured-attribute-update-child-chunk\"\n          : \"structured-attribute-update\",\n        relatedMemoryIds: args.child\n          ? [args.replacementId, args.memory.frontmatter.parentId ?? \"\"].filter(Boolean)\n          : [args.replacementId],\n        correlationId: args.operationKey,\n      },\n    );\n    return wrote;\n  }\n  return true;\n}\n\nasync function expireChildChunksForSupersededParent(args: {\n  storage: TemporalSupersessionStorage;\n  allCandidates: MemoryFile[];\n  parentId: string;\n  newMemoryId: string;\n  supersededAt: string;\n  invalidAt?: string;\n  operationKey: string;\n}): Promise<boolean> {\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 (\n        freshStatus !== \"active\" &&\n        !(\n          freshStatus === \"superseded\" &&\n          freshChunk.frontmatter.supersededBy === args.newMemoryId\n        )\n      ) {\n        continue;\n      }\n      const completed = await ensureTemporalLifecycleEffect({\n        storage: args.storage,\n        memory: freshChunk,\n        replacementId: args.newMemoryId,\n        mutation: {\n          supersededAt: args.supersededAt,\n          ...(args.invalidAt ? { invalidAt: args.invalidAt } : {}),\n          matchedKeys: [],\n        },\n        operationKey: `${args.operationKey}:child:${freshChunk.frontmatter.id}`,\n        child: true,\n      });\n      if (!completed) return false;\n    } catch (err) {\n      log.warn(\n        `temporal-supersession: failed to expire child chunk ${chunk.frontmatter.id} for parent ${args.parentId}: ${err}`,\n      );\n      return false;\n    }\n  }\n  return true;\n}\n\nexport interface TemporalSupersessionMutation {\n  supersededAt: string;\n  invalidAt?: string;\n  matchedKeys: string[];\n}\n\nexport async function applyTemporalSupersessionPrimaryMutation(args: {\n  storage: TemporalSupersessionStorage;\n  oldMemory: MemoryFile;\n  replacementId: string;\n  mutation: TemporalSupersessionMutation;\n  allCandidates?: MemoryFile[];\n}): Promise<boolean> {\n  const { storage, oldMemory, replacementId, mutation } = args;\n  if (typeof storage.getMemoryTimeline !== \"function\") {\n    log.warn(\"temporal-supersession: required memory timeline adapter is missing\");\n    return false;\n  }\n  const operationKey = temporalSupersessionOperationKey(\n    oldMemory.frontmatter.id,\n    replacementId,\n    mutation,\n  );\n  const alreadyApplied =\n    oldMemory.frontmatter.status === \"superseded\" &&\n    oldMemory.frontmatter.supersededBy === replacementId &&\n    oldMemory.frontmatter.supersededAt === mutation.supersededAt &&\n    (mutation.invalidAt === undefined || oldMemory.frontmatter.invalid_at === mutation.invalidAt);\n  const lifecycleEffect = alreadyApplied\n    ? await hasTemporalLifecycleEffect({\n        storage,\n        memoryId: oldMemory.frontmatter.id,\n        timestamp: mutation.supersededAt,\n        operationKey,\n        reasonCode: \"structured-attribute-update\",\n        relatedMemoryIds: [replacementId],\n      })\n    : undefined;\n  if (alreadyApplied && lifecycleEffect === undefined) return false;\n  if (!alreadyApplied || lifecycleEffect === false) {\n    if (!storage.writeMemoryFrontmatterIfUnchanged) return false;\n    const wrote = await storage.writeMemoryFrontmatterIfUnchanged(\n      oldMemory,\n      temporalMutationPatch(replacementId, mutation),\n      {\n        actor: \"temporal-supersession\",\n        reasonCode: \"structured-attribute-update\",\n        relatedMemoryIds: [replacementId],\n        correlationId: operationKey,\n      },\n    );\n    if (!wrote) return false;\n  }\n\n  let allCandidates = args.allCandidates;\n  if (!allCandidates) {\n    let hotMemories: MemoryFile[];\n    let coldMemories: MemoryFile[];\n    try {\n      hotMemories = await storage.readAllMemories();\n    } catch (error) {\n      log.warn(`temporal-supersession: recovery hot-memory scan failed: ${error}`);\n      return false;\n    }\n    try {\n      coldMemories = await storage.readAllColdMemories();\n    } catch (error) {\n      log.warn(`temporal-supersession: recovery cold-memory scan failed: ${error}`);\n      return false;\n    }\n    allCandidates = [...hotMemories, ...coldMemories];\n  }\n  const childrenCompleted = await expireChildChunksForSupersededParent({\n    storage,\n    allCandidates,\n    parentId: oldMemory.frontmatter.id,\n    newMemoryId: replacementId,\n    supersededAt: mutation.supersededAt,\n    invalidAt: mutation.invalidAt ?? oldMemory.frontmatter.invalid_at,\n    operationKey,\n  });\n  if (!childrenCompleted) return false;\n\n  const keysToTombstone =\n    mutation.matchedKeys.length > 0 ? mutation.matchedKeys : [undefined];\n  for (const key of keysToTombstone) {\n    const tombstoneOperationKey = `${operationKey}:tombstone:${key ?? \"content\"}`;\n    if (\n      await hasTemporalTombstoneEffect({\n        storage,\n        oldMemory,\n        supersessionKey: key,\n        operationKey: tombstoneOperationKey,\n        createdAt: mutation.supersededAt,\n      })\n    ) {\n      continue;\n    }\n    try {\n      const tombstoneId = await storage.appendTombstone({\n        reason: \"supersession\",\n        createdBy: \"supersession\",\n        sourceMemoryId: oldMemory.frontmatter.id,\n        ...(oldMemory.frontmatter.contentHash\n          ? { contentHash: oldMemory.frontmatter.contentHash }\n          : {}),\n        rawContent: oldMemory.content,\n        ...(oldMemory.frontmatter.entityRef ? { entityRef: oldMemory.frontmatter.entityRef } : {}),\n        ...(key ? { supersessionKey: key } : {}),\n        createdAt: mutation.supersededAt,\n        operationKey: tombstoneOperationKey,\n      });\n      if (tombstoneId === null && storage.isTombstonesEnabled?.() !== false) {\n        return false;\n      }\n    } catch (error) {\n      log.warn(\n        `temporal-supersession: tombstone emit failed for ${oldMemory.frontmatter.id}${key ? ` (key=${key})` : \"\"} : ${error}`,\n      );\n      return false;\n    }\n  }\n  return true;\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: TemporalSupersessionStorage;\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  /** Namespace used by the dependency propagation worker. */\n  namespaceScope?: string;\n  /** Optional durable delivery for one-hop propagation. */\n  dependencyPropagationDelivery?: DependencyPropagationDeliveryPort;\n}): Promise<TemporalSupersessionResult> {\n  const empty: TemporalSupersessionResult = { supersededIds: [], matchedKeys: [] };\n  const createdAtMs = typeof args.createdAt === \"string\" ? Date.parse(args.createdAt) : Number.NaN;\n  if (!Number.isFinite(createdAtMs)) {\n    log.warn(`temporal-supersession: refusing mutation with invalid createdAt: ${String(args.createdAt)}`);\n    return empty;\n  }\n  // Validate the caller's ordering anchor before any corpus scan or durable\n  // side-effect preparation.  A malformed timestamp must be a true no-op:\n  // otherwise a later monotonic clamp could manufacture a 1970 mutation and\n  // leave a prepared propagation job without a replayable temporal identity.\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  if (typeof args.storage.getMemoryTimeline !== \"function\") {\n    log.warn(\"temporal-supersession: required memory timeline adapter is missing\");\n    return empty;\n  }\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  // Resolve the replacement from the combined hot and cold snapshot. A\n  // hash-dedup promotion can point at a cold-only memory, and replay needs its\n  // captured content rather than a null replacement payload.\n  const replacementMemory =\n    allCandidates.find((memory) => memory.frontmatter.id === args.newMemoryId) ?? newMemoryFile;\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    let preparedPropagation: {\n      delivery: DependencyPropagationDeliveryPort;\n      event: PropagationEvent;\n      token: DependencyPropagationPreparationToken | null;\n    } | null = null;\n    let primaryPath: string | null = null;\n    let primaryBefore: TemporalMemorySnapshot | null = null;\n    let primaryPatch: Partial<MemoryFrontmatter> | null = null;\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      primaryPath = fresh.path;\n      primaryBefore = {\n        content: fresh.content,\n        frontmatter: { ...fresh.frontmatter },\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 = replacementMemory?.frontmatter.valid_at?.trim();\n          invalidAtPatch =\n            newValidAt && newValidAt.length > 0 ? newValidAt : persistedCreatedAt;\n        }\n      }\n      const mutation: TemporalSupersessionMutation = {\n        supersededAt,\n        ...(invalidAtPatch ? { invalidAt: invalidAtPatch } : {}),\n        matchedKeys: decision.matchedKeys,\n      };\n      primaryPatch = temporalMutationPatch(args.newMemoryId, mutation);\n      const propagationEvent: PropagationEvent | null =\n        args.dependencyPropagationDelivery && args.namespaceScope\n          ? {\n              oldMemory: {\n                content: fresh.content,\n                frontmatter: {\n                  ...fresh.frontmatter,\n                  ...(fresh.frontmatter.links\n                    ? { links: fresh.frontmatter.links.map((link) => ({ ...link })) }\n                    : {}),\n                },\n              },\n              replacementId: args.newMemoryId,\n              replacementContent: replacementMemory?.content ?? null,\n              cause: \"temporal_supersession\",\n              namespaceScope: args.namespaceScope,\n              temporalMutation: mutation,\n            }\n          : null;\n      if (propagationEvent && args.dependencyPropagationDelivery) {\n        preparedPropagation = {\n          delivery: args.dependencyPropagationDelivery,\n          event: propagationEvent,\n          token: null,\n        };\n        try {\n          preparedPropagation.token =\n            await args.dependencyPropagationDelivery.prepare(propagationEvent);\n        } catch (prepareErr) {\n          log.warn(\n            `temporal-supersession: dependency propagation preparation failed for ${fresh.frontmatter.id}: ${prepareErr}`,\n          );\n        }\n      }\n      const wrote = await applyTemporalSupersessionPrimaryMutation({\n        storage: args.storage,\n        oldMemory: fresh,\n        replacementId: args.newMemoryId,\n        mutation,\n        allCandidates,\n      });\n      if (!wrote) {\n        const commitState = await classifyTemporalPrimaryMutation({\n          storage: args.storage,\n          path: fresh.path,\n          before: primaryBefore,\n          patch: primaryPatch,\n        });\n        if (preparedPropagation) {\n          await settleTemporalPropagationAfterPrimaryFailure(\n            preparedPropagation,\n            commitState,\n            fresh.frontmatter.id,\n          );\n          if (commitState !== \"not-committed\") {\n            log.warn(\n              `temporal-supersession: retaining dependency propagation recovery for ${fresh.frontmatter.id} after ${commitState} primary mutation`,\n            );\n          }\n        }\n        preparedPropagation = null;\n        continue;\n      }\n      if (preparedPropagation) {\n        const completedPropagation = preparedPropagation;\n        preparedPropagation = null;\n        try {\n          await completedPropagation.delivery.afterMutation(\n            completedPropagation.token,\n            completedPropagation.event,\n          );\n        } catch (afterMutationErr) {\n          log.warn(\n            `temporal-supersession: dependency propagation delivery failed for ${memory.frontmatter.id}: ${afterMutationErr}`,\n          );\n        }\n      }\n      supersededIds.push(memory.frontmatter.id);\n      for (const key of decision.matchedKeys) matchedKeys.add(key);\n    } catch (err) {\n      let commitState: TemporalPrimaryCommitState = \"unknown\";\n      if (primaryPath && primaryBefore && primaryPatch) {\n        commitState = await classifyTemporalPrimaryMutation({\n          storage: args.storage,\n          path: primaryPath,\n          before: primaryBefore,\n          patch: primaryPatch,\n        });\n      }\n      if (preparedPropagation) {\n        await settleTemporalPropagationAfterPrimaryFailure(\n          preparedPropagation,\n          commitState,\n          memory.frontmatter.id,\n        );\n        if (commitState !== \"not-committed\") {\n          log.warn(\n            `temporal-supersession: retaining dependency propagation recovery for ${memory.frontmatter.id} after ${commitState} primary mutation`,\n          );\n        }\n      }\n      preparedPropagation = null;\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-UT5BV5OG.js → chunk-7HXZJAID.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-66SE3BNH.js";
 import {
   StorageManager
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1283,4 +1283,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-UT5BV5OG.js.map
+//# sourceMappingURL=chunk-7HXZJAID.js.map

package/dist/{chunk-M7BXDKPR.js → chunk-7M6NYQWB.js}

@@ -28,10 +28,10 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-J5LLX6IL.js";
+} from "./chunk-BF6SXNQJ.js";
 import {
   validateBriefingFormat
-} from "./chunk-52UKFTUK.js";
+} from "./chunk-F4EU6VUC.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-M7BXDKPR.js.map
+//# sourceMappingURL=chunk-7M6NYQWB.js.map

package/dist/{chunk-TPTECFWR.js → chunk-B6LZ4IBH.js}

@@ -1,12 +1,12 @@
 import {
   StorageManager
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-KMAP7SNQ.js";
 import {
   requestEntityCanonicalIdReconcile
-} from "./chunk-M4A44LUA.js";
+} from "./chunk-GSTIBXBW.js";
 import {
   decideLifecycleTransition
 } from "./chunk-TBBDFYXW.js";
@@ -759,4 +759,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-TPTECFWR.js.map
+//# sourceMappingURL=chunk-B6LZ4IBH.js.map

package/dist/{chunk-J5LLX6IL.js → chunk-BF6SXNQJ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-ZQOCRIGA.js";
+} from "./chunk-QYN5PXDZ.js";
 import {
   WriteQuarantineStore
 } from "./chunk-PJSK6OJM.js";
@@ -45,7 +45,7 @@ import {
 } from "./chunk-QHFV6VNU.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-JYL3BVVZ.js";
+} from "./chunk-JSEJH2YQ.js";
 import {
   ReplicaDivergenceMonitor
 } from "./chunk-CVILPI77.js";
@@ -84,7 +84,7 @@ import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
-} from "./chunk-37ZO6LLJ.js";
+} from "./chunk-RYLEDKQ2.js";
 import {
   lcmEvidenceIdentity
 } from "./chunk-C37ZRXX7.js";
@@ -95,11 +95,11 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-TPTECFWR.js";
+} from "./chunk-B6LZ4IBH.js";
 import {
   CorpusWatermarkCache,
   computeServiceCorpusCensus
-} from "./chunk-NLK2VZYZ.js";
+} from "./chunk-VXCNQYTC.js";
 import {
   namespaceCollectionName
 } from "./chunk-VMMQDEN5.js";
@@ -120,14 +120,14 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-52UKFTUK.js";
+} from "./chunk-F4EU6VUC.js";
 import {
   parseEntityFile,
   parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
@@ -153,10 +153,10 @@ import {
 } from "./chunk-R3DJVOSM.js";
 import {
   createVersion
-} from "./chunk-OQAL6SIR.js";
+} from "./chunk-ZMSZVISA.js";
 import {
   supersessionKeysForFact
-} from "./chunk-EWMTOVMY.js";
+} from "./chunk-5WITETWU.js";
 import {
   ExtractionDeadlineError,
   isActivityDigestPath,
@@ -13523,4 +13523,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-J5LLX6IL.js.map
+//# sourceMappingURL=chunk-BF6SXNQJ.js.map

package/dist/{chunk-4PC4PRJE.js → chunk-BKIFTXHR.js}

@@ -1,7 +1,7 @@
 import {
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-WQM326GS.js";
+} from "./chunk-2LY6GIIE.js";
 import {
   getConfiguredNamespaces
 } from "./chunk-YN6ASZUG.js";
@@ -2204,4 +2204,4 @@ export {
   runNamespaceMaintenancePlan,
   runNamespaceMaintenanceBatchPlan
 };
-//# sourceMappingURL=chunk-4PC4PRJE.js.map
+//# sourceMappingURL=chunk-BKIFTXHR.js.map

package/dist/{chunk-VVG2BOKA.js → chunk-BMEYMKWX.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-JLNBQWZ2.js";
 import {
   runPostConsolidationMaterialize
-} from "./chunk-PUSLMZBQ.js";
+} from "./chunk-NOEMGE56.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-VVG2BOKA.js.map
+//# sourceMappingURL=chunk-BMEYMKWX.js.map

package/dist/{chunk-DCZBSE4F.js → chunk-D5YOZ66N.js}

@@ -54,7 +54,7 @@ import {
 } from "./chunk-IIFFC3RL.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-UEVLYVNW.js";
+} from "./chunk-YXKVLYXU.js";
 import {
   rebuildObservations
 } from "./chunk-DQTCGVFK.js";
@@ -80,16 +80,16 @@ import {
 } from "./chunk-6FC3IZ26.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-FXTYIA46.js";
+} from "./chunk-J272WKX2.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-4F6X3RXW.js";
+} from "./chunk-X57M2Q4I.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-QGR6OVGT.js";
+} from "./chunk-VFSAWRMZ.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
@@ -127,7 +127,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-6MTSFX7A.js";
+} from "./chunk-X7XEDOSL.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -152,7 +152,7 @@ import {
 } from "./chunk-6GUG4YNM.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-AZ2QBGYB.js";
+} from "./chunk-W7Y5JDVB.js";
 import {
   rescoreMemoryImportance
 } from "./chunk-JXS5PDQ7.js";
@@ -169,7 +169,7 @@ import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-AIUBBHSF.js";
+} from "./chunk-5UZ6UCOZ.js";
 import {
   getCueAnchorStoreStatus
 } from "./chunk-ACPCA4NO.js";
@@ -200,7 +200,7 @@ import {
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-XADV5IZ3.js";
+} from "./chunk-HDIUYMSB.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -213,13 +213,13 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-C5QLI33R.js";
+} from "./chunk-QINJITDS.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-DJUKBGAD.js";
 import {
   EngramAccessService
-} from "./chunk-J5LLX6IL.js";
+} from "./chunk-BF6SXNQJ.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -239,7 +239,7 @@ import {
 } from "./chunk-QT2FRYI4.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-JYL3BVVZ.js";
+} from "./chunk-JSEJH2YQ.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-HTP6XRUI.js";
@@ -248,15 +248,15 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-TPTECFWR.js";
+} from "./chunk-B6LZ4IBH.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-PA45XCUD.js";
+} from "./chunk-RANKJI5T.js";
 import {
   resolveNamespaceChildRoot
-} from "./chunk-PUSLMZBQ.js";
+} from "./chunk-NOEMGE56.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-AHZOMHWN.js";
@@ -265,7 +265,7 @@ import {
 } from "./chunk-BIJAWZYW.js";
 import {
   meetingIdDate
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   isValidTranscriptDate
 } from "./chunk-UHVXE24Y.js";
@@ -4025,7 +4025,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const idArg = typeof args[0] === "string" ? args[0] : "";
         const options = args[1] ?? {};
         const reason = typeof options.reason === "string" && options.reason.trim().length > 0 ? options.reason.trim() : void 0;
-        const { forgetMemory } = await import("./forget-UJDJHG6R.js");
+        const { forgetMemory } = await import("./forget-HDS4N6CG.js");
         try {
           const result = await forgetMemory(orchestrator.storage, {
             id: idArg,
@@ -4591,7 +4591,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
             );
           }
         }
-        const { mergeCapsule } = await import("./capsule-merge-XMFBXVDP.js");
+        const { mergeCapsule } = await import("./capsule-merge-HCJJMLPS.js");
         const result = await mergeCapsule({
           sourceArchive,
           targetRoot: memoryDir,
@@ -7989,4 +7989,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-DCZBSE4F.js.map
+//# sourceMappingURL=chunk-D5YOZ66N.js.map

package/dist/{chunk-BHXYAVUM.js → chunk-DLG5V6ND.js}

@@ -2,7 +2,7 @@ import {
   pathMayCarryEntityRefs,
   requestEntityCanonicalIdReconcile,
   withRawEntityPageMutation
-} from "./chunk-M4A44LUA.js";
+} from "./chunk-GSTIBXBW.js";
 import {
   bumpArchiveMutationForPath
 } from "./chunk-W5BIQOAJ.js";
@@ -1377,4 +1377,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-BHXYAVUM.js.map
+//# sourceMappingURL=chunk-DLG5V6ND.js.map

package/dist/{chunk-52UKFTUK.js → chunk-F4EU6VUC.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -958,4 +958,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-52UKFTUK.js.map
+//# sourceMappingURL=chunk-F4EU6VUC.js.map

package/dist/{chunk-M4A44LUA.js → chunk-GSTIBXBW.js}

@@ -1,6 +1,6 @@
 import {
   normalizeSupersessionKey
-} from "./chunk-EWMTOVMY.js";
+} from "./chunk-5WITETWU.js";
 import {
   invalidateForScope
 } from "./chunk-XMMESCPD.js";
@@ -383,4 +383,4 @@ export {
   repairContentAfterJournalMove,
   repairContentAfterJournalMoveSync
 };
-//# sourceMappingURL=chunk-M4A44LUA.js.map
+//# sourceMappingURL=chunk-GSTIBXBW.js.map

package/dist/{chunk-W5XVQFLM.js → chunk-GXFSQ6SD.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-AIUBBHSF.js";
+} from "./chunk-5UZ6UCOZ.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-W5XVQFLM.js.map
+//# sourceMappingURL=chunk-GXFSQ6SD.js.map

package/dist/{chunk-XADV5IZ3.js → chunk-HDIUYMSB.js}

@@ -21,10 +21,10 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-C5QLI33R.js";
+} from "./chunk-QINJITDS.js";
 import {
   RelayMissionStoreError
-} from "./chunk-33SV3E43.js";
+} from "./chunk-3OY7KXHM.js";
 import {
   validateRequest
 } from "./chunk-NIS256NW.js";
@@ -50,12 +50,12 @@ import {
 import {
   authorizationProbeNamespaces,
   probeOperationAuthorization
-} from "./chunk-45BRYON6.js";
+} from "./chunk-QPOHMO6M.js";
 import {
   CorrectionContractError,
   getOperation,
   resolveQueryNamespaceWritablePreflight
-} from "./chunk-J5LLX6IL.js";
+} from "./chunk-BF6SXNQJ.js";
 import {
   isTrustZoneName
 } from "./chunk-KQS72GCR.js";
@@ -3263,4 +3263,4 @@ export {
   MeetingsInputError,
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-XADV5IZ3.js.map
+//# sourceMappingURL=chunk-HDIUYMSB.js.map

package/dist/{chunk-FXTYIA46.js → chunk-J272WKX2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B7RWBZXW.js";
 import {
   StorageManager
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -109,4 +109,4 @@ export {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-FXTYIA46.js.map
+//# sourceMappingURL=chunk-J272WKX2.js.map

package/dist/{chunk-ENTCVTQR.js → chunk-JJRVPWFY.js}

@@ -46,6 +46,7 @@ function parseTombstoneLine(line) {
     createdAt: e.createdAt,
     createdBy: e.createdBy
   };
+  if (typeof e.operationKey === "string") out.operationKey = e.operationKey;
   if (typeof e.entityRef === "string") out.entityRef = e.entityRef;
   if (typeof e.supersessionKey === "string") out.supersessionKey = e.supersessionKey;
   if (typeof e.revokes === "string") out.revokes = e.revokes;
@@ -238,6 +239,7 @@ var TombstoneStore = class {
       normalizedText: this.options.normalizeText(input.rawContent),
       ...input.entityRef ? { entityRef: input.entityRef } : {},
       ...input.supersessionKey ? { supersessionKey: input.supersessionKey } : {},
+      ...input.operationKey ? { operationKey: input.operationKey } : {},
       namespace: this.namespace,
       createdAt,
       createdBy: input.createdBy
@@ -379,6 +381,14 @@ var TombstoneStore = class {
     }
     return null;
   }
+  async hasExactEntry(input) {
+    if (!this.options.enabled) return false;
+    await this.ensureFreshAgainstDisk();
+    await this.load();
+    return this.entries.some(
+      (entry) => entry.kind === "tombstone" && !this.revokedIds.has(entry.id) && entry.namespace === this.namespace && entry.sourceMemoryId === input.sourceMemoryId && (input.contentHash === void 0 || entry.contentHash === input.contentHash) && (input.entityRef === void 0 || entry.entityRef === input.entityRef) && (input.supersessionKey === void 0 || entry.supersessionKey === input.supersessionKey) && (input.createdAt === void 0 || entry.createdAt === input.createdAt) && (input.operationKey === void 0 || entry.operationKey === input.operationKey)
+    );
+  }
   /** Aggregate stats for the doctor / x-ray surfaces. */
   stats() {
     let active = 0;
@@ -520,4 +530,4 @@ export {
   applyTombstoneResurrectionGate,
   buildRetiredFactTombstoneInputs
 };
-//# sourceMappingURL=chunk-ENTCVTQR.js.map
+//# sourceMappingURL=chunk-JJRVPWFY.js.map