@remnic/core 9.62.0 → 9.62.2

package/dist/chunk-46WM6JX2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lifecycle/tombstones.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// lifecycle/tombstones.ts — Tombstone store + non-resurrection invariant\n// (issue #1579)\n//\n// A \"tombstone\" records that a fact has been retired (corrected, superseded,\n// or retracted) so that the SAME fact cannot silently come back to life through\n// any of the five resurrection paths:\n//\n//   1. Re-extraction (session replay, re-observation)\n//   2. Importers (capsule / import-* payloads)\n//   3. Consolidation merges\n//   4. Dreams (REM re-derivation)\n//   5. Pattern reinforcement (duplicate promotion)\n//\n// The invariant is enforced at the SINGLE storage persist path\n// (`StorageManager.writeMemory` — the same chokepoint that records catalog\n// writes, issue #1522). Every write path funnels through it, so paths (a)–(e)\n// are blocked WITHOUT per-path code.\n//\n// File-first / rebuildable (the repo's storage philosophy): the JSONL at\n// `<stateDir>/tombstones.jsonl` is a cache of truth. The authoritative sources\n// are the memory files themselves (status: superseded/retracted) and the\n// `corrections/` records. `rebuildTombstonesFromStorage` reconstructs the\n// JSONL from those sources.\n//\n// Design rules honored (issue #1579 design section):\n//   - Hash `rawContent` exactly as the dedup index does — one helper\n//     (`ContentHashIndex.computeHash` / `normalizeContent`), never a second\n//     (checklist §13; rule 23).\n//   - Append-only log — never rewrite history; a later `kind: \"revocation\"`\n//     entry re-allows (rule 25).\n//   - Instance-scoped, never module-level (rule 11).\n//   - Namespace-scoped — a tombstone in namespace A never blocks namespace B\n//     (rule 42).\n//   - Serialized appends with rejection recovery (rule 40).\n//   - Never silent drop — a blocked write lands as pending_review + blockedBy\n//     (rule 34).\n//   - Do NOT register a blocked fact as an active dedup/index entry (rule 44).\n//   - Off = pre-feature behavior for rollback safety (rule 30).\n//   - Semantic tier (4) ships dark, off by default (rule 48).\n// ---------------------------------------------------------------------------\n\nimport { serializeMutations, withHeldFileLock } from \"../utils/serialize-mutations.js\";\nimport {\n  computeLegacyContentHash,\n  isUnambiguousLegacyContentHash,\n  normalizeLegacyContent,\n} from \"../content-hash.js\";\n\n/** Why a tombstone was emitted. */\nexport type TombstoneReason =\n  | \"correction\"\n  | \"supersession\"\n  | \"retraction\"\n  | \"contradiction_resolution\";\n\n/** Who emitted the tombstone. */\nexport type TombstoneCreatedBy =\n  | \"user_correction\"\n  | \"contradiction_resolution\"\n  | \"supersession\"\n  | \"chat\";\n\n/** Tier that matched on lookup. */\nexport type TombstoneMatchTier = \"exact\" | \"normalized\" | \"keyed\" | \"semantic\";\n\n/**\n * A single append-only tombstone log entry.\n *\n * `kind: \"tombstone\"` blocks; `kind: \"revocation\"` re-allows. The log is\n * never rewritten — the NEWEST matching entry wins at lookup (rule 25).\n */\nexport interface TombstoneEntry {\n  /** Stable tombstone id (`tomb-<ts>-<rand>`). */\n  id: string;\n  kind: \"tombstone\" | \"revocation\";\n  reason: TombstoneReason;\n  /** The memory that was retired. */\n  sourceMemoryId: string;\n  /** sha256 of the retired identity; explicit contentHashSource may define it. */\n  contentHash: string;\n  /** Current body hash retained alongside an ambiguous or explicit primary hash. */\n  currentContentHashAlias?: string;\n  /** Current normalized body used by the normalized lookup tier. */\n  normalizedText: string;\n  /** Version of the current body identity fields. */\n  normalizerVersion?: number;\n  entityRef?: string;\n  /** Structured-attribute supersession key when one existed. */\n  supersessionKey?: string;\n  /** Stable operation identity for crash-recovery replay. */\n  operationKey?: string;\n  /** Namespace scope (rule 42). */\n  namespace: string;\n  createdAt: string;\n  createdBy: TombstoneCreatedBy;\n  /** For `kind: \"revocation\"`: the tombstone id being revoked. */\n  revokes?: string;\n}\n\n/** A positive block decision returned by `TombstoneStore.lookup`. */\nexport interface TombstoneMatch {\n  tombstoneId: string;\n  matchedTier: TombstoneMatchTier;\n  reason: TombstoneReason;\n}\n\n/** Inputs to a lookup. At least one discriminator must be present.\n *\n * Issue #1579 thread Ociag/Oci-W: `supersessionKeys` (plural) lets the write\n * chokepoint check EVERY derived key, not just the first. Emitters register\n * one tombstone per matched key (temporal-supersession, rebuild), so a block\n * can live on any later key; querying only `supersessionKeys[0]` missed it\n * and the retired fact resurrected as active. `supersessionKey` (singular)\n * remains for direct/unit callers; `lookup` checks the union of both. */\nexport interface TombstoneLookupQuery {\n  contentHash?: string;\n  normalizedText?: string;\n  entityRef?: string;\n  /** Single supersession key (direct/unit callers). */\n  supersessionKey?: string;\n  /** All derived supersession keys (write chokepoint). The keyed tier is\n   * checked for each; the first active match wins. */\n  supersessionKeys?: string[];\n  namespace: string;\n}\n\n/** Configuration for a tombstone store instance. */\nexport interface TombstoneStoreOptions {\n  enabled: boolean;\n  semanticMatch: boolean;\n  semanticThreshold: number;\n  /** sha256 of raw content — wired to `ContentHashIndex.computeHash`. */\n  hashContent: (raw: string) => string;\n  /** Normalize raw content — wired to `ContentHashIndex.normalizeContent`. */\n  normalizeText: (raw: string) => string;\n  /**\n   * Optional cosine similarity in [0, 1] for the semantic tier. When\n   * undefined or when `semanticMatch` is false, the semantic tier is\n   * skipped entirely.\n   */\n  semanticSimilarity?: (a: string, b: string) => number;\n  /**\n   * Resolve source identity candidates for bounded legacy sourceMemoryIds.\n   * StorageManager reads the corpus before the tombstone write lock.\n   */\n  readonly sourceContentsForMemoryIds?: (\n    sourceMemoryIds: readonly string[],\n  ) => Promise<ReadonlyMap<string, string | readonly string[]>>;\n  /** Maximum number of legacy entries considered during one load. */\n  readonly legacyMigrationLimit?: number;\n  /**\n   * Cross-process write-lock timings for the tombstone JSONL mutation lock\n   * (issue #1639). The secure-store append is a read-merge-write (read\n   * encrypted → decrypt → concat → re-encrypt → atomic rename), so two\n   * Remnic processes appending concurrently can each read the same contents\n   * and the last writer drops the other's entry — breaking the\n   * non-resurrection invariant. The lock serializes the mutation across\n   * processes. When omitted, defaults that fit the short tombstone critical\n   * section (mirroring the summary-snapshot lock): staleMs 30s, maxWaitMs 5s,\n   * heartbeatMs floor(staleMs/3).\n   */\n  readonly lockStaleMs?: number;\n  readonly lockMaxWaitMs?: number;\n  readonly lockHeartbeatMs?: number;\n}\n\n/** Injected file I/O — the StorageManager wires its secure-store-aware\n * implementations so tombstones are encrypted at rest alongside other state.\n * `stat` is optional; when provided the store tracks the file mtime itself and\n * runs a cross-process staleness probe on each access (#1579). */\nexport interface TombstoneFileIo {\n  read: (filePath: string) => Promise<string>;\n  append: (filePath: string, content: string) => Promise<void>;\n  write: (filePath: string, content: string) => Promise<void>;\n  stat?: (filePath: string) => { mtimeMs: number };\n}\n\n/** Aggregate stats for `remnic doctor`. */\nexport interface TombstoneStats {\n  count: number;\n  revoked: number;\n  lastAppendAt: string | null;\n  corruptedLines: number;\n  /** Whether the in-memory index matches the on-disk file (rebuild check). */\n  loaded: boolean;\n}\n\nconst TOMBSTONE_NORMALIZER_VERSION = 2;\nconst DEFAULT_LEGACY_MIGRATION_LIMIT = 10_000;\n\nconst TOMBSTONE_PREFIX = \"tomb\";\n\nfunction newTombstoneId(): string {\n  return `${TOMBSTONE_PREFIX}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;\n}\n\n/** Deterministic key for the keyed tier (namespace + entityRef + supersessionKey).\n *\n * The namespace is part of the discriminator so two namespace-scoped stores\n * that share the same backing `tombstones.jsonl` (namespaces disabled, or the\n * same directory used with different namespace configs) cannot overwrite each\n * other's index entries — a later tombstone for namespace B with the same\n * entity/key no longer evicts namespace A's entry (issue #1579 thread Ocs-O). */\nfunction keyedTierKey(namespace: string, entityRef: string, supersessionKey: string): string {\n  return `${namespace}\\0${entityRef}\\0${supersessionKey}`;\n}\n\n/**\n * Parse one JSONL line into a TombstoneEntry, validating the discriminated\n * union. Returns `null` for malformed lines (rule 34 — skip with a counter,\n * never crash).\n */\nexport function parseTombstoneLine(line: string): TombstoneEntry | null {\n  const trimmed = line.trim();\n  if (trimmed.length === 0) return null;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(trimmed);\n  } catch {\n    return null;\n  }\n  if (!parsed || typeof parsed !== \"object\") return null;\n  const e = parsed as Record<string, unknown>;\n  if (typeof e.id !== \"string\" || e.id.length === 0) return null;\n  if (e.kind !== \"tombstone\" && e.kind !== \"revocation\") return null;\n  if (\n    e.reason !== \"correction\" &&\n    e.reason !== \"supersession\" &&\n    e.reason !== \"retraction\" &&\n    e.reason !== \"contradiction_resolution\"\n  ) {\n    return null;\n  }\n  if (typeof e.sourceMemoryId !== \"string\") return null;\n  if (typeof e.contentHash !== \"string\") return null;\n  if (typeof e.normalizedText !== \"string\") return null;\n  if (typeof e.namespace !== \"string\") return null;\n  if (typeof e.createdAt !== \"string\") return null;\n  if (\n    e.createdBy !== \"user_correction\" &&\n    e.createdBy !== \"contradiction_resolution\" &&\n    e.createdBy !== \"supersession\" &&\n    e.createdBy !== \"chat\"\n  ) {\n    return null;\n  }\n  const out: TombstoneEntry = {\n    id: e.id,\n    kind: e.kind,\n    reason: e.reason,\n    sourceMemoryId: e.sourceMemoryId,\n    contentHash: e.contentHash,\n    normalizedText: e.normalizedText,\n    namespace: e.namespace,\n    createdAt: e.createdAt,\n    createdBy: e.createdBy,\n  };\n  if (typeof e.currentContentHashAlias === \"string\") {\n    out.currentContentHashAlias = e.currentContentHashAlias;\n  }\n  if (typeof e.normalizerVersion === \"number\" && Number.isInteger(e.normalizerVersion)) {\n    out.normalizerVersion = e.normalizerVersion;\n  }\n  if (typeof e.operationKey === \"string\") out.operationKey = e.operationKey;\n  if (typeof e.entityRef === \"string\") out.entityRef = e.entityRef;\n  if (typeof e.supersessionKey === \"string\") out.supersessionKey = e.supersessionKey;\n  if (typeof e.revokes === \"string\") out.revokes = e.revokes;\n  return out;\n}\n\n/**\n * The instance-scoped tombstone store. One per StorageManager (rule 11),\n * namespace-scoped via `namespace` + the on-disk path (rule 42).\n *\n * The in-memory index is built lazily on first access and invalidated on\n * append + by the StorageManager's cache-invalidation chokepoint (rule 25).\n */\nexport class TombstoneStore {\n  private entries: TombstoneEntry[] = [];\n  /** contentHash → tombstone id (newest) — exact tier. */\n  private readonly byHash = new Map<string, string>();\n  /** normalizedText → tombstone id (newest) — normalized tier. */\n  private readonly byNormalized = new Map<string, string>();\n  /** entityRef\\0supersessionKey → tombstone id (newest) — keyed tier. */\n  private readonly byKey = new Map<string, string>();\n  /** Tombstone ids that have a later revocation entry. */\n  private readonly revokedIds = new Set<string>();\n  /** id → entry index (newest only, for revocation lookups). */\n  private readonly byId = new Map<string, TombstoneEntry>();\n  private loaded = false;\n  private loadPromise: Promise<void> | null = null;\n  private corruptedLines = 0;\n  private lastAppendAt: string | null = null;\n  /**\n   * Last-seen mtime of the JSONL file (cross-process staleness probe, #1579).\n   * Tracked inside the store so the StorageManager wiring stays thin. When the\n   * file's mtime advances past this value between accesses, the in-memory index\n   * is stale (a peer process appended) and is reloaded before the next lookup.\n   */\n  private fileMtimeMs = 0;\n\n  constructor(\n    private readonly filePath: string,\n    private readonly namespace: string,\n    private readonly options: TombstoneStoreOptions,\n    private readonly io: TombstoneFileIo,\n  ) {\n    const limit = this.options.legacyMigrationLimit;\n    if (limit !== undefined && (!Number.isFinite(limit) || !Number.isInteger(limit) || limit < 0)) {\n      throw new Error(\"legacyMigrationLimit must be a finite non-negative integer\");\n    }\n    this.lockStaleMs = this.options.lockStaleMs ?? 30_000;\n    this.lockMaxWaitMs = this.options.lockMaxWaitMs ?? 5_000;\n    this.lockHeartbeatMs =\n      this.options.lockHeartbeatMs ?? Math.max(100, Math.floor(this.lockStaleMs / 3));\n  }\n\n  /**\n   * Resolved cross-process write-lock timings (issue #1639). Defaults mirror\n   * the summary-snapshot lock: a tombstone append critical section is\n   * sub-second, so a stale lock older than 30s is a crashed holder; bounded\n   * acquisition gives up after 5s and strict-fails rather than clobbering a\n   * concurrent writer (which would reintroduce the lost-write race this lock\n   * closes).\n   */\n  private readonly lockStaleMs: number;\n  private readonly lockMaxWaitMs: number;\n  private readonly lockHeartbeatMs: number;\n\n  /**\n   * Sibling advisory lockfile: `<tombstones>.jsonl` → `<tombstones>.lock`.\n   * Shared by append, revoke, and rebuild so every JSONL mutation serializes\n   * against the others across processes (issue #1639: \"shared with rebuilds\").\n   */\n  private get lockPath(): string {\n    return this.filePath.replace(/\\.jsonl$/i, \"\") + \".lock\";\n  }\n\n  /** Lazy load + build the in-memory index. Idempotent. */\n  async load(): Promise<void> {\n    if (this.loaded) return;\n    if (this.loadPromise) return this.loadPromise;\n    this.loadPromise = this.loadInternal();\n    try {\n      await this.loadPromise;\n    } finally {\n      this.loadPromise = null;\n    }\n  }\n\n  private async loadInternal(migrateLegacy = true): Promise<void> {\n    // Record the file mtime before reading so an ENOENT still records 0 and\n    // a successful load does not immediately trigger a staleness reload.\n    this.recordFileMtime();\n    let raw: string;\n    try {\n      raw = await this.io.read(this.filePath);\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException)?.code;\n      if (code !== \"ENOENT\") throw err;\n      this.loaded = true;\n      return;\n    }\n    const initial = this.parseEntries(raw);\n    const migrated = migrateLegacy\n      ? await this.migrateLegacyEntries(initial)\n      : initial;\n    this.resetIndex();\n    for (const entry of migrated.entries) this.indexEntry(entry);\n    this.corruptedLines = migrated.corruptedLines;\n    this.loaded = true;\n  }\n\n  private parseEntries(raw: string): {\n    entries: TombstoneEntry[];\n    corruptedLines: number;\n  } {\n    const entries: TombstoneEntry[] = [];\n    let corruptedLines = 0;\n    for (const line of raw.split(\"\\n\")) {\n      const entry = parseTombstoneLine(line);\n      if (!entry) {\n        if (line.trim().length > 0) corruptedLines += 1;\n        continue;\n      }\n      entries.push(entry);\n    }\n    return { entries, corruptedLines };\n  }\n\n  /**\n   * Re-index pre-Unicode records from retired source content.\n   * Source reads stay bounded, but every batch finishes before the store\n   * publishes its in-memory index. Missing sources remain eligible on restart.\n   */\n  private async migrateLegacyEntries(initial: {\n    entries: TombstoneEntry[];\n    corruptedLines: number;\n  }): Promise<{ entries: TombstoneEntry[]; corruptedLines: number }> {\n    const limit = this.options.legacyMigrationLimit ?? DEFAULT_LEGACY_MIGRATION_LIMIT;\n    if (limit === 0 || !this.options.sourceContentsForMemoryIds) return initial;\n    const sourceMemoryIds: string[] = [];\n    const requested = new Set<string>();\n    for (const entry of initial.entries) {\n      if (\n        entry.kind !== \"tombstone\" ||\n        entry.normalizerVersion === TOMBSTONE_NORMALIZER_VERSION\n      ) {\n        continue;\n      }\n      if (requested.has(entry.sourceMemoryId)) continue;\n      requested.add(entry.sourceMemoryId);\n      sourceMemoryIds.push(entry.sourceMemoryId);\n    }\n    if (sourceMemoryIds.length === 0) return initial;\n    const sourceContents = new Map<string, string | readonly string[]>();\n    for (let offset = 0; offset < sourceMemoryIds.length; offset += limit) {\n      const batch = sourceMemoryIds.slice(offset, offset + limit);\n      const fetched = await this.options.sourceContentsForMemoryIds(batch);\n      for (const [sourceMemoryId, content] of fetched) sourceContents.set(sourceMemoryId, content);\n    }\n    return await serializeMutations(`tombstone:${this.filePath}`, () =>\n      this.withWriteLock(async () => {\n        const latestRaw = await this.io.read(this.filePath);\n        const latest = this.parseEntries(latestRaw);\n        let changed = false;\n        const migrateEntry = (entry: TombstoneEntry): TombstoneEntry => {\n          if (\n            entry.kind !== \"tombstone\" ||\n            entry.normalizerVersion === TOMBSTONE_NORMALIZER_VERSION ||\n            !requested.has(entry.sourceMemoryId)\n          ) {\n            return entry;\n          }\n          const resolved = sourceContents.get(entry.sourceMemoryId);\n          if (resolved === undefined) return entry;\n          const candidates = typeof resolved === \"string\" ? [resolved] : resolved;\n          const matches = candidates.filter((source) =>\n            entry.contentHash === this.options.hashContent(source) ||\n            entry.contentHash === computeLegacyContentHash(source)\n          );\n          const explicitPrimary =\n            matches.length === 0 &&\n            entry.contentHash !== this.options.hashContent(entry.normalizedText);\n          const source = matches[0] ?? (explicitPrimary ? candidates[0] : undefined);\n          if (source === undefined) return entry;\n          const currentHash = this.options.hashContent(source);\n          const alias = explicitPrimary\n            ? currentHash\n            : matches\n              .map((candidate) => this.options.hashContent(candidate))\n              .find((hash) => hash !== currentHash);\n          changed = true;\n          return {\n            ...entry,\n            contentHash: explicitPrimary ? entry.contentHash : currentHash,\n            ...(alias ? { currentContentHashAlias: alias } : {}),\n            normalizedText: this.options.normalizeText(source),\n            normalizerVersion: TOMBSTONE_NORMALIZER_VERSION,\n          };\n        };\n        const serialized = latestRaw\n          .split(\"\\n\")\n          .map((line) => {\n            const entry = parseTombstoneLine(line);\n            if (!entry) return line;\n            const migrated = migrateEntry(entry);\n            return migrated === entry ? line : JSON.stringify(migrated);\n          })\n          .join(\"\\n\");\n        if (!changed) return latest;\n        await this.io.write(this.filePath, serialized);\n        this.markWritten();\n        return this.parseEntries(serialized);\n      }),\n    );\n  }\n\n  private resetIndex(): void {\n    this.entries = [];\n    this.byHash.clear();\n    this.byNormalized.clear();\n    this.byKey.clear();\n    this.revokedIds.clear();\n    this.byId.clear();\n  }\n\n  /**\n   * Index an entry. Later entries (higher array index = newer createdAt)\n   * OVERRIDE earlier ones at each tier key — the newest matching entry wins\n   * (rule 25). Revocation entries mark their target as revoked.\n   */\n  private indexEntry(entry: TombstoneEntry): void {\n    this.entries.push(entry);\n    this.byId.set(entry.id, entry);\n    if (entry.createdAt > (this.lastAppendAt ?? \"\")) {\n      this.lastAppendAt = entry.createdAt;\n    }\n    if (entry.kind === \"revocation\") {\n      if (entry.revokes) this.revokedIds.add(entry.revokes);\n      return;\n    }\n    // Tombstone entries populate the lookup maps. The namespace is part of\n    // every discriminator key (issue #1579 thread Ocs-O): when two\n    // namespace-scoped stores share the same backing file, a later tombstone\n    // for namespace B with identical content must NOT evict namespace A's map\n    // entry — otherwise A's lookup finds B's id, rejects it on namespace\n    // mismatch, and misses its own still-active tombstone (resurrection).\n    const ns = entry.namespace;\n    if (entry.normalizerVersion === TOMBSTONE_NORMALIZER_VERSION) {\n      if (entry.contentHash) this.byHash.set(`${ns}\\0${entry.contentHash}`, entry.id);\n      if (entry.currentContentHashAlias) {\n        this.byHash.set(`${ns}\\0${entry.currentContentHashAlias}`, entry.id);\n      }\n      if (entry.normalizedText) this.byNormalized.set(`${ns}\\0${entry.normalizedText}`, entry.id);\n    }\n    if (entry.entityRef && entry.supersessionKey) {\n      this.byKey.set(keyedTierKey(ns, entry.entityRef, entry.supersessionKey), entry.id);\n    }\n  }\n\n  /** Invalidate the in-memory cache (rule 25). The next access reloads. */\n  invalidate(): void {\n    this.loaded = false;\n    this.loadPromise = null;\n    this.resetIndex();\n  }\n\n  /**\n   * Cross-process staleness probe (#1579). If the file's mtime advanced since\n   * the last load/own-write, a peer process appended and our in-memory index\n   * is stale — invalidate and reload before the next access. Mutation callers\n   * pass `migrate: false` to avoid nested serializer/lock acquisition.\n   */\n  async ensureFreshAgainstDisk(options: { migrate?: boolean } = {}): Promise<void> {\n    if (!this.io.stat) return;\n    let mtimeMs: number;\n    try {\n      mtimeMs = Math.floor(this.io.stat(this.filePath).mtimeMs);\n    } catch {\n      return; // ENOENT / permission — keep the loaded index (fail-open).\n    }\n    if (mtimeMs === this.fileMtimeMs && this.loaded) return;\n    this.fileMtimeMs = mtimeMs;\n    this.invalidate();\n    if (options.migrate === false) {\n      await this.loadInternal(false);\n    } else {\n      await this.load();\n    }\n  }\n\n  /**\n   * Record the file mtime after THIS process writes (append / revoke / rebuild)\n   * so `ensureFreshAgainstDisk` does not treat our own write as a peer append\n   * and throw away the just-updated in-memory index (#1579 — avoids a needless\n   * invalidate+reload in the hot write path).\n   */\n  private markWritten(): void {\n    this.recordFileMtime();\n  }\n\n  private recordFileMtime(): void {\n    if (!this.io.stat) return;\n    try {\n      this.fileMtimeMs = Math.floor(this.io.stat(this.filePath).mtimeMs);\n    } catch {\n      // ENOENT — fresh store with no file yet; mtime stays at its current value.\n    }\n  }\n\n  /**\n   * Append a tombstone entry. Serialized via `serializeMutations` keyed by\n   * file path so concurrent appends do not interleave, with rejection recovery\n   * (rule 40 — a single failed append never poisons the chain). The in-memory\n   * index is updated AFTER the durable append succeeds.\n   *\n   * Returns the new tombstone id.\n   */\n  async appendTombstone(input: {\n    reason: TombstoneReason;\n    createdBy: TombstoneCreatedBy;\n    sourceMemoryId: string;\n    rawContent: string;\n    entityRef?: string;\n    supersessionKey?: string;\n    operationKey?: string;\n    createdAt?: string;\n    /**\n     * Pre-computed canonical contentHash from the retired memory's frontmatter.\n     * When provided, used directly so the tombstone's exact tier matches the\n     * hash writeMemory computes on re-extraction (issue #1579 review: cited\n     * facts must not slip past the chokepoint because the emitter hashed the\n     * citation-annotated body instead of the canonical source).\n     */\n    contentHash?: string;\n  }): Promise<string> {\n    await this.load();\n    const createdAt = input.createdAt ?? new Date().toISOString();\n    const id = newTombstoneId();\n    const currentHash = this.options.hashContent(input.rawContent);\n    const currentNormalizedText = this.options.normalizeText(input.rawContent);\n    const entry: TombstoneEntry = {\n      id,\n      ...(input.contentHash && input.contentHash !== currentHash\n        ? { currentContentHashAlias: currentHash }\n        : {}),\n      kind: \"tombstone\",\n      reason: input.reason,\n      sourceMemoryId: input.sourceMemoryId,\n      contentHash: input.contentHash ?? currentHash,\n      normalizedText: currentNormalizedText,\n      normalizerVersion: TOMBSTONE_NORMALIZER_VERSION,\n      ...(input.entityRef ? { entityRef: input.entityRef } : {}),\n      ...(input.supersessionKey ? { supersessionKey: input.supersessionKey } : {}),\n      ...(input.operationKey ? { operationKey: input.operationKey } : {}),\n      namespace: this.namespace,\n      createdAt,\n      createdBy: input.createdBy,\n    };\n    await this.serializeAppend(entry);\n    this.indexEntry(entry);\n    this.markWritten();\n    await this.migrateLoadedLegacyEntries();\n    return id;\n  }\n\n  /**\n   * Append a revocation entry referencing `tombstoneId`. The log is\n   * append-only; lookup treats a revoked tombstone as re-allowed (rule 25).\n   */\n  async revoke(tombstoneId: string, createdBy: TombstoneCreatedBy): Promise<string> {\n    await this.load();\n    const createdAt = new Date().toISOString();\n    const id = newTombstoneId();\n    const entry: TombstoneEntry = {\n      id,\n      kind: \"revocation\",\n      reason: \"correction\",\n      sourceMemoryId: \"\",\n      contentHash: \"\",\n      normalizedText: \"\",\n      namespace: this.namespace,\n      createdAt,\n      createdBy,\n      revokes: tombstoneId,\n    };\n    await this.serializeAppend(entry);\n    this.indexEntry(entry);\n    this.markWritten();\n    await this.migrateLoadedLegacyEntries();\n    return id;\n  }\n\n  private serializeAppend(entry: TombstoneEntry): Promise<void> {\n    const line = JSON.stringify(entry) + \"\\n\";\n    // serializeMutations (in-process, rule 40 rejection recovery) wraps the\n    // cross-process lock: within one process appends are queued, and across\n    // processes the advisory lockfile serializes the read-merge-write so two\n    // Remnic processes appending concurrently cannot drop each other's entry\n    // (issue #1639). Under the lock we re-sync the in-memory index against\n    // disk first, so indexEntry builds on the peer's just-appended entries.\n    return serializeMutations(`tombstone:${this.filePath}`, () =>\n      this.withWriteLock(async () => {\n        await this.ensureFreshAgainstDisk({ migrate: false });\n        await this.io.append(this.filePath, line);\n      }),\n    );\n  }\n\n  private async migrateLoadedLegacyEntries(): Promise<void> {\n    const initial = {\n      entries: [...this.entries],\n      corruptedLines: this.corruptedLines,\n    };\n    if (!initial.entries.some(\n      (entry) => entry.kind === \"tombstone\" && entry.normalizerVersion !== TOMBSTONE_NORMALIZER_VERSION,\n    )) {\n      return;\n    }\n    try {\n      const migrated = await this.migrateLegacyEntries(initial);\n      this.resetIndex();\n      for (const entry of migrated.entries) this.indexEntry(entry);\n      this.corruptedLines = migrated.corruptedLines;\n      this.loaded = true;\n    } catch {\n      // The durable mutation already succeeded; defer migration to next load.\n    }\n  }\n\n  /**\n   * Acquire the cross-process tombstone write lock and run `task` under it\n   * (issue #1639). Strict-fail on acquisition timeout: the secure-store append\n   * is a read-merge-write, so a best-effort unlocked run would clobber a\n   * concurrent writer — reintroducing the lost-write race this lock closes.\n   * The thrown error surfaces to the caller (rule 34: never silently drop);\n   * rebuild recovers the tombstone on the next maintenance cycle.\n   *\n   * In-process callers are already serialized by serializeMutations (one key\n   * for append/revoke/rebuild), so this lock only contends across processes —\n   * the single-process daemon (default deployment) acquires it immediately.\n   */\n  private withWriteLock<T>(task: () => Promise<T>): Promise<T> {\n    return withHeldFileLock(\n      this.lockPath,\n      {\n        staleMs: this.lockStaleMs,\n        maxWaitMs: this.lockMaxWaitMs,\n        heartbeatMs: this.lockHeartbeatMs,\n      },\n      async (acquired) => {\n        if (!acquired) {\n          throw new Error(\n            \"could not acquire tombstone write lock (contention timeout or filesystem error)\",\n          );\n        }\n        return task();\n      },\n    );\n  }\n\n  /**\n   * Look up whether `query` is blocked by an active (non-revoked) tombstone.\n   * Tiers are checked in order: exact (contentHash) → normalized → keyed →\n   * semantic (off by default). Returns the first active match, or `null`.\n   *\n   * Namespace isolation (rule 42): only entries with `namespace === query.namespace`\n   * match. The store is per-namespace, so this is belt-and-suspenders.\n   */\n  lookup(query: TombstoneLookupQuery): TombstoneMatch | null {\n    // We intentionally do NOT await load() here — lookup is called from the\n    // hot write path. Callers MUST ensure the store is loaded before lookup\n    // (StorageManager does this in ensureTombstoneStoreLoaded). If not loaded,\n    // lookup returns null (fail-open: a missing tombstone check is preferable\n    // to crashing every write — see rule 34 / the \"degrade gracefully\" note).\n    if (!this.options.enabled) return null;\n    if (!this.loaded) return null;\n\n    // Tier 1: exact contentHash. Namespace is part of the map key (thread\n    // Ocs-O), so the lookup finds only this namespace's tombstone even when\n    // the backing file is shared. The namespace equality check below is kept\n    // as defense-in-depth.\n    const ns = query.namespace;\n    if (query.contentHash) {\n      const id = this.byHash.get(`${ns}\\0${query.contentHash}`);\n      if (id && !this.revokedIds.has(id)) {\n        const entry = this.byId.get(id);\n        if (entry && entry.namespace === ns) {\n          return { tombstoneId: id, matchedTier: \"exact\", reason: entry.reason };\n        }\n      }\n    }\n    // Tier 2: normalized text.\n    if (query.normalizedText) {\n      const id = this.byNormalized.get(`${ns}\\0${query.normalizedText}`);\n      if (id && !this.revokedIds.has(id)) {\n        const entry = this.byId.get(id);\n        if (entry && entry.namespace === ns) {\n          return { tombstoneId: id, matchedTier: \"normalized\", reason: entry.reason };\n        }\n      }\n    }\n    // Tier 3: keyed (entityRef + supersessionKey). Issue #1579 thread\n    // Ociag/Oci-W: check EVERY supplied key, not just the first — emitters\n    // append one tombstone per matched supersession key, so the active block\n    // can live on any later key. The union of `supersessionKey` (singular,\n    // direct callers) and `supersessionKeys` (array, write chokepoint) is\n    // checked; the first active match wins (tiers are equality-based, so\n    // ordering across keys does not affect correctness).\n    if (query.entityRef) {\n      const keysToCheck: string[] = [];\n      if (query.supersessionKey) keysToCheck.push(query.supersessionKey);\n      if (query.supersessionKeys) {\n        for (const k of query.supersessionKeys) {\n          if (!keysToCheck.includes(k)) keysToCheck.push(k);\n        }\n      }\n      for (const key of keysToCheck) {\n        const id = this.byKey.get(keyedTierKey(ns, query.entityRef, key));\n        if (id && !this.revokedIds.has(id)) {\n          const entry = this.byId.get(id);\n          if (entry && entry.namespace === ns) {\n            return { tombstoneId: id, matchedTier: \"keyed\", reason: entry.reason };\n          }\n        }\n      }\n    }\n    // Tier 4: semantic (off by default, rule 48).\n    if (this.options.semanticMatch && this.options.semanticSimilarity && query.normalizedText) {\n      const threshold = this.options.semanticThreshold;\n      let best: { id: string; reason: TombstoneReason; score: number } | null = null;\n      for (const entry of this.entries) {\n        if (entry.kind !== \"tombstone\") continue;\n        if (entry.normalizerVersion !== TOMBSTONE_NORMALIZER_VERSION) continue;\n        if (entry.namespace !== query.namespace) continue;\n        if (this.revokedIds.has(entry.id)) continue;\n        if (!entry.normalizedText) continue;\n        const score = this.options.semanticSimilarity(query.normalizedText, entry.normalizedText);\n        if (score >= threshold && (!best || score > best.score)) {\n          best = { id: entry.id, reason: entry.reason, score };\n        }\n      }\n      if (best) {\n        return { tombstoneId: best.id, matchedTier: \"semantic\", reason: best.reason };\n      }\n    }\n    return null;\n  }\n  async hasExactEntry(input: {\n    sourceMemoryId: string;\n    contentHash?: string;\n    entityRef?: string;\n    supersessionKey?: string;\n    createdAt?: string;\n    operationKey?: string;\n  }): Promise<boolean> {\n    if (!this.options.enabled) return false;\n    await this.ensureFreshAgainstDisk();\n    await this.load();\n    return this.entries.some(\n      (entry) =>\n        entry.kind === \"tombstone\" &&\n        !this.revokedIds.has(entry.id) &&\n        entry.namespace === this.namespace &&\n        entry.sourceMemoryId === input.sourceMemoryId &&\n        (input.contentHash === undefined || entry.contentHash === input.contentHash) &&\n        (input.entityRef === undefined || entry.entityRef === input.entityRef) &&\n        (input.supersessionKey === undefined || entry.supersessionKey === input.supersessionKey) &&\n        (input.createdAt === undefined || entry.createdAt === input.createdAt) &&\n        (input.operationKey === undefined || entry.operationKey === input.operationKey),\n    );\n  }\n\n\n  /** Aggregate stats for the doctor / x-ray surfaces. */\n  stats(): TombstoneStats {\n    let active = 0;\n    for (const entry of this.entries) {\n      if (entry.kind === \"tombstone\" && !this.revokedIds.has(entry.id)) active += 1;\n    }\n    return {\n      count: active,\n      revoked: this.revokedIds.size,\n      lastAppendAt: this.lastAppendAt,\n      corruptedLines: this.corruptedLines,\n      loaded: this.loaded,\n    };\n  }\n\n  /** Read-only snapshot of all entries (for rebuild + tests). */\n  snapshot(): readonly TombstoneEntry[] {\n    return this.entries;\n  }\n\n  /**\n   * Rebuild the in-memory index + JSONL from the supplied retired-memory\n   * records + existing entries (preserving revocations). Byte-stable: entries\n   * are sorted by (createdAt, id) before write (rule 38).\n   *\n   * Returns the count of tombstone entries written.\n   */\n  async rebuild(retiredMemories: ReadonlyArray<RetiredMemoryRecord>): Promise<number> {\n    // The full read-merge-write runs UNDER the cross-process lock (issue #1639,\n    // cursor/codex review): we ensureFreshAgainstDisk() first so the in-memory\n    // index reflects any peer append/revoke that landed while we waited for the\n    // lock, THEN compute the payload. Rebuild rewrites the entire JSONL, so a\n    // payload built from a stale this.entries would overwrite a peer's just-\n    // written entry and resurrect a retired fact — the exact invariant this\n    // store exists to enforce. serializeMutations (in-process) wraps the\n    // cross-process lock; the key is unified with append/revoke so they cannot\n    // interleave in-process either.\n    const rebuiltCount = await serializeMutations(`tombstone:${this.filePath}`, () =>\n      this.withWriteLock(async () => {\n        await this.ensureFreshAgainstDisk({ migrate: false });\n        // Preserve existing revocations (all namespaces — ids are globally\n        // unique) so a rebuild does not silently un-revoke.\n        const existingRevocations = this.entries.filter((e) => e.kind === \"revocation\");\n        // Preserve tombstone entries from OTHER namespaces when the backing\n        // file is shared (issue #1579 thread Oc2MJ). rebuild rewrites the\n        // entire file; without preserving foreign entries, rebuilding\n        // namespace A would silently delete namespace B's tombstones, allowing\n        // resurrection in B.\n        const foreignTombstones = this.entries.filter(\n          (e) => e.kind === \"tombstone\" && e.namespace !== this.namespace,\n        );\n        // Reuse existing tombstone ids for source-equivalent entries so a prior\n        // revocation (which references the tombstone id) survives rebuild —\n        // minting fresh ids would orphan the revocation and silently un-revoke.\n        // Issue #1579 thread Oci-T: key the reuse map by (sourceMemoryId,\n        // supersessionKey). See the append path above for the full rationale.\n        const existingBySource = new Map<string, string>();\n        for (const e of this.entries) {\n          if (e.kind === \"tombstone\") {\n            existingBySource.set(`${e.sourceMemoryId}\\u{0000}${e.supersessionKey ?? \"\"}`, e.id);\n          }\n        }\n        const rebuilt: TombstoneEntry[] = retiredMemories.map((m) => {\n          const currentHash = this.options.hashContent(m.rawContent);\n          const currentNormalizedText = this.options.normalizeText(m.rawContent);\n          const persistedHash = m.contentHash;\n          // A persisted hash equal to the body's LEGACY hash only proves the\n          // record predates the Unicode normalizer when that legacy hash is\n          // unambiguous. When the legacy normalizer is lossy for this body\n          // (any body whose ASCII skeleton collides with a distinct\n          // contentHashSource), the equality cannot distinguish \"old body\n          // hash\" from \"explicit source identity\" — replacing the persisted\n          // hash would displace a live identity (issue #2367). Preserving\n          // keeps BOTH keys: contentHash stays the persisted identity and\n          // currentContentHashAlias still blocks the body.\n\n          // Repair only when the persisted hash provably identifies THIS\n          // body's stale legacy hash: either the unambiguous case (legacy and\n          // current normalizations agree), or the empty-skeleton case — every\n          // non-ASCII-only body normalizes to the empty legacy skeleton, so a\n          // persisted hash equal to hash(\"\") is the shared non-identifying\n          // legacy body hash and publishing it on the exact tier would\n          // collide unrelated tombstones. Any OTHER persisted hash on an\n          // empty-skeleton body is a distinct explicit identity (e.g.\n          // contentHashSource) and must be preserved.\n          const legacyBodyHash = computeLegacyContentHash(m.rawContent);\n          const repairEmptySkeleton =\n            normalizeLegacyContent(m.rawContent).length === 0 && persistedHash === legacyBodyHash;\n          const preserveOverride =\n            persistedHash !== undefined &&\n            persistedHash !== currentHash &&\n            !repairEmptySkeleton &&\n            !isUnambiguousLegacyContentHash(m.rawContent, persistedHash, currentNormalizedText);\n          return {\n            id:\n              existingBySource.get(`${m.memoryId}\\u{0000}${m.supersessionKey ?? \"\"}`) ??\n              newTombstoneId(),\n            ...(preserveOverride ? { currentContentHashAlias: currentHash } : {}),\n            kind: \"tombstone\" as const,\n            reason: m.reason,\n            sourceMemoryId: m.memoryId,\n            contentHash: preserveOverride ? persistedHash : currentHash,\n            normalizedText: currentNormalizedText,\n            normalizerVersion: TOMBSTONE_NORMALIZER_VERSION,\n            ...(m.entityRef ? { entityRef: m.entityRef } : {}),\n            ...(m.supersessionKey ? { supersessionKey: m.supersessionKey } : {}),\n            namespace: this.namespace,\n            createdAt: m.createdAt,\n            createdBy: m.createdBy,\n          };\n        });\n        // Sort deterministically (rule 38): createdAt, then id for stability.\n        rebuilt.sort((a, b) =>\n          a.createdAt === b.createdAt\n            ? a.id < b.id ? -1 : a.id > b.id ? 1 : 0\n            : a.createdAt < b.createdAt ? -1 : 1,\n        );\n        const all = [...rebuilt, ...existingRevocations, ...foreignTombstones].sort((a, b) =>\n          a.createdAt === b.createdAt\n            ? a.id < b.id ? -1 : a.id > b.id ? 1 : 0\n            : a.createdAt < b.createdAt ? -1 : 1,\n        );\n        const serialized =\n          all.map((e) => JSON.stringify(e)).join(\"\\n\") + (all.length > 0 ? \"\\n\" : \"\");\n        await this.io.write(this.filePath, serialized);\n        // Update the in-memory index under the same lock so it stays consistent\n        // with the file we just wrote (no window for a lookup to see a stale\n        // index that misses a just-rebuilt entry).\n        this.resetIndex();\n        for (const entry of all) this.indexEntry(entry);\n        this.corruptedLines = 0;\n        this.loaded = true;\n        this.markWritten();\n        return rebuilt.length;\n      }),\n    );\n    await this.migrateLoadedLegacyEntries();\n    return rebuiltCount;\n  }\n}\n\n/** A retired memory projected into the shape `TombstoneStore.rebuild` consumes. */\nexport interface RetiredMemoryRecord {\n  memoryId: string;\n  rawContent: string;\n  entityRef?: string;\n  supersessionKey?: string;\n  reason: TombstoneReason;\n  createdBy: TombstoneCreatedBy;\n  createdAt: string;\n  /** Canonical contentHash from the retired memory's frontmatter (#1579). */\n  contentHash?: string;\n}\n\n/**\n * Project a corpus of memories into the retired-memory records `rebuild`\n * consumes. Pure (no I/O) so the StorageManager wiring stays thin (#1579,\n * #1520 god-file ratchet). Only superseded / forgotten / rejected FACTS\n * participate — entities, questions, and artifacts have their own lifecycle\n * (issue pitfall). The supersession key is derived from structured attributes\n * via the injected helper so there is one keyed-tier definition (rule 23).\n */\nexport function collectRetiredMemoriesForRebuild(\n  memories: ReadonlyArray<{\n    frontmatter: {\n      id: string;\n      status?: string;\n      category?: string;\n      contentHash?: string;\n      entityRef?: string;\n      structuredAttributes?: Record<string, string>;\n      updated?: string;\n      created?: string;\n    };\n    content: string;\n  }>,\n  deps: {\n    /** Strip citation annotations from the body before hashing/normalizing. */\n    stripCitation: (text: string) => string;\n    /** Derive the keyed-tier supersession key (one helper, rule 23). */\n    supersessionKeysForFact: (spec: {\n      entityRef?: string;\n      structuredAttributes?: Record<string, string>;\n    }) => string[];\n  },\n): RetiredMemoryRecord[] {\n  const retired: RetiredMemoryRecord[] = [];\n  for (const m of memories) {\n    const status = m.frontmatter.status;\n    if (status !== \"superseded\" && status !== \"rejected\" && status !== \"forgotten\") continue;\n    if (m.frontmatter.category !== \"fact\") continue;\n    const reason: TombstoneReason =\n      status === \"superseded\" ? \"supersession\" : status === \"forgotten\" ? \"retraction\" : \"correction\";\n    const createdBy: TombstoneCreatedBy =\n      reason === \"supersession\" ? \"supersession\" : \"user_correction\";\n    const entityRef = m.frontmatter.entityRef;\n    const keys =\n      entityRef && m.frontmatter.structuredAttributes\n        ? deps.supersessionKeysForFact({\n            entityRef,\n            structuredAttributes: m.frontmatter.structuredAttributes,\n          })\n        : [];\n    // Issue #1579 thread Ocgjz: emit one record per matched supersession key\n    // (not just keys[0]) so rebuild reproduces the same keyed tombstones as\n    // live temporal-supersession (which now appends one per key — thread ObteS).\n    // Without this, a rebuild would under-rebuild the JSONL and keyed-tier\n    // blocks would disappear until rediscovered.\n    const keysToEmit = keys.length > 0 ? keys : [undefined];\n    for (const key of keysToEmit) {\n      retired.push({\n        memoryId: m.frontmatter.id,\n        rawContent: deps.stripCitation(m.content),\n        contentHash: m.frontmatter.contentHash,\n        ...(entityRef ? { entityRef } : {}),\n        ...(key ? { supersessionKey: key } : {}),\n        reason,\n        createdBy,\n        createdAt: m.frontmatter.updated || m.frontmatter.created || new Date().toISOString(),\n      });\n    }\n  }\n  return retired;\n}\n\n/**\n * One-shot write-time resurrection gate (issue #1579 / #2213). Looks up the\n * fact's identity in the tombstone store and, on a match, downgrades the\n * frontmatter to `pending_review` + `blockedBy` IN PLACE. ADD-ONLY: an\n * already-blocked or terminal-status record is left untouched. Pure over its\n * inputs (no I/O beyond the injected store) so both `writeMemory`'s gate and\n * the chunk-repair re-gate share one lookup + apply.\n */\nexport function applyTombstoneResurrectionGate(\n  store: Pick<TombstoneStore, \"lookup\">,\n  fm: {\n    id: string;\n    status?: string;\n    blockedBy?: string;\n    tombstoneBlockTier?: TombstoneMatchTier;\n    entityRef?: string;\n    contentHash?: string;\n  },\n  query: {\n    normalizedText: string;\n    supersessionKeys: string[];\n    namespace: string;\n  },\n): TombstoneMatch | null {\n  if (fm.status === \"pending_review\" && fm.blockedBy) return null;\n  if (!(fm.status === undefined || fm.status === \"active\" || fm.status === \"pending_review\")) return null;\n  const match = store.lookup({\n    contentHash: fm.contentHash,\n    normalizedText: query.normalizedText,\n    ...(fm.entityRef ? { entityRef: fm.entityRef } : {}),\n    ...(query.supersessionKeys.length > 0 ? { supersessionKeys: query.supersessionKeys } : {}),\n    namespace: query.namespace,\n  });\n  if (!match) return null;\n  fm.status = \"pending_review\";\n  fm.blockedBy = match.tombstoneId;\n  fm.tombstoneBlockTier = match.matchedTier;\n  return match;\n}\n\n/**\n * Build the live-emission tombstone inputs for a single retired FACT — one\n * input per derived supersession key (or a single keyless record when no\n * structured attributes are present). Pure (no I/O) so the emitters in\n * `StorageManager.supersedeMemory` (contradiction) and `forgetMemory`\n * (retraction) stay thin (#1579, #1520 god-file ratchet). Mirrors the\n * temporal-supersession emitter and `collectRetiredMemoriesForRebuild` so\n * every retire path emits the same keyed-tombstone shape (issue #1579\n * threads Oci-Y / OchiF: without per-key tombstones, a paraphrased\n * re-observation missed the keyed tier and the fact resurrected active).\n */\nexport function buildRetiredFactTombstoneInputs(\n  memory: {\n    id: string;\n    content: string;\n    contentHash?: string;\n    entityRef?: string;\n    structuredAttributes?: Record<string, string>;\n  },\n  opts: {\n    reason: TombstoneReason;\n    createdBy: TombstoneCreatedBy;\n    createdAt: string;\n    supersessionKeysForFact: (spec: {\n      entityRef?: string;\n      structuredAttributes?: Record<string, string>;\n    }) => string[];\n  },\n): Array<{\n  reason: TombstoneReason;\n  createdBy: TombstoneCreatedBy;\n  sourceMemoryId: string;\n  rawContent: string;\n  contentHash?: string;\n  entityRef?: string;\n  supersessionKey?: string;\n  createdAt: string;\n}> {\n  const keys =\n    memory.entityRef && memory.structuredAttributes\n      ? opts.supersessionKeysForFact({\n          entityRef: memory.entityRef,\n          structuredAttributes: memory.structuredAttributes,\n        })\n      : [];\n  const keysToEmit = keys.length > 0 ? keys : [undefined];\n  return keysToEmit.map((key) => ({\n    reason: opts.reason,\n    createdBy: opts.createdBy,\n    sourceMemoryId: memory.id,\n    rawContent: memory.content,\n    ...(memory.contentHash ? { contentHash: memory.contentHash } : {}),\n    ...(memory.entityRef ? { entityRef: memory.entityRef } : {}),\n    ...(key ? { supersessionKey: key } : {}),\n    createdAt: opts.createdAt,\n  }));\n}\n"],"mappings":"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","names":["source"]}

package/dist/chunk-47DU4SGJ.js

@@ -0,0 +1,92 @@
+// src/user-message-cleaning.ts
+var NO_PLATFORM_HEADER = /$a/;
+var WRAPPER_OPEN = "<supermemory-context";
+var WRAPPER_CLOSE = "</supermemory-context>";
+var WRAPPER_MAX_ATTRIBUTE_CHARS = 256;
+function isWhitespaceCode(code) {
+  return code === 32 || code >= 9 && code <= 13;
+}
+function stripMemoryWrappers(content) {
+  let out = "";
+  let cursor = 0;
+  for (; ; ) {
+    const open = content.indexOf(WRAPPER_OPEN, cursor);
+    if (open === -1) return out + content.slice(cursor);
+    const headEnd = content.indexOf(">", open);
+    if (headEnd === -1) return out + content.slice(cursor);
+    const head = content.slice(open + WRAPPER_OPEN.length, headEnd);
+    const headIsPlain = head.length > 0 && (head.length > WRAPPER_MAX_ATTRIBUTE_CHARS + 1 || headIsNotAttributeRun(head));
+    if (head !== "" && headIsPlain) {
+      out += content.slice(cursor, open + WRAPPER_OPEN.length);
+      cursor = open + WRAPPER_OPEN.length;
+      continue;
+    }
+    const close = content.indexOf(WRAPPER_CLOSE, headEnd);
+    if (close === -1) return out + content.slice(cursor);
+    let after = close + WRAPPER_CLOSE.length;
+    while (after < content.length && isWhitespaceCode(content.charCodeAt(after))) {
+      after += 1;
+    }
+    out += content.slice(cursor, open);
+    cursor = after;
+  }
+}
+function stripTrailingMessageId(content) {
+  const marker = "[message_id:";
+  const start = content.lastIndexOf(marker);
+  if (start === -1) return null;
+  let index = start + marker.length;
+  while (index < content.length && isWhitespaceCode(content.charCodeAt(index))) {
+    index += 1;
+  }
+  const idStart = index;
+  while (index < content.length && content.charCodeAt(index) !== 93) {
+    index += 1;
+  }
+  if (index === idStart || index === content.length) return null;
+  index += 1;
+  while (index < content.length && isWhitespaceCode(content.charCodeAt(index))) {
+    index += 1;
+  }
+  if (index !== content.length) return null;
+  let boundary = start;
+  while (boundary > 0 && isWhitespaceCode(content.charCodeAt(boundary - 1))) {
+    boundary -= 1;
+  }
+  return content.slice(0, boundary);
+}
+function headIsNotAttributeRun(head) {
+  if (head.charCodeAt(0) !== 32 && !(head.charCodeAt(0) >= 9 && head.charCodeAt(0) <= 13)) {
+    return true;
+  }
+  for (let index = 0; index < head.length; index += 1) {
+    const code = head.charCodeAt(index);
+    if (code === 60 || code === 62) return true;
+  }
+  return false;
+}
+function cleanUserMessageWithPattern(content, platformHeaderPattern) {
+  let cleaned = stripMemoryWrappers(content);
+  const platformHeader = cleaned.match(platformHeaderPattern);
+  const hasPlatformHeader = platformHeader !== null;
+  if (platformHeader) {
+    cleaned = cleaned.slice(platformHeader[0].length);
+  }
+  cleaned = cleaned.replace(
+    /^\s*## Memory Context \((?:Engram|Remnic)\)[\s\S]*?(?=\n## |\n$)/i,
+    ""
+  );
+  if (hasPlatformHeader) {
+    cleaned = stripTrailingMessageId(cleaned) ?? cleaned;
+  }
+  return cleaned.trim();
+}
+function cleanArchivedUserMessage(content) {
+  return cleanUserMessageWithPattern(content, NO_PLATFORM_HEADER);
+}
+
+export {
+  cleanUserMessageWithPattern,
+  cleanArchivedUserMessage
+};
+//# sourceMappingURL=chunk-47DU4SGJ.js.map

package/dist/chunk-47DU4SGJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/user-message-cleaning.ts"],"sourcesContent":["/**\n * Host-agnostic user-message cleaning (issue #2331).\n *\n * Owns the generic part of the cleaner the OpenClaw wiring has always used\n * (`src/user-message-cleaning.ts` in the root host bundle): stripping the\n * structured host-injected memory wrappers and the leading memory-context\n * preamble from a user message. The host wrapper keeps only the\n * platform-header pattern (channel envelopes are an OpenClaw concept) and\n * delegates here, so core consumers — the episodic-context recall section\n * re-rendering archived user turns — share ONE implementation instead of a\n * second cleaner drifting beside it.\n */\n\n/** Never-matching header pattern for callers with no platform envelope. */\nconst NO_PLATFORM_HEADER = /$a/;\n\nconst WRAPPER_OPEN = \"<supermemory-context\";\nconst WRAPPER_CLOSE = \"</supermemory-context>\";\nconst WRAPPER_MAX_ATTRIBUTE_CHARS = 256;\n\nfunction isWhitespaceCode(code: number): boolean {\n  return code === 32 || (code >= 9 && code <= 13);\n}\n\n/**\n * Remove `<supermemory-context …>…</supermemory-context>` wrappers. A\n * single left-to-right scan with string searches — no regex on uncontrolled\n * input — so adversarial repeats of the tag literal stay linear (CodeQL\n * redos rule, issue #2331 review). Malformed or oversized tag heads are\n * treated as plain text, and an unterminated wrapper preserves the rest.\n */\nfunction stripMemoryWrappers(content: string): string {\n  let out = \"\";\n  let cursor = 0;\n  for (;;) {\n    const open = content.indexOf(WRAPPER_OPEN, cursor);\n    if (open === -1) return out + content.slice(cursor);\n    const headEnd = content.indexOf(\">\", open);\n    if (headEnd === -1) return out + content.slice(cursor);\n    const head = content.slice(open + WRAPPER_OPEN.length, headEnd);\n    const headIsPlain =\n      head.length > 0 &&\n      (head.length > WRAPPER_MAX_ATTRIBUTE_CHARS + 1 || headIsNotAttributeRun(head));\n    if (head !== \"\" && headIsPlain) {\n      // Not a wrapper open tag: keep the literal and continue after it.\n      out += content.slice(cursor, open + WRAPPER_OPEN.length);\n      cursor = open + WRAPPER_OPEN.length;\n      continue;\n    }\n    const close = content.indexOf(WRAPPER_CLOSE, headEnd);\n    if (close === -1) return out + content.slice(cursor);\n    let after = close + WRAPPER_CLOSE.length;\n    while (after < content.length && isWhitespaceCode(content.charCodeAt(after))) {\n      after += 1;\n    }\n    // Keep everything before the wrapper; only the wrapper (plus its\n    // trailing whitespace) is removed.\n    out += content.slice(cursor, open);\n    cursor = after;\n  }\n}\n\n/**\n * Remove a trailing `[message_id: …]` marker (with surrounding whitespace)\n * using a single right-anchored string scan — no regex on uncontrolled\n * input (CodeQL redos rule). Returns null when no marker terminates the\n * content, leaving the caller's string untouched.\n */\nfunction stripTrailingMessageId(content: string): string | null {\n  const marker = \"[message_id:\";\n  const start = content.lastIndexOf(marker);\n  if (start === -1) return null;\n  let index = start + marker.length;\n  while (index < content.length && isWhitespaceCode(content.charCodeAt(index))) {\n    index += 1;\n  }\n  const idStart = index;\n  while (index < content.length && content.charCodeAt(index) !== 93 /* ] */) {\n    index += 1;\n  }\n  if (index === idStart || index === content.length) return null;\n  index += 1; // past the closing bracket\n  while (index < content.length && isWhitespaceCode(content.charCodeAt(index))) {\n    index += 1;\n  }\n  if (index !== content.length) return null;\n  let boundary = start;\n  while (boundary > 0 && isWhitespaceCode(content.charCodeAt(boundary - 1))) {\n    boundary -= 1;\n  }\n  return content.slice(0, boundary);\n}\n\n/** True when the tag-head text cannot be a whitespace-led attribute run. */\nfunction headIsNotAttributeRun(head: string): boolean {\n  if (head.charCodeAt(0) !== 32 && !(head.charCodeAt(0) >= 9 && head.charCodeAt(0) <= 13)) {\n    return true;\n  }\n  for (let index = 0; index < head.length; index += 1) {\n    const code = head.charCodeAt(index);\n    if (code === 60 || code === 62) return true;\n  }\n  return false;\n}\n\nexport function cleanUserMessageWithPattern(\n  content: string,\n  platformHeaderPattern: RegExp,\n): string {\n  let cleaned = stripMemoryWrappers(content);\n  const platformHeader = cleaned.match(platformHeaderPattern);\n  const hasPlatformHeader = platformHeader !== null;\n  if (platformHeader) {\n    cleaned = cleaned.slice(platformHeader[0].length);\n  }\n\n  // Remove markdown memory context only when it is a leading preamble. If a\n  // user writes a section with this title later in their message, preserve it.\n  cleaned = cleaned.replace(\n    /^\\s*## Memory Context \\((?:Engram|Remnic)\\)[\\s\\S]*?(?=\\n## |\\n$)/i,\n    \"\",\n  );\n\n  if (hasPlatformHeader) {\n    cleaned = stripTrailingMessageId(cleaned) ?? cleaned;\n  }\n  return cleaned.trim();\n}\n\n/**\n * Clean an archived user turn for re-injection (issue #2331): strips the\n * memory wrappers this system itself injects, so an archived echo of a\n * previous recall output cannot re-enter the context through the\n * episodic-context section. No platform envelope stripping — core has no\n * host channel-envelope concept.\n */\nexport function cleanArchivedUserMessage(content: string): string {\n  return cleanUserMessageWithPattern(content, NO_PLATFORM_HEADER);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-AWRJBAIH.js → chunk-4FFROSFG.js}

@@ -26,7 +26,7 @@ import {
   scoreTrustZoneProvenance,
   seedTrustZoneDemoDataset,
   summarizeTrustZonePromotionReadiness
-} from "./chunk-KQS72GCR.js";
+} from "./chunk-LJOIZPJH.js";
 import {
   planSessionTranscriptMigration
 } from "./chunk-P5FPO2BR.js";
@@ -35,13 +35,13 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-76YNCJ5H.js";
+} from "./chunk-3F3CVVDS.js";
 import {
   estimateRecallTokens
-} from "./chunk-EHMMRZOZ.js";
+} from "./chunk-QICOU4RY.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-CIA6ZUBA.js";
+} from "./chunk-WMOJIOIG.js";
 import {
   ReplicaDivergenceMonitor
 } from "./chunk-CVILPI77.js";
@@ -99,11 +99,11 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-FW73HN33.js";
+} from "./chunk-RFH7U5LT.js";
 import {
   CorpusWatermarkCache,
   computeServiceCorpusCensus
-} from "./chunk-I67HKRBF.js";
+} from "./chunk-EFWHCTYJ.js";
 import {
   CrossNamespaceBudget,
   toBudgetWarning
@@ -120,28 +120,28 @@ import {
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-HXXGZ4KV.js";
+} from "./chunk-ALNZEWGN.js";
 import {
   FileCalendarSource,
   buildBriefing,
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-W3Y6FYRK.js";
+} from "./chunk-7BJYTX6Q.js";
 import {
   parseEntityFile,
   parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-YUIBXMZY.js";
+} from "./chunk-CALURYWR.js";
 import {
   namespaceCollectionName
-} from "./chunk-QWPAQLYV.js";
+} from "./chunk-JFLKSD5V.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-5WVUO6QT.js";
+} from "./chunk-AR253JBM.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -208,7 +208,7 @@ import {
 } from "./chunk-LNEWDF2A.js";
 import {
   createOfflineSyncManifestStream
-} from "./chunk-4SGDYYWV.js";
+} from "./chunk-RPKJHYVE.js";
 import {
   offlineSyncStorageForSnapshot
 } from "./chunk-HZNYJN77.js";
@@ -359,7 +359,7 @@ import {
 } from "./chunk-BTTPKDIL.js";
 import {
   AccessAuditAdapter
-} from "./chunk-TVVEYCNW.js";
+} from "./chunk-7K5Q6COX.js";
 import {
   decodeCitationNamespace
 } from "./chunk-JIYDRBVZ.js";
@@ -8922,6 +8922,29 @@ ${details.join("\n")}`;
     return `## Harmonic Retrieval
 
 ${lines.join("\n\n")}`;
+  }
+  /**
+   * Render grouped raw-turn episodes for the top recalled facts (issue #2331).
+   * Returns `null` for zero episodes so the section is omitted entirely —
+   * never an empty header.
+   */
+  formatEpisodicContext(episodes) {
+    if (episodes.length === 0) return null;
+    const blocks = episodes.map((episode) => {
+      const shortKey = episode.sessionKey.length > 8 ? `${episode.sessionKey.slice(0, 8)}\u2026` : episode.sessionKey;
+      const header = `### Episode: ${shortKey} turns ${episode.fromTurn}-${episode.toTurn - 1} (supports [${episode.memoryIds.join(", ")}])`;
+      const lines = episode.turns.map((turn) => {
+        const content = renderAuthorityBoundContent(turn.content, void 0, {
+          enabled: this.originAuthorityEnabled,
+          untrustedOrigins: this.config.untrustedOrigins
+        });
+        return `${turn.role}: ${content}`;
+      });
+      return [header, ...lines].join("\n");
+    });
+    return `## Source Episodes
+
+${blocks.join("\n\n")}`;
   }
   formatWorkProductResults(results) {
     const lines = results.map(({ entry, matchedFields }, index) => {
@@ -17672,4 +17695,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-AWRJBAIH.js.map
+//# sourceMappingURL=chunk-4FFROSFG.js.map