@remnic/core 1.1.1 → 1.1.3

package/dist/chunk-55FXRRSJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/connectors/codex-materialize-runner.ts","../src/connectors/codex-materialize.ts","../src/semantic-consolidation.ts"],"sourcesContent":["/**\n * codex-materialize-runner.ts — Thin I/O bridge for the Codex materializer.\n *\n * The pure rendering logic lives in {@link ./codex-materialize.js}. This file\n * is the place callers (consolidation hooks, CLI, session-end hook) go when\n * they want the whole \"load memories from storage → render → write\" flow.\n *\n * Kept deliberately small so #378 never has to reach into orchestrator.ts /\n * importance.ts — the two files Wave 1 agents are editing concurrently.\n */\n\nimport path from \"node:path\";\nimport { existsSync } from \"node:fs\";\n\nimport { log } from \"../logger.js\";\nimport { StorageManager } from \"../storage.js\";\nimport type { PluginConfig, MemoryFile } from \"../types.js\";\nimport {\n  materializeForNamespace,\n  type MaterializeResult,\n  type RolloutSummaryInput,\n} from \"./codex-materialize.js\";\n\n/** Options accepted by the shared post-consolidation materialize helper. */\nexport interface PostConsolidationMaterializeOptions {\n  config: PluginConfig;\n  namespace?: string;\n  memories?: MemoryFile[];\n  memoryDir?: string;\n  codexHome?: string;\n  rolloutSummaries?: RolloutSummaryInput[];\n  now?: Date;\n}\n\n/** Options accepted by the runner. */\nexport interface RunMaterializeOptions {\n  /** Remnic config — we only read the `codexMaterialize*` fields. */\n  config: PluginConfig;\n  /** Namespace to materialize. Overrides the config's `codexMaterializeNamespace`. */\n  namespace?: string;\n  /** Override the memory directory (defaults to `config.memoryDir`). */\n  memoryDir?: string;\n  /** Override `<codex_home>` (useful for tests). */\n  codexHome?: string;\n  /** Optional pre-loaded memories (bypasses disk read — used in tests). */\n  memories?: MemoryFile[];\n  /** Optional rollout summaries supplied by the caller. */\n  rolloutSummaries?: RolloutSummaryInput[];\n  /** Current time injection for deterministic runs. */\n  now?: Date;\n  /** Reason string — logged for observability. */\n  reason?: \"consolidation\" | \"session_end\" | \"manual\" | \"cli\";\n}\n\n/**\n * Run the Codex materialization end-to-end. Returns `null` when the feature\n * is disabled in config or when the user hasn't opted in via the sentinel.\n * Never throws for \"expected\" skips; only throws on schema validation or I/O\n * errors that callers actually need to surface.\n */\nexport async function runCodexMaterialize(\n  options: RunMaterializeOptions,\n): Promise<MaterializeResult | null> {\n  const cfg = options.config;\n  if (!cfg.codexMaterializeMemories) {\n    log.debug(`[codex-materialize] skipped — codexMaterializeMemories=false`);\n    return null;\n  }\n\n  // Per-trigger gate: session-end runs must honor codexMaterializeOnSessionEnd.\n  // session-end.sh passes reason=\"session_end\"; when the user has turned off the\n  // session-end trigger we short-circuit here without touching disk.\n  if (options.reason === \"session_end\" && cfg.codexMaterializeOnSessionEnd === false) {\n    log.debug(\n      `[codex-materialize] skipped — session-end disabled via codexMaterializeOnSessionEnd=false`,\n    );\n    return null;\n  }\n\n  const namespace = resolveNamespace(options.namespace, cfg);\n  const memoryDir = options.memoryDir ?? cfg.memoryDir;\n  if (!memoryDir) {\n    log.warn(`[codex-materialize] skipped — no memoryDir available`);\n    return null;\n  }\n\n  let memories: MemoryFile[];\n  if (options.memories) {\n    memories = options.memories;\n  } else {\n    const nsDir = resolveNamespaceDir(memoryDir, namespace, cfg);\n    const storage = new StorageManager(nsDir);\n    try {\n      memories = await storage.readAllMemories();\n    } catch (error) {\n      log.warn(\n        `[codex-materialize] skipped — failed to read memories from ${nsDir}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n      return null;\n    }\n  }\n\n  // Intentionally NOT catching here: per the JSDoc contract above,\n  // schema-validation and I/O errors from `materializeForNamespace` must\n  // surface to callers so they can exit non-zero (CLI) or log + recover\n  // (consolidation post-hook, which has its own narrower try/catch).\n  // Catching everything would make a broken MEMORY.md render look like a\n  // successful skip, and invisible failures are strictly worse than loud\n  // ones for a feature that writes to `~/.codex/memories`.\n  const result = materializeForNamespace(namespace, {\n    memories,\n    codexHome: options.codexHome,\n    maxSummaryTokens: cfg.codexMaterializeMaxSummaryTokens,\n    rolloutRetentionDays: cfg.codexMaterializeRolloutRetentionDays,\n    rolloutSummaries: options.rolloutSummaries,\n    now: options.now,\n  });\n  if (options.reason) {\n    log.debug(\n      `[codex-materialize] ran reason=${options.reason} wrote=${result.wrote} files=${result.filesWritten.length}`,\n    );\n  }\n  return result;\n}\n\n/**\n * Shared helper for post-consolidation materialize hooks.\n *\n * `materializeAfterSemanticConsolidation` and `materializeAfterCausalConsolidation`\n * used to be two nearly-identical copies of this logic; keeping the actual\n * body here means any future guard/logging change happens in one place.\n *\n * The only per-caller knob is `logPrefix`, which is used to tag the\n * non-fatal warning emitted when the materializer throws.\n */\nexport async function runPostConsolidationMaterialize(\n  logPrefix: string,\n  options: PostConsolidationMaterializeOptions,\n): Promise<MaterializeResult | null> {\n  if (!options.config.codexMaterializeMemories) return null;\n  if (!options.config.codexMaterializeOnConsolidation) return null;\n  try {\n    return await runCodexMaterialize({\n      config: options.config,\n      namespace: options.namespace,\n      memories: options.memories,\n      memoryDir: options.memoryDir,\n      codexHome: options.codexHome,\n      rolloutSummaries: options.rolloutSummaries,\n      now: options.now,\n      reason: \"consolidation\",\n    });\n  } catch (error) {\n    log.warn(\n      `${logPrefix} Codex materialize post-hook failed (non-fatal): ${\n        error instanceof Error ? error.message : String(error)\n      }`,\n    );\n    return null;\n  }\n}\n\nfunction resolveNamespace(override: string | undefined, cfg: PluginConfig): string {\n  const requested = (override ?? cfg.codexMaterializeNamespace ?? \"auto\").trim();\n  if (requested.length === 0 || requested === \"auto\") {\n    // When the caller asks for \"auto\", fall back to the configured default\n    // namespace (if any) so storage-root resolution lines up with what\n    // NamespaceStorageRouter would do for the same install.\n    return cfg.defaultNamespace && cfg.defaultNamespace.length > 0\n      ? cfg.defaultNamespace\n      : \"default\";\n  }\n  return requested;\n}\n\n/**\n * Resolve the on-disk storage root for a namespace, matching\n * `NamespaceStorageRouter` in `packages/remnic-core/src/namespaces/storage.ts`.\n *\n * Contract:\n *  - When namespaces are disabled, every namespace maps to `memoryDir` itself.\n *  - When namespaces are enabled, non-default namespaces always live under\n *    `memoryDir/namespaces/<namespace>`.\n *  - The default namespace prefers `memoryDir/namespaces/<defaultNamespace>`\n *    when that directory already exists (migrated install); otherwise it\n *    falls back to the legacy `memoryDir` root so materialization does not\n *    silently switch directories out from under an existing install.\n */\nfunction resolveNamespaceDir(\n  memoryDir: string,\n  namespace: string,\n  cfg: PluginConfig,\n): string {\n  if (!cfg.namespacesEnabled) return memoryDir;\n\n  const ns = namespace || cfg.defaultNamespace || \"default\";\n  const namespacedRoot = path.join(memoryDir, \"namespaces\", ns);\n\n  if (ns === cfg.defaultNamespace) {\n    return existsSync(namespacedRoot) ? namespacedRoot : memoryDir;\n  }\n  return namespacedRoot;\n}\n","/**\n * codex-materialize.ts — Codex CLI native memory artifact materialization (#378)\n *\n * Periodically writes Remnic memories into the file layout that Codex CLI's\n * phase-2 consolidation reads directly under `<codex_home>/memories/`:\n *\n *   memory_summary.md                — always-loaded at session start (tight budget)\n *   MEMORY.md                        — searchable handbook (task-group schema)\n *   raw_memories.md                  — mechanical merge of raw memories, latest first\n *   rollout_summaries/<slug>.md      — per-session recaps\n *\n * Codex's own read path is agnostic to which producer wrote these files — it\n * tags reads by `memory_md` / `memory_summary` / `raw_memories` /\n * `rollout_summaries` / `skills`. By materializing Remnic content into this\n * exact layout we let Codex pick up Remnic memories without a single MCP call.\n *\n * Safety invariants\n * ─────────────────\n *  - **Atomic writes.** Every file is rendered under `.remnic-tmp/` and then\n *    `rename()`d into place so Codex never observes a half-written file.\n *  - **Sentinel-based opt-in.** If `<codex_home>/memories/.remnic-managed` is\n *    missing, we SKIP materialization entirely and log a warning. This honors\n *    user hand-edits to the directory — a user who manually curated their\n *    Codex memory layout will never have those edits overwritten.\n *  - **Schema validation.** `MEMORY.md` content is validated against the\n *    task-group schema before write. Invalid content throws and nothing is\n *    written.\n *  - **Idempotent no-ops.** A content hash is written into the sentinel. If\n *    the re-rendered hash matches the previous run, we skip writes entirely.\n *  - **Token budget.** `memory_summary.md` is truncated to fit under the\n *    configured token budget (whitespace-tokenized approximation), leaving\n *    headroom under Codex's 5000-token summary cap.\n *\n * Privacy\n * ───────\n * This module does not persist any user content outside `<codex_home>/memories`\n * — it only mirrors the memories that Remnic already wrote. It does not log\n * memory content to stdout; it logs file names, counts, and hashes.\n */\n\nimport {\n  createHash,\n} from \"node:crypto\";\nimport {\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  renameSync,\n  rmSync,\n  statSync,\n  unlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport path from \"node:path\";\n\nimport { log } from \"../logger.js\";\nimport { readEnvVar, resolveHomeDir } from \"../runtime/env.js\";\nimport type { MemoryFile } from \"../types.js\";\n\n// ─── Types ─────────────────────────────────────────────────────────────────\n\n/**\n * Input for {@link materializeForNamespace}. Prefer passing pre-loaded\n * `memories` so this module stays I/O-agnostic and trivially testable.\n */\nexport interface MaterializeOptions {\n  /** Pre-loaded Remnic memories for this namespace (required). */\n  memories: MemoryFile[];\n  /** Override `<codex_home>`. Defaults to `$CODEX_HOME` or `~/.codex`. */\n  codexHome?: string;\n  /** Maximum whitespace-tokenized size of memory_summary.md. Default 4500. */\n  maxSummaryTokens?: number;\n  /** Maximum age of rollout_summaries/*.md in days. Default 30. */\n  rolloutRetentionDays?: number;\n  /** Per-session rollout summaries to render. */\n  rolloutSummaries?: RolloutSummaryInput[];\n  /** Current time, injected for deterministic tests. */\n  now?: Date;\n  /** Optional logger override for tests. */\n  logger?: { info: (msg: string) => void; warn: (msg: string) => void; debug?: (msg: string) => void };\n}\n\n/** Input describing one Codex rollout summary file. */\nexport interface RolloutSummaryInput {\n  /** Stable slug for the file (becomes `<slug>.md`). */\n  slug: string;\n  /** Working directory used during the rollout. */\n  cwd?: string;\n  /** Path to the raw Codex rollout log, if known. */\n  rolloutPath?: string;\n  /** ISO-8601 timestamp of the last update. */\n  updatedAt?: string;\n  /** Opaque thread / session id. */\n  threadId?: string;\n  /** Markdown body for the recap. */\n  body: string;\n  /** Freeform keywords / search hints. */\n  keywords?: string[];\n}\n\n/** Result of a materialization run. */\nexport interface MaterializeResult {\n  /** Namespace that was materialized. */\n  namespace: string;\n  /** `<codex_home>/memories` path this run targeted. */\n  memoriesDir: string;\n  /** Was anything actually written (vs. skipped / idempotent no-op)? */\n  wrote: boolean;\n  /** True if the sentinel was missing and we skipped with a warning. */\n  skippedNoSentinel: boolean;\n  /** True if the hash matched the previous run and we short-circuited. */\n  skippedIdempotent: boolean;\n  /** Files that were written this run (relative to `memoriesDir`). */\n  filesWritten: string[];\n  /** Content hash computed for this run. */\n  contentHash: string;\n}\n\n/** On-disk shape of the `.remnic-managed` sentinel. */\ninterface SentinelFile {\n  version: number;\n  namespace: string;\n  updated_at: string;\n  content_hash: string;\n}\n\n// ─── Constants ─────────────────────────────────────────────────────────────\n\n/** Bump when the on-disk layout or semantics change. */\nexport const MATERIALIZE_VERSION = 1;\n\n/** Sentinel file name at the root of the materialized memories dir. */\nexport const SENTINEL_FILE = \".remnic-managed\";\n\n/** Scratch directory used for atomic renames. */\nexport const TMP_DIR = \".remnic-tmp\";\n\n/** File names we own. Anything else in the directory is considered user-managed. */\nconst OWNED_FILES = new Set<string>([\n  \"memory_summary.md\",\n  \"MEMORY.md\",\n  \"raw_memories.md\",\n]);\n\n/** Sub-directory for per-session rollout recaps. */\nconst ROLLOUT_SUBDIR = \"rollout_summaries\";\n\n// ─── Public entry points ───────────────────────────────────────────────────\n\n/**\n * Materialize a Remnic namespace into Codex's native memory layout.\n *\n * Returns a {@link MaterializeResult} describing what happened. Callers\n * should treat \"skipped\" as success — the sentinel / idempotent cases are\n * expected and intentional.\n *\n * @throws if `MEMORY.md` fails schema validation (we do not write garbage).\n */\nexport function materializeForNamespace(\n  namespace: string,\n  options: MaterializeOptions,\n): MaterializeResult {\n  const logger = options.logger ?? {\n    info: (msg) => log.info(`[codex-materialize] ${msg}`),\n    warn: (msg) => log.warn(`[codex-materialize] ${msg}`),\n    debug: (msg) => log.debug(`[codex-materialize] ${msg}`),\n  };\n  const codexHome = resolveCodexHome(options.codexHome);\n  const memoriesDir = path.join(codexHome, \"memories\");\n  const now = options.now ?? new Date();\n  // Honor `0` as \"no summary budget\" — parseConfig already clamps to non-\n  // negative integers, so any provided number is meaningful. Only fall back\n  // to the default when the caller did not provide the option at all.\n  const maxSummaryTokens =\n    typeof options.maxSummaryTokens === \"number\" && options.maxSummaryTokens >= 0\n      ? options.maxSummaryTokens\n      : 4500;\n  const rolloutRetentionDays =\n    typeof options.rolloutRetentionDays === \"number\" && options.rolloutRetentionDays >= 0\n      ? options.rolloutRetentionDays\n      : 30;\n\n  // ── Sentinel check ─────────────────────────────────────────────────────\n  // We deliberately do NOT `mkdirSync(memoriesDir)` before reading the\n  // sentinel: creating `~/.codex/memories/` for every user (including ones\n  // who never use Codex) would make Remnic's post-consolidation hook leave\n  // empty opt-in directories behind on disk. Instead we only check whether\n  // the sentinel already exists — if the parent dir doesn't exist, the\n  // sentinel can't exist either and we fall straight through to the skip\n  // path without touching the filesystem. The `mkdirSync` for `memoriesDir`\n  // happens later, only once we know we're actually going to write.\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  const existingSentinel = readSentinel(sentinelPath);\n  if (!existingSentinel) {\n    // Log at `debug` when the entire memories dir doesn't exist — that's\n    // the common \"user never opted in\" case and should not be noisy.\n    // Keep the `warn` level only when the dir exists but lacks a sentinel,\n    // which is the \"user hand-curated layout, don't overwrite\" case that\n    // genuinely warrants attention.\n    if (existsSync(memoriesDir)) {\n      logger.warn(\n        `sentinel ${SENTINEL_FILE} missing in ${memoriesDir}; skipping materialization to preserve hand-edits`,\n      );\n    } else {\n      logger.debug?.(\n        `skipping materialization — ${memoriesDir} does not exist (user not opted in)`,\n      );\n    }\n    return {\n      namespace,\n      memoriesDir,\n      wrote: false,\n      skippedNoSentinel: true,\n      skippedIdempotent: false,\n      filesWritten: [],\n      contentHash: \"\",\n    };\n  }\n\n  // Now that we know the user has opted in (sentinel exists), it's safe to\n  // ensure the memories dir is present. In practice this is almost always a\n  // no-op because the sentinel read above already succeeded, but a defensive\n  // mkdirSync protects against a race where the dir was removed between the\n  // sentinel read and the first write.\n  mkdirSync(memoriesDir, { recursive: true });\n\n  // ── Render ─────────────────────────────────────────────────────────────\n  const memories = [...options.memories];\n  // Track whether the caller actually supplied a rollout set. `undefined`\n  // means \"don't touch rollout_summaries/\"; an empty array is still\n  // authoritative and means \"we own this dir and it should be empty\".\n  const rolloutsSupplied = options.rolloutSummaries !== undefined;\n  const rolloutSummaries = options.rolloutSummaries ?? [];\n\n  // Prune-before-render: MEMORY.md and memory_summary.md both embed rollout\n  // filenames in their body, so they must only ever see the *retained* set.\n  // Running pruneRollouts after the renderers (as an earlier revision did)\n  // caused MEMORY.md to list `rollout_summaries/<slug>.md` paths for rollouts\n  // that were then pruned and never written — a broken link pointing at a\n  // ghost file. See review feedback on PR #392.\n  const retainedRollouts = pruneRollouts(rolloutSummaries, rolloutRetentionDays, now);\n\n  // Deduplicate on sanitized filename. Two different slugs (\"Session 1\" and\n  // \"session!!!1\") can sanitize to the same output (\"session-1\"), which would\n  // otherwise make the first entry's tmp file get overwritten and cause the\n  // later rename step to crash with ENOENT. For each collision slot we keep\n  // the entry with the newest `updatedAt` so an unsorted input (or a caller\n  // that accidentally appends older recaps after newer ones) can't have an\n  // older recap clobber a newer one.\n  // We do this at the retained-input level (not just at the written-file\n  // level) so MEMORY.md's \"rollout_summary_files\" section lists each slot\n  // exactly once and matches what actually gets written to disk.\n  const dedupedRollouts: RolloutSummaryInput[] = [];\n  const seenNames = new Map<string, number>();\n  const parseTs = (value: string | undefined): number => {\n    if (!value) return Number.NEGATIVE_INFINITY;\n    const parsed = Date.parse(value);\n    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;\n  };\n  for (const r of retainedRollouts) {\n    const name = `${sanitizeSlug(r.slug)}.md`;\n    const existingIdx = seenNames.get(name);\n    if (existingIdx === undefined) {\n      seenNames.set(name, dedupedRollouts.length);\n      dedupedRollouts.push(r);\n      continue;\n    }\n    // Newest-wins: only replace the existing entry if the incoming one has a\n    // strictly newer timestamp. Ties keep the earlier entry (stable for\n    // unsorted inputs) because overwriting on ties would flip rendering output\n    // for benign call-order changes.\n    const existing = dedupedRollouts[existingIdx];\n    if (parseTs(r.updatedAt) > parseTs(existing.updatedAt)) {\n      dedupedRollouts[existingIdx] = r;\n    }\n  }\n\n  const memorySummary = renderMemorySummary({\n    namespace,\n    memories,\n    rolloutSummaries: dedupedRollouts,\n    maxTokens: maxSummaryTokens,\n  });\n\n  const memoryMd = renderMemoryMd({\n    namespace,\n    memories,\n    rolloutSummaries: dedupedRollouts,\n  });\n\n  // Fail fast on schema issues — do not write garbage.\n  const validation = validateMemoryMd(memoryMd);\n  if (!validation.valid) {\n    const reason = validation.errors.join(\"; \");\n    logger.warn(`MEMORY.md failed schema validation: ${reason}`);\n    throw new Error(`codex-materialize: MEMORY.md schema validation failed: ${reason}`);\n  }\n\n  const rawMemories = renderRawMemories({ memories });\n\n  const rolloutFiles = dedupedRollouts.map((r) => ({\n    name: `${sanitizeSlug(r.slug)}.md`,\n    body: renderRolloutSummary(r),\n  }));\n\n  // ── Idempotence check ──────────────────────────────────────────────────\n  const hash = computeContentHash({\n    namespace,\n    memorySummary,\n    memoryMd,\n    rawMemories,\n    rolloutFiles,\n  });\n\n  if (existingSentinel.content_hash === hash) {\n    // Idempotence early-return is only safe when the managed files we would\n    // have written are still on disk. If a user or external process deleted\n    // `MEMORY.md` / `memory_summary.md` / `raw_memories.md` (or any retained\n    // rollout file) while the sentinel's hash stayed the same, we must fall\n    // through and rewrite — otherwise Codex would be stuck with missing\n    // artifacts until a memory-content change happens to flip the hash.\n    const requiredFiles = [\n      path.join(memoriesDir, \"memory_summary.md\"),\n      path.join(memoriesDir, \"MEMORY.md\"),\n      path.join(memoriesDir, \"raw_memories.md\"),\n      ...rolloutFiles.map((r) => path.join(memoriesDir, ROLLOUT_SUBDIR, r.name)),\n    ];\n    const allPresent = requiredFiles.every((f) => existsSync(f));\n    if (allPresent) {\n      logger.debug?.(`no-op materialization for namespace=${namespace} (hash unchanged)`);\n      return {\n        namespace,\n        memoriesDir,\n        wrote: false,\n        skippedNoSentinel: false,\n        skippedIdempotent: true,\n        filesWritten: [],\n        contentHash: hash,\n      };\n    }\n    logger.debug?.(\n      `hash unchanged for namespace=${namespace} but managed file missing — forcing rewrite`,\n    );\n  }\n\n  // ── Atomic writes ──────────────────────────────────────────────────────\n  // Use a unique, per-run staging sub-directory so two overlapping runs\n  // (e.g. a session-end trigger overlapping with a consolidation post-hook)\n  // can't stomp each other's tmp files mid-rename. The old \"fixed TMP_DIR,\n  // wipe-on-entry\" layout meant run B would delete run A's staging area out\n  // from under it, causing ENOENT on A's rename loop. Per-run uniqueness\n  // turns the shared dir into an insulated workspace. See review feedback on\n  // PR #392.\n  const runTag = `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n  const tmpDir = path.join(memoriesDir, `${TMP_DIR}-${runTag}`);\n  // Opportunistic GC for stale scratch dirs left behind by a previous\n  // crashed run. We only remove entries whose mtime is older than the\n  // stale-threshold below — that way we never delete another in-flight\n  // run's staging area out from under it. The threshold is deliberately\n  // generous (1h) because a healthy materialize completes in milliseconds\n  // and there's no legitimate reason for a live staging dir to be older.\n  //\n  // NB: we compare against `Date.now()` (wall-clock), not against the\n  // injected `options.now`. Tests and deterministic replays commonly\n  // inject a non-current timestamp, but file mtimes on disk are always\n  // wall-clock, so mixing the two would either false-positive delete\n  // fresh dirs (test-time in the past) or false-negative skip stale ones\n  // (test-time in the future).\n  const TMP_STALE_MS = 60 * 60 * 1000;\n  const wallClockMs = Date.now();\n  try {\n    for (const entry of readdirSync(memoriesDir, { withFileTypes: true })) {\n      if (!entry.isDirectory()) continue;\n      if (!entry.name.startsWith(TMP_DIR)) continue;\n      const stalePath = path.join(memoriesDir, entry.name);\n      try {\n        const stat = statSync(stalePath);\n        if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;\n        rmSync(stalePath, { recursive: true, force: true });\n      } catch {\n        // ignore — another concurrent run may own it, or we lack perms\n      }\n    }\n  } catch {\n    // ignore — dir may not exist yet\n  }\n  mkdirSync(tmpDir, { recursive: true });\n  mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });\n\n  const filesWritten: string[] = [];\n\n  writeFileSync(path.join(tmpDir, \"memory_summary.md\"), memorySummary);\n  filesWritten.push(\"memory_summary.md\");\n\n  writeFileSync(path.join(tmpDir, \"MEMORY.md\"), memoryMd);\n  filesWritten.push(\"MEMORY.md\");\n\n  writeFileSync(path.join(tmpDir, \"raw_memories.md\"), rawMemories);\n  filesWritten.push(\"raw_memories.md\");\n\n  for (const rollout of rolloutFiles) {\n    writeFileSync(path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);\n    filesWritten.push(path.join(ROLLOUT_SUBDIR, rollout.name));\n  }\n\n  // Rename into place. Atomic per-file is sufficient — Codex reads each file\n  // independently and tolerates an inconsistent in-between snapshot across\n  // files for the duration of the rename loop (milliseconds).\n  for (const rel of [\"memory_summary.md\", \"MEMORY.md\", \"raw_memories.md\"]) {\n    const src = path.join(tmpDir, rel);\n    const dest = path.join(memoriesDir, rel);\n    renameSync(src, dest);\n  }\n\n  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);\n  mkdirSync(destRolloutsDir, { recursive: true });\n  // Only garbage-collect rollout files when the caller actually supplied a\n  // `rolloutSummaries` array — otherwise we'd wipe legitimately\n  // user/Codex-created recap files on every session-end run, since those\n  // calls typically omit the rollout set entirely. When rollouts were\n  // supplied (even as an empty array — meaning \"we own this dir and it\n  // should be empty\"), we clear the stale files we previously owned.\n  if (rolloutsSupplied) {\n    const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));\n    try {\n      for (const entry of readdirSync(destRolloutsDir, { withFileTypes: true })) {\n        if (!entry.isFile()) continue;\n        if (!entry.name.endsWith(\".md\")) continue;\n        if (retainedRolloutNames.has(entry.name)) continue;\n        try {\n          unlinkSync(path.join(destRolloutsDir, entry.name));\n        } catch {\n          // ignore\n        }\n      }\n    } catch {\n      // ignore — directory may not exist yet\n    }\n  }\n\n  for (const rollout of rolloutFiles) {\n    const src = path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);\n    const dest = path.join(destRolloutsDir, rollout.name);\n    renameSync(src, dest);\n  }\n\n  // Update sentinel last so a crash leaves hash mismatched → next run rewrites.\n  const sentinel: SentinelFile = {\n    version: MATERIALIZE_VERSION,\n    namespace,\n    updated_at: now.toISOString(),\n    content_hash: hash,\n  };\n  writeFileSync(sentinelPath, `${JSON.stringify(sentinel, null, 2)}\\n`);\n\n  try {\n    rmSync(tmpDir, { recursive: true, force: true });\n  } catch {\n    // ignore\n  }\n\n  logger.info(\n    `materialized namespace=${namespace} files=${filesWritten.length} hash=${hash.slice(0, 12)}`,\n  );\n\n  return {\n    namespace,\n    memoriesDir,\n    wrote: true,\n    skippedNoSentinel: false,\n    skippedIdempotent: false,\n    filesWritten,\n    contentHash: hash,\n  };\n}\n\n/**\n * Create (or refresh) the `.remnic-managed` sentinel. Callers must do this\n * explicitly the first time they want Remnic to start managing a directory —\n * we never write it implicitly, because its presence is the user's opt-in.\n */\nexport function ensureSentinel(memoriesDir: string, namespace: string, now: Date = new Date()): void {\n  mkdirSync(memoriesDir, { recursive: true });\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  if (existsSync(sentinelPath)) return;\n  const sentinel: SentinelFile = {\n    version: MATERIALIZE_VERSION,\n    namespace,\n    updated_at: now.toISOString(),\n    content_hash: \"\",\n  };\n  writeFileSync(sentinelPath, `${JSON.stringify(sentinel, null, 2)}\\n`);\n}\n\n// ─── Rendering ─────────────────────────────────────────────────────────────\n\ninterface RenderContext {\n  namespace: string;\n  memories: MemoryFile[];\n  rolloutSummaries: RolloutSummaryInput[];\n  // Historically this interface exposed a `now: Date` field, but neither\n  // `renderMemoryMd` nor `renderMemorySummary` ever read it (rendered output\n  // is purely a function of `namespace`, `memories`, and `rolloutSummaries`).\n  // The field was flagged as dead weight in PR #392 review and removed.\n  // If a future renderer needs a timestamp, re-add it here and update both\n  // call sites and the schema test.\n}\n\ninterface SummaryRenderContext extends RenderContext {\n  maxTokens: number;\n}\n\n/**\n * Render `memory_summary.md` — the always-loaded file.\n * Budget-capped at `maxTokens` whitespace tokens.\n */\nexport function renderMemorySummary(ctx: SummaryRenderContext): string {\n  const lines: string[] = [];\n  lines.push(\"# Memory Summary\");\n  lines.push(\"\");\n  lines.push(`_namespace: ${ctx.namespace}_`);\n  lines.push(`_source: remnic_`);\n  lines.push(\"\");\n\n  const highValue = selectSummaryMemories(ctx.memories, 12);\n  if (highValue.length > 0) {\n    lines.push(\"## Top memories\");\n    lines.push(\"\");\n    for (const mem of highValue) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n    lines.push(\"\");\n  }\n\n  if (ctx.rolloutSummaries.length > 0) {\n    lines.push(\"## Recent rollouts\");\n    lines.push(\"\");\n    const sorted = [...ctx.rolloutSummaries]\n      .sort((a, b) => (b.updatedAt ?? \"\").localeCompare(a.updatedAt ?? \"\"))\n      .slice(0, 5);\n    for (const r of sorted) {\n      const when = r.updatedAt ? ` (${r.updatedAt})` : \"\";\n      lines.push(`- ${r.slug}${when}`);\n    }\n    lines.push(\"\");\n  }\n\n  const full = lines.join(\"\\n\").replace(/\\n+$/u, \"\\n\");\n  return truncateToTokenBudget(full, ctx.maxTokens);\n}\n\n/**\n * Render `MEMORY.md` — the searchable handbook in Codex's task-group schema.\n */\nexport function renderMemoryMd(ctx: RenderContext): string {\n  const lines: string[] = [];\n  lines.push(`# Task Group: ${ctx.namespace}`);\n  lines.push(`scope: ${ctx.namespace}`);\n  lines.push(`applies_to: cwd=*; reuse_rule=namespace-match`);\n  lines.push(\"\");\n\n  // One \"task\" per top-level topic cluster. For the first cut we group by\n  // memory category so the schema validator always sees at least one task.\n  const byCategory = groupMemoriesByCategory(ctx.memories);\n  let taskIndex = 1;\n  if (byCategory.size === 0) {\n    lines.push(`## Task ${taskIndex}: baseline — no memories yet`);\n    lines.push(\"\");\n    lines.push(\"### rollout_summary_files\");\n    for (const r of ctx.rolloutSummaries) {\n      lines.push(\n        `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? \"*\"}, rollout_path=${r.rolloutPath ?? \"\"}, updated_at=${r.updatedAt ?? \"\"}, thread_id=${r.threadId ?? \"\"})`,\n      );\n    }\n    if (ctx.rolloutSummaries.length === 0) {\n      lines.push(\"- (none)\");\n    }\n    lines.push(\"\");\n    lines.push(\"### keywords\");\n    lines.push(`- ${ctx.namespace}`);\n    lines.push(\"\");\n    taskIndex += 1;\n  } else {\n    for (const [category, mems] of byCategory) {\n      lines.push(`## Task ${taskIndex}: ${category} memories, outcome=surface-to-codex`);\n      lines.push(\"\");\n      lines.push(\"### rollout_summary_files\");\n      const relevantRollouts = ctx.rolloutSummaries.slice(0, 5);\n      if (relevantRollouts.length === 0) {\n        lines.push(\"- (none)\");\n      } else {\n        for (const r of relevantRollouts) {\n          lines.push(\n            `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? \"*\"}, rollout_path=${r.rolloutPath ?? \"\"}, updated_at=${r.updatedAt ?? \"\"}, thread_id=${r.threadId ?? \"\"})`,\n          );\n        }\n      }\n      lines.push(\"\");\n      lines.push(\"### keywords\");\n      const keywords = collectKeywords(mems, category, ctx.namespace);\n      lines.push(`- ${keywords.join(\", \")}`);\n      lines.push(\"\");\n      taskIndex += 1;\n    }\n  }\n\n  lines.push(\"## User preferences\");\n  const prefs = pickCategory(ctx.memories, [\"preference\"]);\n  if (prefs.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const pref of prefs.slice(0, 20)) {\n      lines.push(`- ${oneLineSummary(pref)}`);\n    }\n  }\n  lines.push(\"\");\n\n  lines.push(\"## Reusable knowledge\");\n  const knowledge = pickCategory(ctx.memories, [\"fact\", \"decision\", \"principle\", \"rule\", \"skill\"]);\n  if (knowledge.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const mem of knowledge.slice(0, 30)) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n  }\n  lines.push(\"\");\n\n  lines.push(\"## Failures and how to do differently\");\n  const corrections = pickCategory(ctx.memories, [\"correction\"]);\n  if (corrections.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const mem of corrections.slice(0, 20)) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n  }\n  lines.push(\"\");\n\n  return lines.join(\"\\n\");\n}\n\n/** Render `raw_memories.md` — mechanical dump, latest first. */\nexport function renderRawMemories(ctx: { memories: MemoryFile[] }): string {\n  const sorted = [...ctx.memories].sort((a, b) => {\n    const aUpdated = a.frontmatter.updated ?? a.frontmatter.created ?? \"\";\n    const bUpdated = b.frontmatter.updated ?? b.frontmatter.created ?? \"\";\n    return bUpdated.localeCompare(aUpdated);\n  });\n\n  const lines: string[] = [\"# Raw Memories\", \"\", \"_source: remnic — latest first_\", \"\"];\n  for (const mem of sorted) {\n    const fm = mem.frontmatter;\n    const id = fm.id ?? \"unknown\";\n    const category = fm.category ?? \"unknown\";\n    const updated = fm.updated ?? fm.created ?? \"\";\n    lines.push(`## ${id} (${category}, updated=${updated})`);\n    lines.push(\"\");\n    lines.push(mem.content.trim());\n    lines.push(\"\");\n  }\n  return lines.join(\"\\n\");\n}\n\n/** Render a single rollout summary file. */\nexport function renderRolloutSummary(input: RolloutSummaryInput): string {\n  const lines: string[] = [];\n  lines.push(`# Rollout Summary: ${input.slug}`);\n  lines.push(\"\");\n  const meta: string[] = [];\n  if (input.cwd) meta.push(`cwd=${input.cwd}`);\n  if (input.rolloutPath) meta.push(`rollout_path=${input.rolloutPath}`);\n  if (input.updatedAt) meta.push(`updated_at=${input.updatedAt}`);\n  if (input.threadId) meta.push(`thread_id=${input.threadId}`);\n  if (meta.length > 0) {\n    lines.push(`_${meta.join(\"; \")}_`);\n    lines.push(\"\");\n  }\n  if (input.keywords && input.keywords.length > 0) {\n    lines.push(`**keywords:** ${input.keywords.join(\", \")}`);\n    lines.push(\"\");\n  }\n  lines.push(input.body.trim());\n  lines.push(\"\");\n  return lines.join(\"\\n\");\n}\n\n// ─── Schema validation ─────────────────────────────────────────────────────\n\nexport interface MemoryMdValidation {\n  valid: boolean;\n  errors: string[];\n}\n\n/**\n * Validate that a rendered `MEMORY.md` matches Codex's task-group schema.\n * We enforce the minimum set of structural requirements called out in #378:\n *\n *  - one `# Task Group:` header\n *  - `scope:` and `applies_to:` lines directly beneath it\n *  - at least one `## Task N:` section\n *  - each task section has `### rollout_summary_files` and `### keywords`\n *  - `## User preferences`, `## Reusable knowledge`,\n *    `## Failures and how to do differently` sections all present\n */\nexport function validateMemoryMd(content: string): MemoryMdValidation {\n  const errors: string[] = [];\n  const lines = content.split(/\\r?\\n/u);\n\n  const taskGroupIndex = lines.findIndex((l) => /^#\\s+Task Group:\\s+\\S+/u.test(l));\n  if (taskGroupIndex === -1) {\n    errors.push(\"missing `# Task Group:` header\");\n  } else {\n    const tail = lines.slice(taskGroupIndex + 1, taskGroupIndex + 5);\n    if (!tail.some((l) => /^scope:\\s*\\S+/u.test(l))) {\n      errors.push(\"missing `scope:` line under Task Group header\");\n    }\n    if (!tail.some((l) => /^applies_to:\\s*\\S+/u.test(l))) {\n      errors.push(\"missing `applies_to:` line under Task Group header\");\n    }\n  }\n\n  const taskHeaders = lines.filter((l) => /^##\\s+Task\\s+\\d+:/u.test(l));\n  if (taskHeaders.length === 0) {\n    errors.push(\"at least one `## Task N:` section is required\");\n  }\n\n  // For every task section, make sure we have rollout_summary_files + keywords\n  // before the next `##` header at the same level.\n  const sectionRegex = /^##\\s+/u;\n  for (let i = 0; i < lines.length; i++) {\n    if (!/^##\\s+Task\\s+\\d+:/u.test(lines[i])) continue;\n    let hasRollout = false;\n    let hasKeywords = false;\n    for (let j = i + 1; j < lines.length; j++) {\n      if (sectionRegex.test(lines[j])) break;\n      if (/^###\\s+rollout_summary_files\\s*$/u.test(lines[j])) hasRollout = true;\n      if (/^###\\s+keywords\\s*$/u.test(lines[j])) hasKeywords = true;\n    }\n    if (!hasRollout) errors.push(`task block at line ${i + 1} missing \\`### rollout_summary_files\\``);\n    if (!hasKeywords) errors.push(`task block at line ${i + 1} missing \\`### keywords\\``);\n  }\n\n  const requiredSections = [\n    /^##\\s+User preferences\\s*$/u,\n    /^##\\s+Reusable knowledge\\s*$/u,\n    /^##\\s+Failures and how to do differently\\s*$/u,\n  ];\n  for (const re of requiredSections) {\n    if (!lines.some((l) => re.test(l))) {\n      errors.push(`missing required section: ${re.source}`);\n    }\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n\n// ─── Helpers ───────────────────────────────────────────────────────────────\n\nfunction resolveCodexHome(override?: string): string {\n  if (override && override.trim().length > 0) return override;\n  const fromEnv = readEnvVar(\"CODEX_HOME\");\n  if (fromEnv && fromEnv.trim().length > 0) return fromEnv;\n  return path.join(resolveHomeDir(), \".codex\");\n}\n\nfunction readSentinel(sentinelPath: string): SentinelFile | null {\n  if (!existsSync(sentinelPath)) return null;\n  try {\n    const raw = readFileSync(sentinelPath, \"utf-8\");\n    const parsed = JSON.parse(raw) as Partial<SentinelFile>;\n    if (typeof parsed !== \"object\" || parsed === null) return null;\n    return {\n      version: typeof parsed.version === \"number\" ? parsed.version : MATERIALIZE_VERSION,\n      namespace: typeof parsed.namespace === \"string\" ? parsed.namespace : \"\",\n      updated_at: typeof parsed.updated_at === \"string\" ? parsed.updated_at : \"\",\n      content_hash: typeof parsed.content_hash === \"string\" ? parsed.content_hash : \"\",\n    };\n  } catch {\n    return null;\n  }\n}\n\nfunction selectSummaryMemories(memories: MemoryFile[], limit: number): MemoryFile[] {\n  const scored = memories\n    .filter((m) => !m.frontmatter.status || m.frontmatter.status === \"active\")\n    .map((m) => {\n      const confidence = typeof m.frontmatter.confidence === \"number\" ? m.frontmatter.confidence : 0;\n      const importance =\n        typeof m.frontmatter.importance === \"object\" &&\n        m.frontmatter.importance !== null &&\n        typeof (m.frontmatter.importance as { score?: number }).score === \"number\"\n          ? ((m.frontmatter.importance as { score: number }).score ?? 0)\n          : 0;\n      const updated = m.frontmatter.updated ?? m.frontmatter.created ?? \"\";\n      return { memory: m, score: importance * 2 + confidence, updated };\n    });\n\n  scored.sort((a, b) => {\n    if (b.score !== a.score) return b.score - a.score;\n    return b.updated.localeCompare(a.updated);\n  });\n\n  return scored.slice(0, limit).map((s) => s.memory);\n}\n\nfunction oneLineSummary(memory: MemoryFile): string {\n  const raw = memory.content.replace(/\\s+/gu, \" \").trim();\n  if (raw.length <= 160) return raw;\n  return `${raw.slice(0, 157)}...`;\n}\n\nfunction groupMemoriesByCategory(memories: MemoryFile[]): Map<string, MemoryFile[]> {\n  const map = new Map<string, MemoryFile[]>();\n  for (const memory of memories) {\n    if (memory.frontmatter.status && memory.frontmatter.status !== \"active\") continue;\n    const category = memory.frontmatter.category ?? \"unknown\";\n    const list = map.get(category) ?? [];\n    list.push(memory);\n    map.set(category, list);\n  }\n  return map;\n}\n\nfunction pickCategory(memories: MemoryFile[], categories: string[]): MemoryFile[] {\n  const allowed = new Set(categories);\n  return memories.filter(\n    (m) =>\n      (!m.frontmatter.status || m.frontmatter.status === \"active\") &&\n      allowed.has(m.frontmatter.category ?? \"\"),\n  );\n}\n\nfunction collectKeywords(memories: MemoryFile[], category: string, namespace: string): string[] {\n  const keywords = new Set<string>();\n  keywords.add(category);\n  keywords.add(namespace);\n  for (const mem of memories.slice(0, 10)) {\n    for (const tag of mem.frontmatter.tags ?? []) {\n      if (typeof tag === \"string\" && tag.trim().length > 0) keywords.add(tag.trim());\n    }\n  }\n  return [...keywords].slice(0, 16);\n}\n\nfunction pruneRollouts(\n  rollouts: RolloutSummaryInput[],\n  retentionDays: number,\n  now: Date,\n): RolloutSummaryInput[] {\n  // Negative retention → \"infinite retention\" escape hatch. `parseConfig`\n  // clamps the knob to >= 0, so in practice only callers passing a negative\n  // value intentionally get the all-pass behavior.\n  if (retentionDays < 0) return rollouts;\n  // retentionDays === 0 → cutoff is exactly `now`, which prunes every\n  // rollout whose `updatedAt` is in the past (i.e. all of them in practice).\n  // This matches the documented semantics of \"retain for 0 days\".\n  const cutoffMs = now.getTime() - retentionDays * 24 * 60 * 60 * 1000;\n  return rollouts.filter((r) => {\n    if (!r.updatedAt) return true;\n    const t = Date.parse(r.updatedAt);\n    if (!Number.isFinite(t)) return true;\n    return t >= cutoffMs;\n  });\n}\n\nfunction sanitizeSlug(slug: string): string {\n  return slug\n    .toLowerCase()\n    .replace(/[^a-z0-9._-]+/gu, \"-\")\n    .replace(/^-+|-+$/gu, \"\")\n    .slice(0, 96)\n    || \"rollout\";\n}\n\n/**\n * Whitespace-tokenized approximation used by the budget check. Matches the\n * simple heuristic Codex's usage.rs reporting uses for the \"5000 token\"\n * memory_summary cap.\n */\nexport function approximateTokenCount(text: string): number {\n  const trimmed = text.trim();\n  if (trimmed.length === 0) return 0;\n  return trimmed.split(/\\s+/u).length;\n}\n\n/**\n * Truncate `text` so it fits under `maxTokens` whitespace tokens. We drop\n * trailing lines until we're under the budget and then append an ellipsis\n * marker so downstream readers can see that truncation happened.\n */\nexport function truncateToTokenBudget(text: string, maxTokens: number): string {\n  if (maxTokens <= 0) return \"\";\n  if (approximateTokenCount(text) <= maxTokens) return text;\n\n  // Reserve headroom for the truncation marker so the line-preserving path\n  // can actually fit the marker without flipping to the hard-cut fallback.\n  // Both markers are counted with the same whitespace heuristic the budget\n  // check uses, so the arithmetic stays consistent.\n  const lineMarker = \"_[truncated for summary budget]_\";\n  const tailMarker = \"[truncated]\";\n  const lineMarkerTokens = approximateTokenCount(lineMarker);\n  const tailMarkerTokens = approximateTokenCount(tailMarker);\n\n  const lines = text.split(/\\r?\\n/u);\n  const lineBudget = Math.max(0, maxTokens - lineMarkerTokens);\n  while (lines.length > 0 && approximateTokenCount(lines.join(\"\\n\")) > lineBudget) {\n    lines.pop();\n  }\n  lines.push(lineMarker);\n  let result = lines.join(\"\\n\");\n\n  // If a single huge line still blows the budget, hard-cut tokens. Reserve\n  // space for the tail marker's own token count so the final string stays\n  // within maxTokens rather than sneaking over by a few tokens.\n  if (approximateTokenCount(result) > maxTokens) {\n    const tokens = result.split(/\\s+/u);\n    const keep = Math.max(0, maxTokens - tailMarkerTokens);\n    result = keep > 0 ? `${tokens.slice(0, keep).join(\" \")} ${tailMarker}` : tailMarker;\n  }\n  return result;\n}\n\nfunction computeContentHash(input: {\n  namespace: string;\n  memorySummary: string;\n  memoryMd: string;\n  rawMemories: string;\n  rolloutFiles: Array<{ name: string; body: string }>;\n}): string {\n  const hash = createHash(\"sha256\");\n  hash.update(`v${MATERIALIZE_VERSION}\\n`);\n  hash.update(`namespace=${input.namespace}\\n`);\n  hash.update(\"---memory_summary---\\n\");\n  hash.update(input.memorySummary);\n  hash.update(\"\\n---memory_md---\\n\");\n  hash.update(input.memoryMd);\n  hash.update(\"\\n---raw_memories---\\n\");\n  hash.update(input.rawMemories);\n  const sortedRollouts = [...input.rolloutFiles].sort((a, b) => a.name.localeCompare(b.name));\n  for (const r of sortedRollouts) {\n    hash.update(`\\n---rollout:${r.name}---\\n`);\n    hash.update(r.body);\n  }\n  return hash.digest(\"hex\");\n}\n\n// ─── Stat helper for tests / debugging ─────────────────────────────────────\n\n/**\n * Return basic stats about a materialized memories dir. Useful for tests and\n * debug CLI output. Returns `null` if the dir does not exist.\n */\nexport function describeMemoriesDir(memoriesDir: string): {\n  exists: boolean;\n  hasSentinel: boolean;\n  files: string[];\n  sentinel: SentinelFile | null;\n} | null {\n  if (!existsSync(memoriesDir)) return null;\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  const sentinel = readSentinel(sentinelPath);\n  const files: string[] = [];\n  for (const entry of readdirSync(memoriesDir, { withFileTypes: true })) {\n    if (entry.isFile() && OWNED_FILES.has(entry.name)) files.push(entry.name);\n  }\n  const rolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);\n  if (existsSync(rolloutsDir)) {\n    try {\n      for (const entry of readdirSync(rolloutsDir, { withFileTypes: true })) {\n        if (entry.isFile() && entry.name.endsWith(\".md\")) {\n          files.push(path.join(ROLLOUT_SUBDIR, entry.name));\n        }\n      }\n    } catch {\n      // ignore\n    }\n  }\n  return {\n    exists: true,\n    hasSentinel: sentinel !== null,\n    files: files.sort(),\n    sentinel,\n  };\n}\n","/**\n * semantic-consolidation.ts — Semantic Consolidation Engine\n *\n * Finds clusters of semantically similar memories using token overlap,\n * synthesizes canonical versions via LLM, and archives the originals.\n * Reduces memory store bloat while preserving all unique information.\n */\n\nimport type { MemoryFile, PluginConfig } from \"./types.js\";\nimport { normalizeRecallTokens, countRecallTokenOverlap } from \"./recall-tokenization.js\";\nimport { runPostConsolidationMaterialize } from \"./connectors/codex-materialize-runner.js\";\nimport type { MaterializeResult, RolloutSummaryInput } from \"./connectors/codex-materialize.js\";\nimport { discoverMemoryExtensions, renderExtensionsBlock, resolveExtensionsRoot } from \"./memory-extension-host/index.js\";\nimport { log } from \"./logger.js\";\n\n// Re-export resolveExtensionsRoot for backward compatibility — existing\n// consumers that import from semantic-consolidation.ts continue to work.\nexport { resolveExtensionsRoot } from \"./memory-extension-host/index.js\";\n\n// Operator vocabulary (issue #561).  The types and validators live in a\n// standalone `consolidation-operator.ts` module so `storage.ts` can import\n// them without creating a `storage → semantic-consolidation →\n// codex-materialize-runner → storage` cycle.  Re-exported here so existing\n// consumers that reach for `./semantic-consolidation.js` keep working.\nexport {\n  CONSOLIDATION_OPERATORS,\n  isConsolidationOperator,\n  isSemanticConsolidationLlmOperator,\n  isValidDerivedFromEntry,\n  type ConsolidationOperator,\n  type SemanticConsolidationLlmOperator,\n} from \"./consolidation-operator.js\";\n\nimport {\n  CONSOLIDATION_OPERATORS as _CONSOLIDATION_OPERATORS,\n  isConsolidationOperator as _isConsolidationOperator,\n  isSemanticConsolidationLlmOperator as _isSemanticConsolidationLlmOperator,\n  type ConsolidationOperator as _ConsolidationOperator,\n  type SemanticConsolidationLlmOperator as _SemanticConsolidationLlmOperator,\n} from \"./consolidation-operator.js\";\n\nexport interface ConsolidationCluster {\n  category: string;\n  memories: MemoryFile[];\n  overlapScore: number;\n  canonicalContent?: string;\n}\n\nexport interface SemanticConsolidationResult {\n  clustersFound: number;\n  memoriesConsolidated: number;\n  memoriesArchived: number;\n  errors: number;\n  clusters: ConsolidationCluster[];\n}\n\n/**\n * Find clusters of semantically similar memories using token overlap.\n */\nexport function findSimilarClusters(\n  memories: MemoryFile[],\n  config: {\n    threshold: number;\n    minClusterSize: number;\n    excludeCategories: string[];\n    maxPerRun: number;\n  },\n): ConsolidationCluster[] {\n  const excluded = new Set(config.excludeCategories);\n\n  // Group by category first\n  const byCategory = new Map<string, MemoryFile[]>();\n  for (const m of memories) {\n    const cat = m.frontmatter.category;\n    if (excluded.has(cat)) continue;\n    if (m.frontmatter.status && m.frontmatter.status !== \"active\") continue;\n    const list = byCategory.get(cat) ?? [];\n    list.push(m);\n    byCategory.set(cat, list);\n  }\n\n  const clusters: ConsolidationCluster[] = [];\n  let totalCandidates = 0;\n\n  for (const [category, mems] of byCategory) {\n    if (totalCandidates >= config.maxPerRun) break;\n\n    // Token-normalize all memories in this category\n    const tokenized = mems.map((m) => ({\n      memory: m,\n      tokens: new Set(normalizeRecallTokens(m.content, [])),\n    }));\n\n    // Track which memories are already clustered\n    const clustered = new Set<string>();\n\n    for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {\n      if (clustered.has(tokenized[i].memory.frontmatter.id)) continue;\n\n      const cluster: MemoryFile[] = [tokenized[i].memory];\n      let totalOverlap = 0;\n      let comparisons = 0;\n\n      for (let j = i + 1; j < tokenized.length; j++) {\n        if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;\n\n        const aTokens = tokenized[i].tokens;\n        const bTokens = tokenized[j].tokens;\n        if (aTokens.size === 0 || bTokens.size === 0) continue;\n\n        // Bidirectional overlap: what fraction of tokens are shared\n        const overlap = countRecallTokenOverlap(aTokens, [...bTokens].join(\" \"));\n        const maxTokens = Math.max(aTokens.size, bTokens.size);\n        const score = maxTokens > 0 ? overlap / maxTokens : 0;\n\n        if (score >= config.threshold) {\n          cluster.push(tokenized[j].memory);\n          totalOverlap += score;\n          comparisons++;\n          // Enforce maxPerRun within a single cluster\n          if (totalCandidates + cluster.length >= config.maxPerRun) break;\n        }\n      }\n\n      if (cluster.length >= config.minClusterSize) {\n        for (const m of cluster) clustered.add(m.frontmatter.id);\n        clusters.push({\n          category,\n          memories: cluster,\n          overlapScore: comparisons > 0 ? totalOverlap / comparisons : 0,\n        });\n        totalCandidates += cluster.length;\n      }\n    }\n  }\n\n  return clusters;\n}\n\n/**\n * Build the LLM prompt for synthesizing a canonical memory from a cluster.\n */\nexport function buildConsolidationPrompt(cluster: ConsolidationCluster): string {\n  const memoryTexts = cluster.memories\n    .map(\n      (m, i) =>\n        `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):\\n${m.content}`,\n    )\n    .join(\"\\n\\n\");\n\n  return `You are a memory consolidation system. The following ${cluster.memories.length} memories in the \"${cluster.category}\" category contain overlapping information.\n\nSynthesize them into ONE canonical memory that:\n1. Preserves ALL unique information from every source memory\n2. Removes redundancy and repetition\n3. Uses clear, concise language\n4. Maintains the same category and tone\n5. Does NOT add information that isn't in the sources\n\n${memoryTexts}\n\nWrite ONLY the consolidated memory content (no metadata, no explanation, no preamble):`;\n}\n\n/**\n * Parse the LLM response to extract the canonical content.\n */\nexport function parseConsolidationResponse(response: string): string {\n  return response.trim();\n}\n\n// ─── Operator-aware prompt / parse (issue #561 PR 3) ─────────────────────────\n\n/**\n * Structured result from an operator-aware consolidation LLM call.\n *\n * - `operator` — the consolidation operator the LLM chose for this cluster.\n *   Falls back to the heuristic default when the LLM omits or returns an\n *   unknown value (the parser never surfaces an invalid operator; see\n *   `parseOperatorAwareConsolidationResponse`).\n * - `output` — the canonical content (same format the legacy prompt\n *   returns).  Callers persist this as the body of the new memory.\n */\nexport interface OperatorAwareConsolidationResult {\n  // Restricted to the LLM-allowed subset (Cursor Bugbot, PR #730):\n  // `pattern-reinforcement` is reserved for the maintenance job and\n  // must never reach this struct from a consolidation LLM response.\n  operator: _SemanticConsolidationLlmOperator;\n  output: string;\n}\n\n/**\n * Heuristic default operator for a cluster.  Used as the fallback when the\n * LLM does not return a parseable operator, and as the \"floor\" decision in\n * `parseOperatorAwareConsolidationResponse`.\n *\n * Current heuristic (kept deliberately conservative — PR 3 only):\n *\n *   - Two or more memories being collapsed into one canonical blob is a\n *     MERGE by definition.  This is the path the current clustering\n *     pipeline exercises.\n *   - A cluster of size 1 that still reaches consolidation (future path,\n *     e.g. supersession of a single older memory by a newer value) is an\n *     UPDATE.\n *   - SPLIT is never selected by the heuristic because the current write\n *     path emits exactly one canonical memory per cluster.  The prompt\n *     reserves SPLIT for future cluster shapes where the LLM decides one\n *     logical source actually encodes several distinct facts — at which\n *     point the orchestrator would need to write multiple outputs.\n */\nexport function chooseConsolidationOperator(\n  cluster: ConsolidationCluster,\n): _SemanticConsolidationLlmOperator {\n  if (cluster.memories.length <= 1) return \"update\";\n  return \"merge\";\n}\n\n/**\n * Build the operator-aware LLM prompt.  The LLM is asked to return a\n * JSON object `{ \"operator\": <split|merge|update>, \"output\": <content> }`.\n *\n * The prompt is additive: it still asks for a single canonical blob under\n * `output`, so the upstream write path does not change.  Future expansions\n * (SPLIT emitting multiple outputs) are explicitly documented as\n * out-of-scope for the parser — `parseOperatorAwareConsolidationResponse`\n * collapses any SPLIT response into a single canonical output for now.\n */\nexport function buildOperatorAwareConsolidationPrompt(\n  cluster: ConsolidationCluster,\n): string {\n  const memoryTexts = cluster.memories\n    .map(\n      (m, i) =>\n        `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):\\n${m.content}`,\n    )\n    .join(\"\\n\\n\");\n\n  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the \"${cluster.category}\" category contain overlapping information.\n\nPick exactly ONE consolidation operator for this cluster and return a JSON object.\n\nOperator vocabulary:\n  - \"merge\"  — multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).\n  - \"update\" — one source memory carries a stale value that a newer source supersedes within the same logical fact.\n  - \"split\"  — a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body — the write path will chunk it later).\n\nOutput JSON ONLY, no prose before or after.  The \"operator\" key MUST be set to exactly one of the three strings \"merge\", \"update\", or \"split\" — never a pipe-separated placeholder like \"merge|update|split\".  Example shape:\n  {\n    \"operator\": \"merge\",\n    \"output\": \"<the canonical memory text>\"\n  }\n\nThe \"output\" value must:\n1. Preserve ALL unique information from every source memory\n2. Remove redundancy and repetition\n3. Use clear, concise language\n4. Match the \"${cluster.category}\" category and tone\n5. NOT add information that isn't in the sources\n\n${memoryTexts}\n\nReturn ONLY the JSON object:`;\n}\n\n/**\n * Parse an operator-aware consolidation response.\n *\n * Contract:\n *   - Accepts strict JSON `{ \"operator\": \"...\", \"output\": \"...\" }`.\n *   - Tolerates a JSON payload wrapped in a fenced code block (```json ...```).\n *   - Falls back to the heuristic operator when the JSON is malformed,\n *     the `operator` field is missing / unknown, or the raw response is\n *     a plain blob with no JSON at all.  This keeps PR 3 backwards\n *     compatible with older models that ignore the JSON instruction.\n *   - Never throws.  A missing / empty `output` field falls back to the\n *     trimmed raw response so the caller still writes something rather\n *     than dropping the cluster.\n */\nexport function parseOperatorAwareConsolidationResponse(\n  response: string,\n  cluster: ConsolidationCluster,\n): OperatorAwareConsolidationResult {\n  const fallback: OperatorAwareConsolidationResult = {\n    operator: chooseConsolidationOperator(cluster),\n    output: response.trim(),\n  };\n\n  const trimmed = response.trim();\n  if (trimmed.length === 0) return fallback;\n\n  // Strip a fenced code block if present.\n  const fenced = /^```(?:json)?\\s*([\\s\\S]*?)```\\s*$/u.exec(trimmed);\n  const payload = fenced ? fenced[1].trim() : trimmed;\n\n  // Find a balanced brace-delimited JSON object that has an `operator`\n  // key (PR #632 round-4 review, codex P1).  A first/last-brace slice\n  // breaks when the model prepends an earlier brace block (e.g.\n  // `Example: {\"note\":\"...\"} ... {\"operator\":\"merge\",...}`).  Walk the\n  // payload tracking nesting + string/escape state and skip past\n  // objects that don't look like our target shape.\n  const parsed = findLastJsonObjectWithOperator(payload);\n  if (parsed === undefined) return fallback;\n  if (typeof parsed !== \"object\" || parsed === null) return fallback;\n\n  const obj = parsed as Record<string, unknown>;\n  const rawOperator = typeof obj.operator === \"string\" ? obj.operator.trim().toLowerCase() : \"\";\n  const rawOutput = typeof obj.output === \"string\" ? obj.output : \"\";\n\n  // Narrow gate (Cursor Bugbot review on PR #730 head `aa1c2a8`):\n  // accept ONLY the legacy split/merge/update LLM vocabulary here.\n  // `pattern-reinforcement` joined the broader `ConsolidationOperator`\n  // type in #687 PR 2/4 but is reserved for the maintenance job — if\n  // an LLM hallucinates that operator we must NOT promote it onto\n  // `derived_via`.\n  const operator = _isSemanticConsolidationLlmOperator(rawOperator)\n    ? rawOperator\n    : chooseConsolidationOperator(cluster);\n  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();\n\n  return { operator, output };\n}\n\n/**\n * Walk `text`, find all balanced top-level `{ ... }` blocks whose\n * JSON.parse result is an object with an `operator` key, and return\n * the LAST one (function name reflects this — PR #632 review,\n * cursor Low).  Returns `undefined` when nothing matches.  Tracks\n * string state + escape sequences so braces inside string values\n * don't throw off the depth counter.\n *\n * Used by `parseOperatorAwareConsolidationResponse` to tolerate models\n * that prepend an explanatory JSON example block before the real\n * payload (PR #632 round-4 + round-5 review, codex P1).  We take the\n * LAST candidate so that an instructional example with an `operator`\n * key ahead of the real answer doesn't steal precedence — models\n * typically write the example first and the real answer last.\n */\nfunction findLastJsonObjectWithOperator(text: string): unknown {\n  let searchFrom = 0;\n  let last: unknown = undefined;\n  while (searchFrom < text.length) {\n    const start = text.indexOf(\"{\", searchFrom);\n    if (start < 0) return last;\n    let depth = 0;\n    let inString = false;\n    let escape = false;\n    let closed = false;\n    let endIdx = -1;\n    for (let i = start; i < text.length; i++) {\n      const ch = text[i];\n      if (inString) {\n        if (escape) {\n          escape = false;\n        } else if (ch === \"\\\\\") {\n          escape = true;\n        } else if (ch === '\"') {\n          inString = false;\n        }\n        continue;\n      }\n      if (ch === '\"') {\n        inString = true;\n      } else if (ch === \"{\") {\n        depth += 1;\n      } else if (ch === \"}\") {\n        depth -= 1;\n        if (depth === 0) {\n          closed = true;\n          endIdx = i;\n          break;\n        }\n      }\n    }\n    if (!closed) return last;\n    const slice = text.slice(start, endIdx + 1);\n    try {\n      const parsed = JSON.parse(slice);\n      if (\n        typeof parsed === \"object\" &&\n        parsed !== null &&\n        \"operator\" in (parsed as Record<string, unknown>)\n      ) {\n        last = parsed;\n      }\n    } catch {\n      // Fall through to the next candidate.\n    }\n    searchFrom = endIdx + 1;\n  }\n  return last;\n}\n\n// Silence unused-import warnings when tsup tree-shakes: these are used\n// above in chooseConsolidationOperator + parse helpers.\nvoid _CONSOLIDATION_OPERATORS;\n\n/**\n * Discover extensions and build the block to append to a consolidation prompt.\n * Returns \"\" when extensions are disabled or none are found.\n */\nexport async function buildExtensionsBlockForConsolidation(\n  config: PluginConfig,\n): Promise<string> {\n  if (!config.memoryExtensionsEnabled) return \"\";\n  const root = resolveExtensionsRoot(config);\n  const extensions = await discoverMemoryExtensions(root, log);\n  if (extensions.length === 0) return \"\";\n  return renderExtensionsBlock(extensions);\n}\n\n/**\n * Optional post-consolidation hook — materializes the namespace into Codex's\n * native memory layout when the consolidation run finishes. Kept here (rather\n * than in orchestrator.ts) so #378 doesn't conflict with Wave 1 edits.\n *\n * Safe to call regardless of config state: honors `codexMaterializeMemories`\n * and `codexMaterializeOnConsolidation` and silently becomes a no-op when\n * either is disabled.\n */\nexport async function materializeAfterSemanticConsolidation(options: {\n  config: PluginConfig;\n  namespace?: string;\n  memories?: MemoryFile[];\n  memoryDir?: string;\n  codexHome?: string;\n  rolloutSummaries?: RolloutSummaryInput[];\n  now?: Date;\n}): Promise<MaterializeResult | null> {\n  // Delegates to the shared post-consolidation helper so semantic and causal\n  // flows stay in lock-step — any guard/logging change happens in one place.\n  return runPostConsolidationMaterialize(\"[semantic-consolidation]\", options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAWA,OAAOA,WAAU;AACjB,SAAS,cAAAC,mBAAkB;;;AC4B3B;AAAA,EACE;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,OAAO,UAAU;AA4EV,IAAM,sBAAsB;AAG5B,IAAM,gBAAgB;AAGtB,IAAM,UAAU;AAGvB,IAAM,cAAc,oBAAI,IAAY;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAGD,IAAM,iBAAiB;AAahB,SAAS,wBACd,WACA,SACmB;AACnB,QAAM,SAAS,QAAQ,UAAU;AAAA,IAC/B,MAAM,CAAC,QAAQ,IAAI,KAAK,uBAAuB,GAAG,EAAE;AAAA,IACpD,MAAM,CAAC,QAAQ,IAAI,KAAK,uBAAuB,GAAG,EAAE;AAAA,IACpD,OAAO,CAAC,QAAQ,IAAI,MAAM,uBAAuB,GAAG,EAAE;AAAA,EACxD;AACA,QAAM,YAAY,iBAAiB,QAAQ,SAAS;AACpD,QAAM,cAAc,KAAK,KAAK,WAAW,UAAU;AACnD,QAAM,MAAM,QAAQ,OAAO,oBAAI,KAAK;AAIpC,QAAM,mBACJ,OAAO,QAAQ,qBAAqB,YAAY,QAAQ,oBAAoB,IACxE,QAAQ,mBACR;AACN,QAAM,uBACJ,OAAO,QAAQ,yBAAyB,YAAY,QAAQ,wBAAwB,IAChF,QAAQ,uBACR;AAWN,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,QAAM,mBAAmB,aAAa,YAAY;AAClD,MAAI,CAAC,kBAAkB;AAMrB,QAAI,WAAW,WAAW,GAAG;AAC3B,aAAO;AAAA,QACL,YAAY,aAAa,eAAe,WAAW;AAAA,MACrD;AAAA,IACF,OAAO;AACL,aAAO;AAAA,QACL,mCAA8B,WAAW;AAAA,MAC3C;AAAA,IACF;AACA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,OAAO;AAAA,MACP,mBAAmB;AAAA,MACnB,mBAAmB;AAAA,MACnB,cAAc,CAAC;AAAA,MACf,aAAa;AAAA,IACf;AAAA,EACF;AAOA,YAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAG1C,QAAM,WAAW,CAAC,GAAG,QAAQ,QAAQ;AAIrC,QAAM,mBAAmB,QAAQ,qBAAqB;AACtD,QAAM,mBAAmB,QAAQ,oBAAoB,CAAC;AAQtD,QAAM,mBAAmB,cAAc,kBAAkB,sBAAsB,GAAG;AAYlF,QAAM,kBAAyC,CAAC;AAChD,QAAM,YAAY,oBAAI,IAAoB;AAC1C,QAAM,UAAU,CAAC,UAAsC;AACrD,QAAI,CAAC,MAAO,QAAO,OAAO;AAC1B,UAAM,SAAS,KAAK,MAAM,KAAK;AAC/B,WAAO,OAAO,SAAS,MAAM,IAAI,SAAS,OAAO;AAAA,EACnD;AACA,aAAW,KAAK,kBAAkB;AAChC,UAAM,OAAO,GAAG,aAAa,EAAE,IAAI,CAAC;AACpC,UAAM,cAAc,UAAU,IAAI,IAAI;AACtC,QAAI,gBAAgB,QAAW;AAC7B,gBAAU,IAAI,MAAM,gBAAgB,MAAM;AAC1C,sBAAgB,KAAK,CAAC;AACtB;AAAA,IACF;AAKA,UAAM,WAAW,gBAAgB,WAAW;AAC5C,QAAI,QAAQ,EAAE,SAAS,IAAI,QAAQ,SAAS,SAAS,GAAG;AACtD,sBAAgB,WAAW,IAAI;AAAA,IACjC;AAAA,EACF;AAEA,QAAM,gBAAgB,oBAAoB;AAAA,IACxC;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA,IAClB,WAAW;AAAA,EACb,CAAC;AAED,QAAM,WAAW,eAAe;AAAA,IAC9B;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA,EACpB,CAAC;AAGD,QAAM,aAAa,iBAAiB,QAAQ;AAC5C,MAAI,CAAC,WAAW,OAAO;AACrB,UAAM,SAAS,WAAW,OAAO,KAAK,IAAI;AAC1C,WAAO,KAAK,uCAAuC,MAAM,EAAE;AAC3D,UAAM,IAAI,MAAM,0DAA0D,MAAM,EAAE;AAAA,EACpF;AAEA,QAAM,cAAc,kBAAkB,EAAE,SAAS,CAAC;AAElD,QAAM,eAAe,gBAAgB,IAAI,CAAC,OAAO;AAAA,IAC/C,MAAM,GAAG,aAAa,EAAE,IAAI,CAAC;AAAA,IAC7B,MAAM,qBAAqB,CAAC;AAAA,EAC9B,EAAE;AAGF,QAAM,OAAO,mBAAmB;AAAA,IAC9B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,MAAI,iBAAiB,iBAAiB,MAAM;AAO1C,UAAM,gBAAgB;AAAA,MACpB,KAAK,KAAK,aAAa,mBAAmB;AAAA,MAC1C,KAAK,KAAK,aAAa,WAAW;AAAA,MAClC,KAAK,KAAK,aAAa,iBAAiB;AAAA,MACxC,GAAG,aAAa,IAAI,CAAC,MAAM,KAAK,KAAK,aAAa,gBAAgB,EAAE,IAAI,CAAC;AAAA,IAC3E;AACA,UAAM,aAAa,cAAc,MAAM,CAAC,MAAM,WAAW,CAAC,CAAC;AAC3D,QAAI,YAAY;AACd,aAAO,QAAQ,uCAAuC,SAAS,mBAAmB;AAClF,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA,OAAO;AAAA,QACP,mBAAmB;AAAA,QACnB,mBAAmB;AAAA,QACnB,cAAc,CAAC;AAAA,QACf,aAAa;AAAA,MACf;AAAA,IACF;AACA,WAAO;AAAA,MACL,gCAAgC,SAAS;AAAA,IAC3C;AAAA,EACF;AAUA,QAAM,SAAS,GAAG,QAAQ,GAAG,IAAI,KAAK,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC;AACnG,QAAM,SAAS,KAAK,KAAK,aAAa,GAAG,OAAO,IAAI,MAAM,EAAE;AAc5D,QAAM,eAAe,KAAK,KAAK;AAC/B,QAAM,cAAc,KAAK,IAAI;AAC7B,MAAI;AACF,eAAW,SAAS,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACrE,UAAI,CAAC,MAAM,YAAY,EAAG;AAC1B,UAAI,CAAC,MAAM,KAAK,WAAW,OAAO,EAAG;AACrC,YAAM,YAAY,KAAK,KAAK,aAAa,MAAM,IAAI;AACnD,UAAI;AACF,cAAM,OAAO,SAAS,SAAS;AAC/B,YAAI,cAAc,KAAK,UAAU,aAAc;AAC/C,eAAO,WAAW,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AAAA,MACpD,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACA,YAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;AACrC,YAAU,KAAK,KAAK,QAAQ,cAAc,GAAG,EAAE,WAAW,KAAK,CAAC;AAEhE,QAAM,eAAyB,CAAC;AAEhC,gBAAc,KAAK,KAAK,QAAQ,mBAAmB,GAAG,aAAa;AACnE,eAAa,KAAK,mBAAmB;AAErC,gBAAc,KAAK,KAAK,QAAQ,WAAW,GAAG,QAAQ;AACtD,eAAa,KAAK,WAAW;AAE7B,gBAAc,KAAK,KAAK,QAAQ,iBAAiB,GAAG,WAAW;AAC/D,eAAa,KAAK,iBAAiB;AAEnC,aAAW,WAAW,cAAc;AAClC,kBAAc,KAAK,KAAK,QAAQ,gBAAgB,QAAQ,IAAI,GAAG,QAAQ,IAAI;AAC3E,iBAAa,KAAK,KAAK,KAAK,gBAAgB,QAAQ,IAAI,CAAC;AAAA,EAC3D;AAKA,aAAW,OAAO,CAAC,qBAAqB,aAAa,iBAAiB,GAAG;AACvE,UAAM,MAAM,KAAK,KAAK,QAAQ,GAAG;AACjC,UAAM,OAAO,KAAK,KAAK,aAAa,GAAG;AACvC,eAAW,KAAK,IAAI;AAAA,EACtB;AAEA,QAAM,kBAAkB,KAAK,KAAK,aAAa,cAAc;AAC7D,YAAU,iBAAiB,EAAE,WAAW,KAAK,CAAC;AAO9C,MAAI,kBAAkB;AACpB,UAAM,uBAAuB,IAAI,IAAI,aAAa,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC;AACpE,QAAI;AACF,iBAAW,SAAS,YAAY,iBAAiB,EAAE,eAAe,KAAK,CAAC,GAAG;AACzE,YAAI,CAAC,MAAM,OAAO,EAAG;AACrB,YAAI,CAAC,MAAM,KAAK,SAAS,KAAK,EAAG;AACjC,YAAI,qBAAqB,IAAI,MAAM,IAAI,EAAG;AAC1C,YAAI;AACF,qBAAW,KAAK,KAAK,iBAAiB,MAAM,IAAI,CAAC;AAAA,QACnD,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,aAAW,WAAW,cAAc;AAClC,UAAM,MAAM,KAAK,KAAK,QAAQ,gBAAgB,QAAQ,IAAI;AAC1D,UAAM,OAAO,KAAK,KAAK,iBAAiB,QAAQ,IAAI;AACpD,eAAW,KAAK,IAAI;AAAA,EACtB;AAGA,QAAM,WAAyB;AAAA,IAC7B,SAAS;AAAA,IACT;AAAA,IACA,YAAY,IAAI,YAAY;AAAA,IAC5B,cAAc;AAAA,EAChB;AACA,gBAAc,cAAc,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,CAAI;AAEpE,MAAI;AACF,WAAO,QAAQ,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AAAA,EACjD,QAAQ;AAAA,EAER;AAEA,SAAO;AAAA,IACL,0BAA0B,SAAS,UAAU,aAAa,MAAM,SAAS,KAAK,MAAM,GAAG,EAAE,CAAC;AAAA,EAC5F;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,mBAAmB;AAAA,IACnB,mBAAmB;AAAA,IACnB;AAAA,IACA,aAAa;AAAA,EACf;AACF;AAOO,SAAS,eAAe,aAAqB,WAAmB,MAAY,oBAAI,KAAK,GAAS;AACnG,YAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAC1C,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,MAAI,WAAW,YAAY,EAAG;AAC9B,QAAM,WAAyB;AAAA,IAC7B,SAAS;AAAA,IACT;AAAA,IACA,YAAY,IAAI,YAAY;AAAA,IAC5B,cAAc;AAAA,EAChB;AACA,gBAAc,cAAc,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,CAAI;AACtE;AAwBO,SAAS,oBAAoB,KAAmC;AACrE,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,kBAAkB;AAC7B,QAAM,KAAK,EAAE;AACb,QAAM,KAAK,eAAe,IAAI,SAAS,GAAG;AAC1C,QAAM,KAAK,kBAAkB;AAC7B,QAAM,KAAK,EAAE;AAEb,QAAM,YAAY,sBAAsB,IAAI,UAAU,EAAE;AACxD,MAAI,UAAU,SAAS,GAAG;AACxB,UAAM,KAAK,iBAAiB;AAC5B,UAAM,KAAK,EAAE;AACb,eAAW,OAAO,WAAW;AAC3B,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AAEA,MAAI,IAAI,iBAAiB,SAAS,GAAG;AACnC,UAAM,KAAK,oBAAoB;AAC/B,UAAM,KAAK,EAAE;AACb,UAAM,SAAS,CAAC,GAAG,IAAI,gBAAgB,EACpC,KAAK,CAAC,GAAG,OAAO,EAAE,aAAa,IAAI,cAAc,EAAE,aAAa,EAAE,CAAC,EACnE,MAAM,GAAG,CAAC;AACb,eAAW,KAAK,QAAQ;AACtB,YAAM,OAAO,EAAE,YAAY,KAAK,EAAE,SAAS,MAAM;AACjD,YAAM,KAAK,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE;AAAA,IACjC;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AAEA,QAAM,OAAO,MAAM,KAAK,IAAI,EAAE,QAAQ,SAAS,IAAI;AACnD,SAAO,sBAAsB,MAAM,IAAI,SAAS;AAClD;AAKO,SAAS,eAAe,KAA4B;AACzD,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,iBAAiB,IAAI,SAAS,EAAE;AAC3C,QAAM,KAAK,UAAU,IAAI,SAAS,EAAE;AACpC,QAAM,KAAK,+CAA+C;AAC1D,QAAM,KAAK,EAAE;AAIb,QAAM,aAAa,wBAAwB,IAAI,QAAQ;AACvD,MAAI,YAAY;AAChB,MAAI,WAAW,SAAS,GAAG;AACzB,UAAM,KAAK,WAAW,SAAS,mCAA8B;AAC7D,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,2BAA2B;AACtC,eAAW,KAAK,IAAI,kBAAkB;AACpC,YAAM;AAAA,QACJ,uBAAuB,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE;AAAA,MAC1K;AAAA,IACF;AACA,QAAI,IAAI,iBAAiB,WAAW,GAAG;AACrC,YAAM,KAAK,UAAU;AAAA,IACvB;AACA,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,cAAc;AACzB,UAAM,KAAK,KAAK,IAAI,SAAS,EAAE;AAC/B,UAAM,KAAK,EAAE;AACb,iBAAa;AAAA,EACf,OAAO;AACL,eAAW,CAAC,UAAU,IAAI,KAAK,YAAY;AACzC,YAAM,KAAK,WAAW,SAAS,KAAK,QAAQ,qCAAqC;AACjF,YAAM,KAAK,EAAE;AACb,YAAM,KAAK,2BAA2B;AACtC,YAAM,mBAAmB,IAAI,iBAAiB,MAAM,GAAG,CAAC;AACxD,UAAI,iBAAiB,WAAW,GAAG;AACjC,cAAM,KAAK,UAAU;AAAA,MACvB,OAAO;AACL,mBAAW,KAAK,kBAAkB;AAChC,gBAAM;AAAA,YACJ,uBAAuB,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE;AAAA,UAC1K;AAAA,QACF;AAAA,MACF;AACA,YAAM,KAAK,EAAE;AACb,YAAM,KAAK,cAAc;AACzB,YAAM,WAAW,gBAAgB,MAAM,UAAU,IAAI,SAAS;AAC9D,YAAM,KAAK,KAAK,SAAS,KAAK,IAAI,CAAC,EAAE;AACrC,YAAM,KAAK,EAAE;AACb,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,QAAM,KAAK,qBAAqB;AAChC,QAAM,QAAQ,aAAa,IAAI,UAAU,CAAC,YAAY,CAAC;AACvD,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,QAAQ,MAAM,MAAM,GAAG,EAAE,GAAG;AACrC,YAAM,KAAK,KAAK,eAAe,IAAI,CAAC,EAAE;AAAA,IACxC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,QAAM,KAAK,uBAAuB;AAClC,QAAM,YAAY,aAAa,IAAI,UAAU,CAAC,QAAQ,YAAY,aAAa,QAAQ,OAAO,CAAC;AAC/F,MAAI,UAAU,WAAW,GAAG;AAC1B,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,OAAO,UAAU,MAAM,GAAG,EAAE,GAAG;AACxC,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,QAAM,KAAK,uCAAuC;AAClD,QAAM,cAAc,aAAa,IAAI,UAAU,CAAC,YAAY,CAAC;AAC7D,MAAI,YAAY,WAAW,GAAG;AAC5B,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,OAAO,YAAY,MAAM,GAAG,EAAE,GAAG;AAC1C,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,SAAO,MAAM,KAAK,IAAI;AACxB;AAGO,SAAS,kBAAkB,KAAyC;AACzE,QAAM,SAAS,CAAC,GAAG,IAAI,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM;AAC9C,UAAM,WAAW,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AACnE,UAAM,WAAW,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AACnE,WAAO,SAAS,cAAc,QAAQ;AAAA,EACxC,CAAC;AAED,QAAM,QAAkB,CAAC,kBAAkB,IAAI,wCAAmC,EAAE;AACpF,aAAW,OAAO,QAAQ;AACxB,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,GAAG,MAAM;AACpB,UAAM,WAAW,GAAG,YAAY;AAChC,UAAM,UAAU,GAAG,WAAW,GAAG,WAAW;AAC5C,UAAM,KAAK,MAAM,EAAE,KAAK,QAAQ,aAAa,OAAO,GAAG;AACvD,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,IAAI,QAAQ,KAAK,CAAC;AAC7B,UAAM,KAAK,EAAE;AAAA,EACf;AACA,SAAO,MAAM,KAAK,IAAI;AACxB;AAGO,SAAS,qBAAqB,OAAoC;AACvE,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,sBAAsB,MAAM,IAAI,EAAE;AAC7C,QAAM,KAAK,EAAE;AACb,QAAM,OAAiB,CAAC;AACxB,MAAI,MAAM,IAAK,MAAK,KAAK,OAAO,MAAM,GAAG,EAAE;AAC3C,MAAI,MAAM,YAAa,MAAK,KAAK,gBAAgB,MAAM,WAAW,EAAE;AACpE,MAAI,MAAM,UAAW,MAAK,KAAK,cAAc,MAAM,SAAS,EAAE;AAC9D,MAAI,MAAM,SAAU,MAAK,KAAK,aAAa,MAAM,QAAQ,EAAE;AAC3D,MAAI,KAAK,SAAS,GAAG;AACnB,UAAM,KAAK,IAAI,KAAK,KAAK,IAAI,CAAC,GAAG;AACjC,UAAM,KAAK,EAAE;AAAA,EACf;AACA,MAAI,MAAM,YAAY,MAAM,SAAS,SAAS,GAAG;AAC/C,UAAM,KAAK,iBAAiB,MAAM,SAAS,KAAK,IAAI,CAAC,EAAE;AACvD,UAAM,KAAK,EAAE;AAAA,EACf;AACA,QAAM,KAAK,MAAM,KAAK,KAAK,CAAC;AAC5B,QAAM,KAAK,EAAE;AACb,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,iBAAiB,SAAqC;AACpE,QAAM,SAAmB,CAAC;AAC1B,QAAM,QAAQ,QAAQ,MAAM,QAAQ;AAEpC,QAAM,iBAAiB,MAAM,UAAU,CAAC,MAAM,0BAA0B,KAAK,CAAC,CAAC;AAC/E,MAAI,mBAAmB,IAAI;AACzB,WAAO,KAAK,gCAAgC;AAAA,EAC9C,OAAO;AACL,UAAM,OAAO,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAC/D,QAAI,CAAC,KAAK,KAAK,CAAC,MAAM,iBAAiB,KAAK,CAAC,CAAC,GAAG;AAC/C,aAAO,KAAK,+CAA+C;AAAA,IAC7D;AACA,QAAI,CAAC,KAAK,KAAK,CAAC,MAAM,sBAAsB,KAAK,CAAC,CAAC,GAAG;AACpD,aAAO,KAAK,oDAAoD;AAAA,IAClE;AAAA,EACF;AAEA,QAAM,cAAc,MAAM,OAAO,CAAC,MAAM,qBAAqB,KAAK,CAAC,CAAC;AACpE,MAAI,YAAY,WAAW,GAAG;AAC5B,WAAO,KAAK,+CAA+C;AAAA,EAC7D;AAIA,QAAM,eAAe;AACrB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,CAAC,qBAAqB,KAAK,MAAM,CAAC,CAAC,EAAG;AAC1C,QAAI,aAAa;AACjB,QAAI,cAAc;AAClB,aAAS,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACzC,UAAI,aAAa,KAAK,MAAM,CAAC,CAAC,EAAG;AACjC,UAAI,oCAAoC,KAAK,MAAM,CAAC,CAAC,EAAG,cAAa;AACrE,UAAI,uBAAuB,KAAK,MAAM,CAAC,CAAC,EAAG,eAAc;AAAA,IAC3D;AACA,QAAI,CAAC,WAAY,QAAO,KAAK,sBAAsB,IAAI,CAAC,wCAAwC;AAChG,QAAI,CAAC,YAAa,QAAO,KAAK,sBAAsB,IAAI,CAAC,2BAA2B;AAAA,EACtF;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,aAAW,MAAM,kBAAkB;AACjC,QAAI,CAAC,MAAM,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG;AAClC,aAAO,KAAK,6BAA6B,GAAG,MAAM,EAAE;AAAA,IACtD;AAAA,EACF;AAEA,SAAO,EAAE,OAAO,OAAO,WAAW,GAAG,OAAO;AAC9C;AAIA,SAAS,iBAAiB,UAA2B;AACnD,MAAI,YAAY,SAAS,KAAK,EAAE,SAAS,EAAG,QAAO;AACnD,QAAM,UAAU,WAAW,YAAY;AACvC,MAAI,WAAW,QAAQ,KAAK,EAAE,SAAS,EAAG,QAAO;AACjD,SAAO,KAAK,KAAK,eAAe,GAAG,QAAQ;AAC7C;AAEA,SAAS,aAAa,cAA2C;AAC/D,MAAI,CAAC,WAAW,YAAY,EAAG,QAAO;AACtC,MAAI;AACF,UAAM,MAAM,aAAa,cAAc,OAAO;AAC9C,UAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,QAAI,OAAO,WAAW,YAAY,WAAW,KAAM,QAAO;AAC1D,WAAO;AAAA,MACL,SAAS,OAAO,OAAO,YAAY,WAAW,OAAO,UAAU;AAAA,MAC/D,WAAW,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY;AAAA,MACrE,YAAY,OAAO,OAAO,eAAe,WAAW,OAAO,aAAa;AAAA,MACxE,cAAc,OAAO,OAAO,iBAAiB,WAAW,OAAO,eAAe;AAAA,IAChF;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,sBAAsB,UAAwB,OAA6B;AAClF,QAAM,SAAS,SACZ,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,QAAQ,EACxE,IAAI,CAAC,MAAM;AACV,UAAM,aAAa,OAAO,EAAE,YAAY,eAAe,WAAW,EAAE,YAAY,aAAa;AAC7F,UAAM,aACJ,OAAO,EAAE,YAAY,eAAe,YACpC,EAAE,YAAY,eAAe,QAC7B,OAAQ,EAAE,YAAY,WAAkC,UAAU,WAC5D,EAAE,YAAY,WAAiC,SAAS,IAC1D;AACN,UAAM,UAAU,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AAClE,WAAO,EAAE,QAAQ,GAAG,OAAO,aAAa,IAAI,YAAY,QAAQ;AAAA,EAClE,CAAC;AAEH,SAAO,KAAK,CAAC,GAAG,MAAM;AACpB,QAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAC5C,WAAO,EAAE,QAAQ,cAAc,EAAE,OAAO;AAAA,EAC1C,CAAC;AAED,SAAO,OAAO,MAAM,GAAG,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM;AACnD;AAEA,SAAS,eAAe,QAA4B;AAClD,QAAM,MAAM,OAAO,QAAQ,QAAQ,SAAS,GAAG,EAAE,KAAK;AACtD,MAAI,IAAI,UAAU,IAAK,QAAO;AAC9B,SAAO,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC;AAC7B;AAEA,SAAS,wBAAwB,UAAmD;AAClF,QAAM,MAAM,oBAAI,IAA0B;AAC1C,aAAW,UAAU,UAAU;AAC7B,QAAI,OAAO,YAAY,UAAU,OAAO,YAAY,WAAW,SAAU;AACzE,UAAM,WAAW,OAAO,YAAY,YAAY;AAChD,UAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,CAAC;AACnC,SAAK,KAAK,MAAM;AAChB,QAAI,IAAI,UAAU,IAAI;AAAA,EACxB;AACA,SAAO;AACT;AAEA,SAAS,aAAa,UAAwB,YAAoC;AAChF,QAAM,UAAU,IAAI,IAAI,UAAU;AAClC,SAAO,SAAS;AAAA,IACd,CAAC,OACE,CAAC,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,aACnD,QAAQ,IAAI,EAAE,YAAY,YAAY,EAAE;AAAA,EAC5C;AACF;AAEA,SAAS,gBAAgB,UAAwB,UAAkB,WAA6B;AAC9F,QAAM,WAAW,oBAAI,IAAY;AACjC,WAAS,IAAI,QAAQ;AACrB,WAAS,IAAI,SAAS;AACtB,aAAW,OAAO,SAAS,MAAM,GAAG,EAAE,GAAG;AACvC,eAAW,OAAO,IAAI,YAAY,QAAQ,CAAC,GAAG;AAC5C,UAAI,OAAO,QAAQ,YAAY,IAAI,KAAK,EAAE,SAAS,EAAG,UAAS,IAAI,IAAI,KAAK,CAAC;AAAA,IAC/E;AAAA,EACF;AACA,SAAO,CAAC,GAAG,QAAQ,EAAE,MAAM,GAAG,EAAE;AAClC;AAEA,SAAS,cACP,UACA,eACA,KACuB;AAIvB,MAAI,gBAAgB,EAAG,QAAO;AAI9B,QAAM,WAAW,IAAI,QAAQ,IAAI,gBAAgB,KAAK,KAAK,KAAK;AAChE,SAAO,SAAS,OAAO,CAAC,MAAM;AAC5B,QAAI,CAAC,EAAE,UAAW,QAAO;AACzB,UAAM,IAAI,KAAK,MAAM,EAAE,SAAS;AAChC,QAAI,CAAC,OAAO,SAAS,CAAC,EAAG,QAAO;AAChC,WAAO,KAAK;AAAA,EACd,CAAC;AACH;AAEA,SAAS,aAAa,MAAsB;AAC1C,SAAO,KACJ,YAAY,EACZ,QAAQ,mBAAmB,GAAG,EAC9B,QAAQ,aAAa,EAAE,EACvB,MAAM,GAAG,EAAE,KACT;AACP;AAOO,SAAS,sBAAsB,MAAsB;AAC1D,QAAM,UAAU,KAAK,KAAK;AAC1B,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,SAAO,QAAQ,MAAM,MAAM,EAAE;AAC/B;AAOO,SAAS,sBAAsB,MAAc,WAA2B;AAC7E,MAAI,aAAa,EAAG,QAAO;AAC3B,MAAI,sBAAsB,IAAI,KAAK,UAAW,QAAO;AAMrD,QAAM,aAAa;AACnB,QAAM,aAAa;AACnB,QAAM,mBAAmB,sBAAsB,UAAU;AACzD,QAAM,mBAAmB,sBAAsB,UAAU;AAEzD,QAAM,QAAQ,KAAK,MAAM,QAAQ;AACjC,QAAM,aAAa,KAAK,IAAI,GAAG,YAAY,gBAAgB;AAC3D,SAAO,MAAM,SAAS,KAAK,sBAAsB,MAAM,KAAK,IAAI,CAAC,IAAI,YAAY;AAC/E,UAAM,IAAI;AAAA,EACZ;AACA,QAAM,KAAK,UAAU;AACrB,MAAI,SAAS,MAAM,KAAK,IAAI;AAK5B,MAAI,sBAAsB,MAAM,IAAI,WAAW;AAC7C,UAAM,SAAS,OAAO,MAAM,MAAM;AAClC,UAAM,OAAO,KAAK,IAAI,GAAG,YAAY,gBAAgB;AACrD,aAAS,OAAO,IAAI,GAAG,OAAO,MAAM,GAAG,IAAI,EAAE,KAAK,GAAG,CAAC,IAAI,UAAU,KAAK;AAAA,EAC3E;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,OAMjB;AACT,QAAM,OAAO,WAAW,QAAQ;AAChC,OAAK,OAAO,IAAI,mBAAmB;AAAA,CAAI;AACvC,OAAK,OAAO,aAAa,MAAM,SAAS;AAAA,CAAI;AAC5C,OAAK,OAAO,wBAAwB;AACpC,OAAK,OAAO,MAAM,aAAa;AAC/B,OAAK,OAAO,qBAAqB;AACjC,OAAK,OAAO,MAAM,QAAQ;AAC1B,OAAK,OAAO,wBAAwB;AACpC,OAAK,OAAO,MAAM,WAAW;AAC7B,QAAM,iBAAiB,CAAC,GAAG,MAAM,YAAY,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAC1F,aAAW,KAAK,gBAAgB;AAC9B,SAAK,OAAO;AAAA,aAAgB,EAAE,IAAI;AAAA,CAAO;AACzC,SAAK,OAAO,EAAE,IAAI;AAAA,EACpB;AACA,SAAO,KAAK,OAAO,KAAK;AAC1B;AAQO,SAAS,oBAAoB,aAK3B;AACP,MAAI,CAAC,WAAW,WAAW,EAAG,QAAO;AACrC,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,QAAM,WAAW,aAAa,YAAY;AAC1C,QAAM,QAAkB,CAAC;AACzB,aAAW,SAAS,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACrE,QAAI,MAAM,OAAO,KAAK,YAAY,IAAI,MAAM,IAAI,EAAG,OAAM,KAAK,MAAM,IAAI;AAAA,EAC1E;AACA,QAAM,cAAc,KAAK,KAAK,aAAa,cAAc;AACzD,MAAI,WAAW,WAAW,GAAG;AAC3B,QAAI;AACF,iBAAW,SAAS,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACrE,YAAI,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,KAAK,GAAG;AAChD,gBAAM,KAAK,KAAK,KAAK,gBAAgB,MAAM,IAAI,CAAC;AAAA,QAClD;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,aAAa,aAAa;AAAA,IAC1B,OAAO,MAAM,KAAK;AAAA,IAClB;AAAA,EACF;AACF;;;AD75BA,eAAsB,oBACpB,SACmC;AACnC,QAAM,MAAM,QAAQ;AACpB,MAAI,CAAC,IAAI,0BAA0B;AACjC,QAAI,MAAM,mEAA8D;AACxE,WAAO;AAAA,EACT;AAKA,MAAI,QAAQ,WAAW,iBAAiB,IAAI,iCAAiC,OAAO;AAClF,QAAI;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,iBAAiB,QAAQ,WAAW,GAAG;AACzD,QAAM,YAAY,QAAQ,aAAa,IAAI;AAC3C,MAAI,CAAC,WAAW;AACd,QAAI,KAAK,2DAAsD;AAC/D,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI,QAAQ,UAAU;AACpB,eAAW,QAAQ;AAAA,EACrB,OAAO;AACL,UAAM,QAAQ,oBAAoB,WAAW,WAAW,GAAG;AAC3D,UAAM,UAAU,IAAI,eAAe,KAAK;AACxC,QAAI;AACF,iBAAW,MAAM,QAAQ,gBAAgB;AAAA,IAC3C,SAAS,OAAO;AACd,UAAI;AAAA,QACF,mEAA8D,KAAK,KACjE,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CACvD;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF;AASA,QAAM,SAAS,wBAAwB,WAAW;AAAA,IAChD;AAAA,IACA,WAAW,QAAQ;AAAA,IACnB,kBAAkB,IAAI;AAAA,IACtB,sBAAsB,IAAI;AAAA,IAC1B,kBAAkB,QAAQ;AAAA,IAC1B,KAAK,QAAQ;AAAA,EACf,CAAC;AACD,MAAI,QAAQ,QAAQ;AAClB,QAAI;AAAA,MACF,kCAAkC,QAAQ,MAAM,UAAU,OAAO,KAAK,UAAU,OAAO,aAAa,MAAM;AAAA,IAC5G;AAAA,EACF;AACA,SAAO;AACT;AAYA,eAAsB,gCACpB,WACA,SACmC;AACnC,MAAI,CAAC,QAAQ,OAAO,yBAA0B,QAAO;AACrD,MAAI,CAAC,QAAQ,OAAO,gCAAiC,QAAO;AAC5D,MAAI;AACF,WAAO,MAAM,oBAAoB;AAAA,MAC/B,QAAQ,QAAQ;AAAA,MAChB,WAAW,QAAQ;AAAA,MACnB,UAAU,QAAQ;AAAA,MAClB,WAAW,QAAQ;AAAA,MACnB,WAAW,QAAQ;AAAA,MACnB,kBAAkB,QAAQ;AAAA,MAC1B,KAAK,QAAQ;AAAA,MACb,QAAQ;AAAA,IACV,CAAC;AAAA,EACH,SAAS,OAAO;AACd,QAAI;AAAA,MACF,GAAG,SAAS,oDACV,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CACvD;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAEA,SAAS,iBAAiB,UAA8B,KAA2B;AACjF,QAAM,aAAa,YAAY,IAAI,6BAA6B,QAAQ,KAAK;AAC7E,MAAI,UAAU,WAAW,KAAK,cAAc,QAAQ;AAIlD,WAAO,IAAI,oBAAoB,IAAI,iBAAiB,SAAS,IACzD,IAAI,mBACJ;AAAA,EACN;AACA,SAAO;AACT;AAeA,SAAS,oBACP,WACA,WACA,KACQ;AACR,MAAI,CAAC,IAAI,kBAAmB,QAAO;AAEnC,QAAM,KAAK,aAAa,IAAI,oBAAoB;AAChD,QAAM,iBAAiBC,MAAK,KAAK,WAAW,cAAc,EAAE;AAE5D,MAAI,OAAO,IAAI,kBAAkB;AAC/B,WAAOC,YAAW,cAAc,IAAI,iBAAiB;AAAA,EACvD;AACA,SAAO;AACT;;;AEjJO,SAAS,oBACd,UACA,QAMwB;AACxB,QAAM,WAAW,IAAI,IAAI,OAAO,iBAAiB;AAGjD,QAAM,aAAa,oBAAI,IAA0B;AACjD,aAAW,KAAK,UAAU;AACxB,UAAM,MAAM,EAAE,YAAY;AAC1B,QAAI,SAAS,IAAI,GAAG,EAAG;AACvB,QAAI,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,SAAU;AAC/D,UAAM,OAAO,WAAW,IAAI,GAAG,KAAK,CAAC;AACrC,SAAK,KAAK,CAAC;AACX,eAAW,IAAI,KAAK,IAAI;AAAA,EAC1B;AAEA,QAAM,WAAmC,CAAC;AAC1C,MAAI,kBAAkB;AAEtB,aAAW,CAAC,UAAU,IAAI,KAAK,YAAY;AACzC,QAAI,mBAAmB,OAAO,UAAW;AAGzC,UAAM,YAAY,KAAK,IAAI,CAAC,OAAO;AAAA,MACjC,QAAQ;AAAA,MACR,QAAQ,IAAI,IAAI,sBAAsB,EAAE,SAAS,CAAC,CAAC,CAAC;AAAA,IACtD,EAAE;AAGF,UAAM,YAAY,oBAAI,IAAY;AAElC,aAAS,IAAI,GAAG,IAAI,UAAU,UAAU,kBAAkB,OAAO,WAAW,KAAK;AAC/E,UAAI,UAAU,IAAI,UAAU,CAAC,EAAE,OAAO,YAAY,EAAE,EAAG;AAEvD,YAAM,UAAwB,CAAC,UAAU,CAAC,EAAE,MAAM;AAClD,UAAI,eAAe;AACnB,UAAI,cAAc;AAElB,eAAS,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AAC7C,YAAI,UAAU,IAAI,UAAU,CAAC,EAAE,OAAO,YAAY,EAAE,EAAG;AAEvD,cAAM,UAAU,UAAU,CAAC,EAAE;AAC7B,cAAM,UAAU,UAAU,CAAC,EAAE;AAC7B,YAAI,QAAQ,SAAS,KAAK,QAAQ,SAAS,EAAG;AAG9C,cAAM,UAAU,wBAAwB,SAAS,CAAC,GAAG,OAAO,EAAE,KAAK,GAAG,CAAC;AACvE,cAAM,YAAY,KAAK,IAAI,QAAQ,MAAM,QAAQ,IAAI;AACrD,cAAM,QAAQ,YAAY,IAAI,UAAU,YAAY;AAEpD,YAAI,SAAS,OAAO,WAAW;AAC7B,kBAAQ,KAAK,UAAU,CAAC,EAAE,MAAM;AAChC,0BAAgB;AAChB;AAEA,cAAI,kBAAkB,QAAQ,UAAU,OAAO,UAAW;AAAA,QAC5D;AAAA,MACF;AAEA,UAAI,QAAQ,UAAU,OAAO,gBAAgB;AAC3C,mBAAW,KAAK,QAAS,WAAU,IAAI,EAAE,YAAY,EAAE;AACvD,iBAAS,KAAK;AAAA,UACZ;AAAA,UACA,UAAU;AAAA,UACV,cAAc,cAAc,IAAI,eAAe,cAAc;AAAA,QAC/D,CAAC;AACD,2BAAmB,QAAQ;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAKO,SAAS,yBAAyB,SAAuC;AAC9E,QAAM,cAAc,QAAQ,SACzB;AAAA,IACC,CAAC,GAAG,MACF,UAAU,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,OAAO;AAAA,EAAO,EAAE,OAAO;AAAA,EAC1F,EACC,KAAK,MAAM;AAEd,SAAO,wDAAwD,QAAQ,SAAS,MAAM,qBAAqB,QAAQ,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAS3H,WAAW;AAAA;AAAA;AAGb;AAKO,SAAS,2BAA2B,UAA0B;AACnE,SAAO,SAAS,KAAK;AACvB;AAyCO,SAAS,4BACd,SACmC;AACnC,MAAI,QAAQ,SAAS,UAAU,EAAG,QAAO;AACzC,SAAO;AACT;AAYO,SAAS,sCACd,SACQ;AACR,QAAM,cAAc,QAAQ,SACzB;AAAA,IACC,CAAC,GAAG,MACF,UAAU,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,OAAO;AAAA,EAAO,EAAE,OAAO;AAAA,EAC1F,EACC,KAAK,MAAM;AAEd,SAAO,yDAAyD,QAAQ,SAAS,MAAM,qBAAqB,QAAQ,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAmB9G,QAAQ,QAAQ;AAAA;AAAA;AAAA,EAG9B,WAAW;AAAA;AAAA;AAGb;AAgBO,SAAS,wCACd,UACA,SACkC;AAClC,QAAM,WAA6C;AAAA,IACjD,UAAU,4BAA4B,OAAO;AAAA,IAC7C,QAAQ,SAAS,KAAK;AAAA,EACxB;AAEA,QAAM,UAAU,SAAS,KAAK;AAC9B,MAAI,QAAQ,WAAW,EAAG,QAAO;AAGjC,QAAM,SAAS,qCAAqC,KAAK,OAAO;AAChE,QAAM,UAAU,SAAS,OAAO,CAAC,EAAE,KAAK,IAAI;AAQ5C,QAAM,SAAS,+BAA+B,OAAO;AACrD,MAAI,WAAW,OAAW,QAAO;AACjC,MAAI,OAAO,WAAW,YAAY,WAAW,KAAM,QAAO;AAE1D,QAAM,MAAM;AACZ,QAAM,cAAc,OAAO,IAAI,aAAa,WAAW,IAAI,SAAS,KAAK,EAAE,YAAY,IAAI;AAC3F,QAAM,YAAY,OAAO,IAAI,WAAW,WAAW,IAAI,SAAS;AAQhE,QAAM,WAAW,mCAAoC,WAAW,IAC5D,cACA,4BAA4B,OAAO;AACvC,QAAM,SAAS,UAAU,KAAK,EAAE,SAAS,IAAI,UAAU,KAAK,IAAI,SAAS,KAAK;AAE9E,SAAO,EAAE,UAAU,OAAO;AAC5B;AAiBA,SAAS,+BAA+B,MAAuB;AAC7D,MAAI,aAAa;AACjB,MAAI,OAAgB;AACpB,SAAO,aAAa,KAAK,QAAQ;AAC/B,UAAM,QAAQ,KAAK,QAAQ,KAAK,UAAU;AAC1C,QAAI,QAAQ,EAAG,QAAO;AACtB,QAAI,QAAQ;AACZ,QAAI,WAAW;AACf,QAAI,SAAS;AACb,QAAI,SAAS;AACb,QAAI,SAAS;AACb,aAAS,IAAI,OAAO,IAAI,KAAK,QAAQ,KAAK;AACxC,YAAM,KAAK,KAAK,CAAC;AACjB,UAAI,UAAU;AACZ,YAAI,QAAQ;AACV,mBAAS;AAAA,QACX,WAAW,OAAO,MAAM;AACtB,mBAAS;AAAA,QACX,WAAW,OAAO,KAAK;AACrB,qBAAW;AAAA,QACb;AACA;AAAA,MACF;AACA,UAAI,OAAO,KAAK;AACd,mBAAW;AAAA,MACb,WAAW,OAAO,KAAK;AACrB,iBAAS;AAAA,MACX,WAAW,OAAO,KAAK;AACrB,iBAAS;AACT,YAAI,UAAU,GAAG;AACf,mBAAS;AACT,mBAAS;AACT;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,QAAQ,KAAK,MAAM,OAAO,SAAS,CAAC;AAC1C,QAAI;AACF,YAAM,SAAS,KAAK,MAAM,KAAK;AAC/B,UACE,OAAO,WAAW,YAClB,WAAW,QACX,cAAe,QACf;AACA,eAAO;AAAA,MACT;AAAA,IACF,QAAQ;AAAA,IAER;AACA,iBAAa,SAAS;AAAA,EACxB;AACA,SAAO;AACT;AAUA,eAAsB,qCACpB,QACiB;AACjB,MAAI,CAAC,OAAO,wBAAyB,QAAO;AAC5C,QAAM,OAAO,sBAAsB,MAAM;AACzC,QAAM,aAAa,MAAM,yBAAyB,MAAM,GAAG;AAC3D,MAAI,WAAW,WAAW,EAAG,QAAO;AACpC,SAAO,sBAAsB,UAAU;AACzC;AAWA,eAAsB,sCAAsC,SAQtB;AAGpC,SAAO,gCAAgC,4BAA4B,OAAO;AAC5E;","names":["path","existsSync","path","existsSync"]}

package/dist/{chunk-ULYOGL6R.js → chunk-5HRY2WRF.js}

@@ -1,6 +1,7 @@
 import {
+  DERIVED_FROM_MEMORY_ID_RE,
   isConsolidationOperator
-} from "./chunk-X6GF3FX2.js";
+} from "./chunk-G7D6GZ5J.js";
 import {
   sidecarKey
 } from "./chunk-FAAFWE4G.js";
@@ -215,7 +216,7 @@ async function runConsolidationProvenanceCheck(options) {
             continue;
           }
           if (!derivedFrom.includes(tok)) {
-            if (!/^(.+):(\d+)$/u.test(tok)) {
+            if (!/^(.+):(\d+)$/u.test(tok) && !DERIVED_FROM_MEMORY_ID_RE.test(tok)) {
               report.issues.push({
                 memoryPath: memory.path,
                 memoryId: fm.id,
@@ -237,6 +238,9 @@ async function runConsolidationProvenanceCheck(options) {
     }
     if (hasFrom) {
       for (const entry of derivedFrom) {
+        if (derivedVia === "pattern-reinforcement" && DERIVED_FROM_MEMORY_ID_RE.test(entry)) {
+          continue;
+        }
         const resolved = resolveSnapshotPath(memoryDir, sidecarDir, entry);
         if (!resolved.ok) {
           report.issues.push({
@@ -319,4 +323,4 @@ async function* walkMarkdownFiles(root) {
 export {
   runConsolidationProvenanceCheck
 };
-//# sourceMappingURL=chunk-ULYOGL6R.js.map
+//# sourceMappingURL=chunk-5HRY2WRF.js.map

package/dist/chunk-5HRY2WRF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/consolidation-provenance-check.ts"],"sourcesContent":["/**\n * Consolidation provenance integrity check (issue #561 PR 4).\n *\n * Validates that every memory carrying consolidation provenance frontmatter\n * (`derived_from`, `derived_via`) resolves to real data:\n *\n *   - Each `derived_from` entry `\"<path>:<version>\"` must name a\n *     page-version snapshot that exists on disk (via the sidecar layout\n *     documented in `page-versioning.ts`).\n *   - Each `derived_via` must be one of the known\n *     `ConsolidationOperator` values — malformed values are surfaced as\n *     warnings rather than crashes so legacy or future operators survive a\n *     rollback.\n *\n * Non-fatal: every failure renders a warning with the offending file path\n * and a human-readable reason.  Integrity problems are informational for\n * now — we do not auto-heal or archive broken memories.\n */\n\nimport path from \"node:path\";\nimport { access, readdir, readFile, stat } from \"node:fs/promises\";\nimport { constants as fsConstants } from \"node:fs\";\nimport type { StorageManager } from \"./storage.js\";\nimport {\n  DERIVED_FROM_MEMORY_ID_RE,\n  isConsolidationOperator,\n} from \"./consolidation-operator.js\";\n// Import the canonical `sidecarKey` from page-versioning (PR #634\n// review, cursor Medium) so a future key-format change stays in\n// lock-step with the doctor scan.\nimport { sidecarKey } from \"./page-versioning.js\";\n\n/**\n * Regex to spot a `derived_via: <value>` line in the raw YAML frontmatter\n * between the opening and first closing `---` delimiters.  We use the raw\n * text rather than the parsed `frontmatter.derived_via` because the\n * read-path parser coerces unknown values back to `undefined` — that\n * would silently hide corrupted-or-future operators from the doctor scan\n * (PR #634 review feedback, codex P2).\n */\n// Allow empty capture groups so truncated/blank `derived_via:` and\n// `derived_from:` lines (key present, no value) are distinguishable\n// from \"key missing entirely\" (regex returns null).  Optional\n// leading whitespace accepts indented keys which `parseFrontmatter`\n// also accepts (PR #634 round-6 review, codex P2).\nconst DERIVED_VIA_RAW_RE = /^[\\t ]*derived_via:[\\t ]*(.*)$/mu;\nconst DERIVED_FROM_RAW_RE = /^[\\t ]*derived_from:[\\t ]*(.*)$/mu;\n\n/**\n * Tokenize a YAML-block-style list under `key:` in the given\n * frontmatter slice.  Looks for lines matching `^  - <value>` after a\n * `key:` line and before the next non-list line.  Returns `null` when\n * the key is missing or the value is a scalar / flow list (no block\n * entries found).\n *\n * Only used for the mixed-list malformed-entry detection — it does\n * not try to decode YAML escape sequences since we only need the\n * entry count + raw token text to compare against the parsed array.\n */\nfunction tokenizeRawBlockList(fmSlice: string, key: string): string[] | null {\n  const lines = fmSlice.split(\"\\n\");\n  // Accept indented keys too — parseFrontmatter does (PR #634 round-7\n  // review, codex P2 / cursor Low).\n  const keyRe = new RegExp(`^[\\\\t ]*${key}:[\\\\t ]*(.*)$`, \"u\");\n  let startIdx = -1;\n  for (let i = 0; i < lines.length; i++) {\n    const m = lines[i].match(keyRe);\n    if (m) {\n      if (m[1].trim().length === 0) {\n        startIdx = i + 1;\n      }\n      break;\n    }\n  }\n  if (startIdx < 0) return null;\n  const items: string[] = [];\n  for (let i = startIdx; i < lines.length; i++) {\n    const line = lines[i];\n    if (!/^\\s+-/.test(line)) break; // not a block-list entry\n    const m = line.match(/^\\s+-\\s*(.*)$/u);\n    if (!m) break;\n    let tok = m[1].trim();\n    if (\n      (tok.startsWith('\"') && tok.endsWith('\"') && tok.length >= 2) ||\n      (tok.startsWith(\"'\") && tok.endsWith(\"'\") && tok.length >= 2)\n    ) {\n      tok = tok.slice(1, -1);\n    }\n    items.push(tok);\n  }\n  return items.length > 0 ? items : null;\n}\n\n/**\n * Tokenize a YAML-flow-style list (`[\"a\", \"b\", ...]`) into a flat\n * string array.  Returns `null` when the input isn't a flow list.\n * Best-effort — we don't implement a full YAML parser, just enough to\n * detect mixed valid/invalid entries for the doctor integrity check.\n */\nfunction tokenizeRawFlowList(raw: string): string[] | null {\n  const trimmed = raw.trim();\n  if (!trimmed.startsWith(\"[\") || !trimmed.endsWith(\"]\")) return null;\n  const inner = trimmed.slice(1, -1);\n  const parts: string[] = [];\n  let current = \"\";\n  let inSingle = false;\n  let inDouble = false;\n  for (let i = 0; i < inner.length; i++) {\n    const ch = inner[i];\n    if (inDouble) {\n      if (ch === \"\\\\\" && i + 1 < inner.length) {\n        current += inner[++i];\n        continue;\n      }\n      if (ch === '\"') {\n        inDouble = false;\n        continue;\n      }\n      current += ch;\n    } else if (inSingle) {\n      if (ch === \"'\" && inner[i + 1] === \"'\") {\n        current += \"'\";\n        i++;\n        continue;\n      }\n      if (ch === \"'\") {\n        inSingle = false;\n        continue;\n      }\n      current += ch;\n    } else if (ch === '\"') {\n      inDouble = true;\n    } else if (ch === \"'\") {\n      inSingle = true;\n    } else if (ch === \",\") {\n      parts.push(current.trim());\n      current = \"\";\n    } else {\n      current += ch;\n    }\n  }\n  if (current.trim().length > 0 || parts.length > 0) {\n    parts.push(current.trim());\n  }\n  return parts;\n}\n\n/**\n * One integrity warning attached to a specific memory.\n */\nexport interface ConsolidationProvenanceIssue {\n  /** Absolute path to the memory markdown file. */\n  memoryPath: string;\n  /** Memory id from frontmatter. */\n  memoryId: string;\n  /** Type of integrity issue. */\n  kind:\n    | \"derived_from_missing_snapshot\"\n    | \"derived_from_malformed_entry\"\n    | \"derived_via_unknown_operator\";\n  /** Human-readable detail — includes the offending value when relevant. */\n  detail: string;\n}\n\n/**\n * Summary of a provenance-integrity scan.  Used by the operator-doctor\n * report and surfaced in the CLI output.\n */\nexport interface ConsolidationProvenanceReport {\n  /** Total memories inspected. */\n  scanned: number;\n  /** Memories that carry `derived_from` and/or `derived_via`. */\n  withProvenance: number;\n  /** One entry per problem detected (may be empty). */\n  issues: ConsolidationProvenanceIssue[];\n}\n\nconst DERIVED_FROM_ENTRY_RE = /^(.+):(\\d+)$/;\n\n/**\n * Build the on-disk snapshot path for a `\"<relpath>:<version>\"` entry,\n * relative to the given memory directory.  Mirrors the layout documented\n * in `page-versioning.ts`:\n *\n *   memoryDir/<sidecarDir>/<sidecarKey>/<version><ext>\n */\nfunction resolveSnapshotPath(\n  memoryDir: string,\n  sidecarDir: string,\n  entry: string,\n): { ok: true; snapshotPath: string } | { ok: false; reason: string } {\n  const match = entry.match(DERIVED_FROM_ENTRY_RE);\n  if (!match) {\n    return { ok: false, reason: `malformed entry (expected \"<path>:<version>\")` };\n  }\n  const pagePath = match[1];\n  const versionId = match[2];\n  const ext = path.extname(pagePath) || \".md\";\n  const key = sidecarKey(pagePath);\n  const snapshotPath = path.join(memoryDir, sidecarDir, key, `${versionId}${ext}`);\n  return { ok: true, snapshotPath };\n}\n\n/**\n * Scan every memory under `storage` and flag consolidation-provenance\n * problems.  Does not throw on individual failures — collects them in the\n * returned report.\n */\nexport async function runConsolidationProvenanceCheck(options: {\n  storage: StorageManager;\n  memoryDir: string;\n  /**\n   * Page-versioning sidecar directory name.  Defaults to `.versions` —\n   * matches the baked-in default used by `setVersioningConfig` when\n   * versioning is enabled via config.\n   */\n  sidecarDir?: string;\n}): Promise<ConsolidationProvenanceReport> {\n  const { storage, memoryDir } = options;\n  const sidecarDir = options.sidecarDir ?? \".versions\";\n\n  const report: ConsolidationProvenanceReport = {\n    scanned: 0,\n    withProvenance: 0,\n    issues: [],\n  };\n\n  let memories;\n  try {\n    memories = await storage.readAllMemories();\n  } catch {\n    // If we can't enumerate memories at all, surface a single synthetic\n    // issue rather than throwing — the doctor wrapper treats an empty\n    // issues list as \"ok\" and we don't want a filesystem hiccup to crash\n    // the whole diagnostic.\n    return {\n      scanned: 0,\n      withProvenance: 0,\n      issues: [\n        {\n          memoryPath: memoryDir,\n          memoryId: \"(unreadable)\",\n          kind: \"derived_from_malformed_entry\",\n          detail: \"Could not enumerate memory directory to scan provenance.\",\n        },\n      ],\n    };\n  }\n\n  for (const memory of memories) {\n    report.scanned += 1;\n    const fm = memory.frontmatter;\n    const derivedFrom = fm.derived_from;\n    const derivedVia = fm.derived_via;\n\n    // Raw frontmatter values from disk — the read-path parser coerces\n    // malformed `derived_from` and unknown `derived_via` back to\n    // `undefined`, which would silently hide on-disk corruption from\n    // the doctor scan (PR #634 review feedback, codex P2).  We\n    // re-extract both via regex so integrity issues are reported even\n    // when the parser normalized them away.  `rawDerivedVia` /\n    // `rawDerivedFrom` being `\"\"` (empty string) represents a\n    // corrupted file with the key present but the value truncated —\n    // that's distinct from \"key missing entirely\" (undefined).\n    let rawDerivedVia: string | undefined;\n    let rawDerivedFrom: string | undefined;\n    let rawDerivedViaKeyPresent = false;\n    let rawDerivedFromKeyPresent = false;\n    let duplicateViaKeys = false;\n    let duplicateFromKeys = false;\n    let viaMatchCount = 0;\n    let fromMatchCount = 0;\n    let fmSlice = \"\";\n    try {\n      const raw = await readFile(memory.path, \"utf-8\");\n      const frontmatterEnd = raw.indexOf(\"\\n---\", raw.indexOf(\"---\") + 3);\n      fmSlice = frontmatterEnd > 0 ? raw.slice(0, frontmatterEnd) : raw;\n      // Use matchAll to find ALL occurrences of `derived_via` / `derived_from`\n      // in the raw YAML.  `parseFrontmatter` keeps the LAST assignment when\n      // duplicate keys appear, so the doctor must read the last occurrence\n      // to match what the storage reader actually uses (PR #634 review,\n      // codex P2 — duplicate `derived_via` keys caused false-clean or\n      // false-unknown-operator warnings depending on order).\n      const viaMatches = [...fmSlice.matchAll(new RegExp(DERIVED_VIA_RAW_RE.source, DERIVED_VIA_RAW_RE.flags + \"g\"))];\n      viaMatchCount = viaMatches.length;\n      duplicateViaKeys = viaMatches.length > 1;\n      if (viaMatches.length > 0) {\n        rawDerivedViaKeyPresent = true;\n        // Use the last occurrence — `parseFrontmatter` keeps the last\n        // assignment when duplicate keys appear, so the doctor must\n        // match that behavior to produce accurate warnings (PR #634\n        // review, codex P2).\n        const lastVia = viaMatches[viaMatches.length - 1];\n        let val = lastVia[1].trim();\n        if (\n          (val.startsWith('\"') && val.endsWith('\"')) ||\n          (val.startsWith(\"'\") && val.endsWith(\"'\"))\n        ) {\n          val = val.slice(1, -1);\n        }\n        rawDerivedVia = val;\n      }\n      const fromMatches = [...fmSlice.matchAll(new RegExp(DERIVED_FROM_RAW_RE.source, DERIVED_FROM_RAW_RE.flags + \"g\"))];\n      fromMatchCount = fromMatches.length;\n      duplicateFromKeys = fromMatches.length > 1;\n      if (fromMatches.length > 0) {\n        rawDerivedFromKeyPresent = true;\n        const lastFrom = fromMatches[fromMatches.length - 1];\n        rawDerivedFrom = lastFrom[1].trim();\n      }\n    } catch {\n      // Fall through to the parsed values.\n    }\n\n    const hasFrom = Array.isArray(derivedFrom) && derivedFrom.length > 0;\n    const hasVia = derivedVia !== undefined && derivedVia !== null;\n    const hasRawVia = rawDerivedVia !== undefined && rawDerivedVia.length > 0;\n    // A raw `derived_from` that the parser dropped indicates on-disk\n    // corruption we must surface.  We detect this by: (a) the raw YAML\n    // contains a `derived_from:` key, AND (b) the parsed frontmatter\n    // has no valid array.  A scalar like `derived_from: facts/a.md:7`\n    // (list brackets omitted) or a blank `derived_from:` both hit this\n    // branch.\n    const hasRawMalformedFrom = rawDerivedFromKeyPresent && !hasFrom;\n    // A blank `derived_via:` with no value is also corrupt — the\n    // parser drops it to undefined, but the raw key is still present\n    // on disk (PR #634 round-3 review, codex P2).\n    const hasBlankRawVia =\n      rawDerivedViaKeyPresent &&\n      (rawDerivedVia === undefined || rawDerivedVia.length === 0) &&\n      !hasVia;\n    if (\n      !hasFrom && !hasVia && !hasRawVia &&\n      !hasRawMalformedFrom && !hasBlankRawVia\n    ) continue;\n    report.withProvenance += 1;\n\n    // Duplicate-key detection (PR #634 review, codex P2): when the raw\n    // YAML contains multiple `derived_via` or `derived_from` lines,\n    // `parseFrontmatter` silently uses the last one.  Flag this as a\n    // malformed entry so operators can inspect and fix the file.\n    if (duplicateViaKeys) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: `raw YAML contains ${viaMatchCount} \"derived_via\" keys; parseFrontmatter uses the last occurrence`,\n      });\n    }\n    if (duplicateFromKeys) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_from_malformed_entry\",\n        detail: `raw YAML contains ${fromMatchCount} \"derived_from\" keys; parseFrontmatter uses the last occurrence`,\n      });\n    }\n\n    if (hasRawMalformedFrom) {\n      const display = rawDerivedFrom ?? \"(blank)\";\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_from_malformed_entry\",\n        detail: `raw YAML \"derived_from: ${display}\" could not be parsed as a list`,\n      });\n    }\n\n    // Mixed-list detection (PR #634 round-4 + round-5 review, codex\n    // P2): when the parser DID return a valid list but the raw YAML\n    // includes additional tokens that got dropped, flag those as\n    // malformed.  Handles both flow-style (`[\"a\", \"\", \"b\"]`) and\n    // block-style (`\\n  - a\\n  - \\n  - b`) YAML lists.\n    if (hasFrom && rawDerivedFromKeyPresent) {\n      let rawList: string[] | null = null;\n      if (rawDerivedFrom && rawDerivedFrom.length > 0) {\n        rawList = tokenizeRawFlowList(rawDerivedFrom);\n      }\n      if (rawList === null) {\n        // Fall back to block-list tokenization by re-reading the full\n        // frontmatter (already loaded above as `raw`) and scanning\n        // the lines following `derived_from:`.\n        rawList = tokenizeRawBlockList(fmSlice, \"derived_from\");\n      }\n      if (rawList !== null && rawList.length > derivedFrom!.length) {\n        for (const tok of rawList) {\n          if (tok.length === 0) {\n            report.issues.push({\n              memoryPath: memory.path,\n              memoryId: fm.id,\n              kind: \"derived_from_malformed_entry\",\n              detail: `raw YAML derived_from contains an empty entry (mixed list)`,\n            });\n            continue;\n          }\n          if (!derivedFrom!.includes(tok)) {\n            // Accept either the snapshot format `<path>:<version>` or\n            // a bare memory id (issue #687 PR 2/4 — pattern\n            // reinforcement uses ID-shaped entries).  PR #730\n            // review feedback, Codex P2.\n            if (\n              !/^(.+):(\\d+)$/u.test(tok) &&\n              !DERIVED_FROM_MEMORY_ID_RE.test(tok)\n            ) {\n              report.issues.push({\n                memoryPath: memory.path,\n                memoryId: fm.id,\n                kind: \"derived_from_malformed_entry\",\n                detail: `raw YAML derived_from contains a malformed entry: ${JSON.stringify(tok)}`,\n              });\n            }\n          }\n        }\n      }\n    }\n    if (hasBlankRawVia) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: \"raw YAML has `derived_via:` key with empty value\",\n      });\n    }\n\n    if (hasFrom) {\n      for (const entry of derivedFrom!) {\n        // Pattern-reinforcement (issue #687 PR 2/4) records source\n        // memory IDs directly in `derived_from` rather than\n        // page-versioning snapshot references.  Memory IDs may\n        // contain `:` for namespace-prefixed forms like\n        // `global:fact-abc-123`, but never `/` or `.` — those remain\n        // exclusive to snapshot paths (PR #730 review feedback,\n        // Codex P1).  For ID-shaped entries we skip the snapshot\n        // file check entirely — but ONLY when the operator is\n        // `pattern-reinforcement`, which is the sole operator that\n        // legitimately stores IDs rather than snapshot references.\n        // Allowing the bypass for split/merge/update would weaken\n        // validation on those existing consolidation paths (PR #730\n        // review, Codex P2).\n        if (\n          derivedVia === \"pattern-reinforcement\" &&\n          DERIVED_FROM_MEMORY_ID_RE.test(entry)\n        ) {\n          continue;\n        }\n        const resolved = resolveSnapshotPath(memoryDir, sidecarDir, entry);\n        if (!resolved.ok) {\n          report.issues.push({\n            memoryPath: memory.path,\n            memoryId: fm.id,\n            kind: \"derived_from_malformed_entry\",\n            detail: `${JSON.stringify(entry)}: ${resolved.reason}`,\n          });\n          continue;\n        }\n        // Require a regular file at the snapshot path (PR #634\n        // round-8 review, codex P2) — a directory or device node at\n        // that path means the sidecar was corrupted and the snapshot\n        // is effectively missing.\n        let snapshotOk = false;\n        try {\n          const st = await stat(resolved.snapshotPath);\n          snapshotOk = st.isFile();\n        } catch {\n          snapshotOk = false;\n        }\n        if (!snapshotOk) {\n          report.issues.push({\n            memoryPath: memory.path,\n            memoryId: fm.id,\n            kind: \"derived_from_missing_snapshot\",\n            detail: `${entry} → ${resolved.snapshotPath} (not a regular file)`,\n          });\n        }\n      }\n    }\n\n    // Check the RAW YAML value for unknown operators.  The parsed value\n    // (`fm.derived_via`) is always known-good because the read-path\n    // normalizer dropped anything else to undefined.\n    if (hasRawVia && !isConsolidationOperator(rawDerivedVia)) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: `unknown operator: ${JSON.stringify(rawDerivedVia)}`,\n      });\n    }\n  }\n\n  // Parse-failure detection (PR #634 round-4 review, codex P2):\n  // `readAllMemories()` silently drops files whose frontmatter\n  // doesn't parse.  Walk the facts/ and corrections/ directories for\n  // `.md` files that DO reference provenance frontmatter but didn't\n  // come back from the reader — those are the corruption cases the\n  // doctor is meant to surface.\n  try {\n    const seenPaths = new Set(memories.map((m) => m.path));\n    const scanRoots = [\"facts\", \"corrections\", \"procedures\", \"reasoning-traces\"];\n    for (const rootName of scanRoots) {\n      const rootPath = path.join(memoryDir, rootName);\n      for await (const file of walkMarkdownFiles(rootPath)) {\n        if (seenPaths.has(file)) continue;\n        try {\n          const raw = await readFile(file, \"utf-8\");\n          if (\n            DERIVED_FROM_RAW_RE.test(raw) ||\n            DERIVED_VIA_RAW_RE.test(raw)\n          ) {\n            report.withProvenance += 1;\n            report.issues.push({\n              memoryPath: file,\n              memoryId: \"(parse failed)\",\n              kind: \"derived_from_malformed_entry\",\n              detail:\n                \"frontmatter could not be parsed by storage reader; provenance fields visible in raw YAML\",\n            });\n          }\n        } catch {\n          // Unreadable file — skip.\n        }\n      }\n    }\n  } catch {\n    // Best-effort; don't fail the whole scan on a filesystem hiccup.\n  }\n\n  return report;\n}\n\n/**\n * Recursively yield all `.md` file paths under `root`.  Silent on\n * missing directories — the facts/corrections dirs may not exist in\n * fresh installs.\n */\nasync function* walkMarkdownFiles(root: string): AsyncGenerator<string> {\n  let entries;\n  try {\n    entries = await readdir(root, { withFileTypes: true });\n  } catch {\n    return;\n  }\n  for (const entry of entries) {\n    const full = path.join(root, entry.name);\n    if (entry.isDirectory()) {\n      yield* walkMarkdownFiles(full);\n    } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n      yield full;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-6TBWYBJ3.js

@@ -0,0 +1,236 @@
+import {
+  expandTildePath
+} from "./chunk-IXEJRKCZ.js";
+
+// src/connectors/live/state-store.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/connectors/live/framework.ts
+var CONNECTOR_ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+function isValidConnectorId(id) {
+  return typeof id === "string" && CONNECTOR_ID_PATTERN.test(id);
+}
+
+// src/connectors/live/state-store.ts
+var STATE_DIR_NAME = "state";
+var CONNECTORS_DIR_NAME = "connectors";
+var MAX_ERROR_LENGTH = 1024;
+var VALID_SYNC_STATUSES = /* @__PURE__ */ new Set([
+  "success",
+  "error",
+  "never"
+]);
+var ConnectorStateCorruptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorStateCorruptionError";
+  }
+};
+function resolveConnectorsDir(memoryDir) {
+  if (typeof memoryDir !== "string" || memoryDir.length === 0) {
+    throw new TypeError("memoryDir must be a non-empty string");
+  }
+  return path.join(expandTildePath(memoryDir), STATE_DIR_NAME, CONNECTORS_DIR_NAME);
+}
+function resolveConnectorStatePath(memoryDir, id) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  return path.join(resolveConnectorsDir(memoryDir), `${id}.json`);
+}
+function isConnectorStateShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.id !== "string") return false;
+  if (typeof v.lastSyncStatus !== "string") return false;
+  if (!["success", "error", "never"].includes(v.lastSyncStatus)) return false;
+  if (typeof v.totalDocsImported !== "number" || !Number.isInteger(v.totalDocsImported)) return false;
+  if (v.totalDocsImported < 0) return false;
+  if (typeof v.updatedAt !== "string") return false;
+  if (v.lastSyncAt !== null && typeof v.lastSyncAt !== "string") return false;
+  if (v.cursor !== null) {
+    if (typeof v.cursor !== "object" || v.cursor === null) return false;
+    const c = v.cursor;
+    if (typeof c.kind !== "string" || typeof c.value !== "string" || typeof c.updatedAt !== "string") {
+      return false;
+    }
+  }
+  if (v.lastSyncError !== void 0 && typeof v.lastSyncError !== "string") return false;
+  return true;
+}
+async function assertNoSymlinkOnPath(memoryDir, filePath) {
+  const expandedRoot = expandTildePath(memoryDir);
+  const root = path.resolve(expandedRoot);
+  const target = path.resolve(filePath);
+  const rel = path.relative(root, target);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(
+      `connector state path ${target} escapes memory root ${root}`
+    );
+  }
+  const segments = rel.length === 0 ? [] : rel.split(path.sep);
+  let current = root;
+  const componentsToCheck = [current];
+  for (const seg of segments) {
+    current = path.join(current, seg);
+    componentsToCheck.push(current);
+  }
+  for (const component of componentsToCheck) {
+    let stat;
+    try {
+      stat = await fs.lstat(component);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    if (stat.isSymbolicLink()) {
+      throw new Error(
+        `connector state path component ${component} is a symlink; refusing to follow`
+      );
+    }
+  }
+}
+async function readConnectorState(memoryDir, id) {
+  const filePath = resolveConnectorStatePath(memoryDir, id);
+  await assertNoSymlinkOnPath(memoryDir, filePath);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} is not valid JSON: ${err.message}`
+    );
+  }
+  if (!isConnectorStateShape(parsed)) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} does not match ConnectorState shape`
+    );
+  }
+  if (parsed.id !== id) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} has mismatched id ${JSON.stringify(parsed.id)}; expected ${JSON.stringify(id)}`
+    );
+  }
+  return parsed;
+}
+async function writeConnectorState(memoryDir, id, state) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  if (state.id !== id) {
+    throw new Error(
+      `writeConnectorState(): state.id ${JSON.stringify(state.id)} does not match id argument ${JSON.stringify(id)}`
+    );
+  }
+  if (!VALID_SYNC_STATUSES.has(state.lastSyncStatus)) {
+    throw new Error(
+      `writeConnectorState(): lastSyncStatus must be one of ${[...VALID_SYNC_STATUSES].join(", ")}, got ${JSON.stringify(state.lastSyncStatus)}`
+    );
+  }
+  if (state.lastSyncAt !== null && typeof state.lastSyncAt !== "string") {
+    throw new Error(
+      `writeConnectorState(): lastSyncAt must be a string or null, got ${typeof state.lastSyncAt}`
+    );
+  }
+  if (state.cursor !== null) {
+    if (typeof state.cursor !== "object") {
+      throw new Error(`writeConnectorState(): cursor must be an object or null`);
+    }
+    if (typeof state.cursor.kind !== "string" || typeof state.cursor.value !== "string" || typeof state.cursor.updatedAt !== "string") {
+      throw new Error(
+        `writeConnectorState(): cursor must have string kind, value, and updatedAt`
+      );
+    }
+  }
+  if (typeof state.totalDocsImported !== "number" || !Number.isInteger(state.totalDocsImported) || state.totalDocsImported < 0) {
+    throw new Error(
+      `writeConnectorState(): totalDocsImported must be a non-negative integer`
+    );
+  }
+  if (state.lastSyncError !== void 0 && typeof state.lastSyncError !== "string") {
+    throw new Error(`writeConnectorState(): lastSyncError must be a string when provided`);
+  }
+  const truncatedError = state.lastSyncError !== void 0 && state.lastSyncError.length > MAX_ERROR_LENGTH ? state.lastSyncError.slice(0, MAX_ERROR_LENGTH) : state.lastSyncError;
+  const finalState = {
+    id: state.id,
+    cursor: state.cursor,
+    lastSyncAt: state.lastSyncAt,
+    lastSyncStatus: state.lastSyncStatus,
+    ...truncatedError !== void 0 ? { lastSyncError: truncatedError } : {},
+    totalDocsImported: state.totalDocsImported,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const dir = resolveConnectorsDir(memoryDir);
+  const targetPath = path.join(dir, `${id}.json`);
+  await assertNoSymlinkOnPath(memoryDir, targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const body = `${JSON.stringify(finalState, null, 2)}
+`;
+  try {
+    await fs.writeFile(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    await fs.rename(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return finalState;
+}
+async function listConnectorStates(memoryDir) {
+  const dir = resolveConnectorsDir(memoryDir);
+  await assertNoSymlinkOnPath(memoryDir, dir);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const id = entry.slice(0, -".json".length);
+    if (!isValidConnectorId(id)) continue;
+    try {
+      const state = await readConnectorState(memoryDir, id);
+      if (state !== null) out.push(state);
+    } catch (err) {
+      if (err instanceof ConnectorStateCorruptionError) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  out.sort((a, b) => a.id.localeCompare(b.id));
+  return out;
+}
+function _connectorStatePathForTest(memoryDir, id) {
+  return resolveConnectorStatePath(memoryDir, id);
+}
+
+export {
+  CONNECTOR_ID_PATTERN,
+  isValidConnectorId,
+  readConnectorState,
+  writeConnectorState,
+  listConnectorStates,
+  _connectorStatePathForTest
+};
+//# sourceMappingURL=chunk-6TBWYBJ3.js.map

package/dist/chunk-6TBWYBJ3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/connectors/live/state-store.ts","../src/connectors/live/framework.ts"],"sourcesContent":["/**\n * @remnic/core — Live Connectors State Store (issue #683 PR 1/N)\n *\n * Persists per-connector cursor + sync metadata to\n *   `<memoryDir>/state/connectors/<id>.json`\n *\n * Reasons this lives next to memory data, not in user config:\n *   - cursors are *operational* state that should travel with the memory\n *     directory when a user moves it across machines;\n *   - it keeps memory + ingest provenance co-located so tooling that backs up\n *     the memory directory captures cursor state too.\n *\n * Atomic-write contract (CLAUDE.md gotcha #54):\n *   - We NEVER `rmSync(target)` before `renameSync(tmp, target)`.\n *   - Writes go to a sibling tmp file and `rename()` swaps it in.\n *   - On error, the tmp file is best-effort cleaned up; the previous good\n *     state file is left untouched.\n *\n * Privacy: cursors are opaque connector-defined strings. We do not log them\n * and do not surface them through user-visible APIs. Document content NEVER\n * touches this module.\n */\n\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\n\nimport { expandTildePath } from \"../../utils/path.js\";\n\nimport {\n  isValidConnectorId,\n  type ConnectorCursor,\n} from \"./framework.js\";\n\n/**\n * Status of the most recent sync attempt for a connector.\n *\n * `\"never\"` is distinct from `\"success\"` so callers can detect\n * \"registered but never run\" without inspecting timestamps. Per CLAUDE.md\n * gotcha #34, we deliberately distinguish empty/unknown from failure states.\n */\nexport type ConnectorSyncStatus = \"success\" | \"error\" | \"never\";\n\n/**\n * Persisted per-connector state.\n *\n * Stored as pretty-printed JSON for human inspection — the file is small\n * (one record per connector) and operators may need to debug stuck cursors\n * by hand.\n */\nexport interface ConnectorState {\n  /** Connector id. Matches the filename stem. */\n  readonly id: string;\n  /** Last persisted cursor, or `null` if the connector has never synced. */\n  readonly cursor: ConnectorCursor | null;\n  /** ISO 8601 timestamp of the last completed sync attempt, or `null`. */\n  readonly lastSyncAt: string | null;\n  /** Status of the last completed sync attempt. */\n  readonly lastSyncStatus: ConnectorSyncStatus;\n  /** Optional error message from the last failed sync. Truncated to 1 KB. */\n  readonly lastSyncError?: string;\n  /** Cumulative count of documents successfully imported across all syncs. */\n  readonly totalDocsImported: number;\n  /** ISO 8601 timestamp of when this state record was last written. */\n  readonly updatedAt: string;\n}\n\nconst STATE_DIR_NAME = \"state\";\nconst CONNECTORS_DIR_NAME = \"connectors\";\nconst MAX_ERROR_LENGTH = 1024;\nconst VALID_SYNC_STATUSES: ReadonlySet<ConnectorSyncStatus> = new Set([\n  \"success\",\n  \"error\",\n  \"never\",\n]);\n\n/**\n * Internal error thrown when a state file's JSON is unparseable or its shape\n * doesn't match `ConnectorState`. Used by `listConnectorStates` to distinguish\n * \"skip this corrupt file\" cases from genuine I/O failures (`EACCES`, `EIO`)\n * that the caller must see.\n */\nclass ConnectorStateCorruptionError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConnectorStateCorruptionError\";\n  }\n}\n\n/**\n * Resolve `<memoryDir>/state/connectors/`, expanding `~` per CLAUDE.md #17.\n */\nfunction resolveConnectorsDir(memoryDir: string): string {\n  if (typeof memoryDir !== \"string\" || memoryDir.length === 0) {\n    throw new TypeError(\"memoryDir must be a non-empty string\");\n  }\n  return path.join(expandTildePath(memoryDir), STATE_DIR_NAME, CONNECTORS_DIR_NAME);\n}\n\n/**\n * Resolve the state file path for a single connector. Throws on invalid id\n * to prevent path traversal via crafted ids.\n */\nfunction resolveConnectorStatePath(memoryDir: string, id: string): string {\n  if (!isValidConnectorId(id)) {\n    throw new TypeError(\n      `invalid connector id ${JSON.stringify(id)} — must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`,\n    );\n  }\n  return path.join(resolveConnectorsDir(memoryDir), `${id}.json`);\n}\n\n/**\n * Type guard for parsed state records. Validates the on-disk shape so a\n * corrupted/edited file produces a clear error rather than crashing later.\n *\n * Per CLAUDE.md gotcha #18, JSON.parse('null') yields `null` which would\n * pass a naive truthy check. We explicitly require an object.\n */\nfunction isConnectorStateShape(value: unknown): value is ConnectorState {\n  if (typeof value !== \"object\" || value === null) return false;\n  const v = value as Record<string, unknown>;\n  if (typeof v.id !== \"string\") return false;\n  if (typeof v.lastSyncStatus !== \"string\") return false;\n  if (![\"success\", \"error\", \"never\"].includes(v.lastSyncStatus)) return false;\n  // totalDocsImported is a cumulative count — fractional values would corrupt\n  // metrics on later increments. Mirror the boundary check in writeConnectorState.\n  if (typeof v.totalDocsImported !== \"number\" || !Number.isInteger(v.totalDocsImported)) return false;\n  if (v.totalDocsImported < 0) return false;\n  if (typeof v.updatedAt !== \"string\") return false;\n  if (v.lastSyncAt !== null && typeof v.lastSyncAt !== \"string\") return false;\n  if (v.cursor !== null) {\n    if (typeof v.cursor !== \"object\" || v.cursor === null) return false;\n    const c = v.cursor as Record<string, unknown>;\n    if (typeof c.kind !== \"string\" || typeof c.value !== \"string\" || typeof c.updatedAt !== \"string\") {\n      return false;\n    }\n  }\n  if (v.lastSyncError !== undefined && typeof v.lastSyncError !== \"string\") return false;\n  return true;\n}\n\n/**\n * Reject any path component along `<memoryDir>/state/connectors/<id>.json`\n * that is a symlink. Without this guard, a symlink in any of those\n * components would let `fs.readFile` escape the memory root and consume an\n * arbitrary outside file as cursor state — silently poisoning sync state and\n * violating the project-wide rule against symlink traversal.\n *\n * `lstat` is used (not `stat`) so we observe the link itself rather than its\n * target. Missing components are tolerated — the caller's `readFile` /\n * `mkdir` will surface ENOENT in its normal way.\n *\n * (PR #724 review.)\n */\nasync function assertNoSymlinkOnPath(memoryDir: string, filePath: string): Promise<void> {\n  const expandedRoot = expandTildePath(memoryDir);\n  // Normalize so `..` segments can't bypass the prefix check below.\n  const root = path.resolve(expandedRoot);\n  const target = path.resolve(filePath);\n  const rel = path.relative(root, target);\n  // path.relative() yields a \"../...\" prefix when target escapes root.\n  if (rel.startsWith(\"..\") || path.isAbsolute(rel)) {\n    throw new Error(\n      `connector state path ${target} escapes memory root ${root}`,\n    );\n  }\n  // Walk every component from root to target (inclusive) and lstat each.\n  const segments = rel.length === 0 ? [] : rel.split(path.sep);\n  let current = root;\n  const componentsToCheck = [current];\n  for (const seg of segments) {\n    current = path.join(current, seg);\n    componentsToCheck.push(current);\n  }\n  for (const component of componentsToCheck) {\n    let stat: import(\"node:fs\").Stats;\n    try {\n      stat = await fs.lstat(component);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === \"ENOENT\") {\n        // Not yet created — that's fine; caller's readFile/mkdir handles it.\n        continue;\n      }\n      throw err;\n    }\n    if (stat.isSymbolicLink()) {\n      throw new Error(\n        `connector state path component ${component} is a symlink; refusing to follow`,\n      );\n    }\n  }\n}\n\n/**\n * Read the persisted state for a single connector.\n *\n * Returns `null` if the file does not exist (ENOENT). Throws on any other\n * I/O error or on shape mismatch — operators should see corruption loudly.\n *\n * Rejects symlinks anywhere on the path so a planted symlink can't redirect\n * reads outside the memory root. (PR #724 review.)\n */\nexport async function readConnectorState(\n  memoryDir: string,\n  id: string,\n): Promise<ConnectorState | null> {\n  const filePath = resolveConnectorStatePath(memoryDir, id);\n  await assertNoSymlinkOnPath(memoryDir, filePath);\n  let raw: string;\n  try {\n    raw = await fs.readFile(filePath, \"utf-8\");\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n    throw err;\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (err) {\n    throw new ConnectorStateCorruptionError(\n      `connector state at ${filePath} is not valid JSON: ${(err as Error).message}`,\n    );\n  }\n  if (!isConnectorStateShape(parsed)) {\n    throw new ConnectorStateCorruptionError(\n      `connector state at ${filePath} does not match ConnectorState shape`,\n    );\n  }\n  if (parsed.id !== id) {\n    throw new ConnectorStateCorruptionError(\n      `connector state at ${filePath} has mismatched id ${JSON.stringify(parsed.id)}; expected ${JSON.stringify(id)}`,\n    );\n  }\n  return parsed;\n}\n\n/**\n * Write state atomically: create-tmp + rename. Never destroys the previous\n * file before the new one is in place — see CLAUDE.md gotcha #54.\n *\n * We accept `Omit<ConnectorState, \"updatedAt\">` and stamp `updatedAt`\n * ourselves so callers can't accidentally persist a stale timestamp.\n */\nexport async function writeConnectorState(\n  memoryDir: string,\n  id: string,\n  state: Omit<ConnectorState, \"updatedAt\">,\n): Promise<ConnectorState> {\n  if (!isValidConnectorId(id)) {\n    throw new TypeError(\n      `invalid connector id ${JSON.stringify(id)} — must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`,\n    );\n  }\n  if (state.id !== id) {\n    throw new Error(\n      `writeConnectorState(): state.id ${JSON.stringify(state.id)} does not match id argument ${JSON.stringify(id)}`,\n    );\n  }\n  // Full boundary validation. Persisting an out-of-shape record would brick\n  // the connector's cursor file: subsequent `readConnectorState` calls would\n  // throw `ConnectorStateCorruptionError` until manual repair. JS callers\n  // bypassing TS types must be rejected here, not later. (PR #724 review.)\n  if (!VALID_SYNC_STATUSES.has(state.lastSyncStatus as ConnectorSyncStatus)) {\n    throw new Error(\n      `writeConnectorState(): lastSyncStatus must be one of ${[...VALID_SYNC_STATUSES].join(\", \")}, got ${JSON.stringify(state.lastSyncStatus)}`,\n    );\n  }\n  if (state.lastSyncAt !== null && typeof state.lastSyncAt !== \"string\") {\n    throw new Error(\n      `writeConnectorState(): lastSyncAt must be a string or null, got ${typeof state.lastSyncAt}`,\n    );\n  }\n  if (state.cursor !== null) {\n    if (typeof state.cursor !== \"object\") {\n      throw new Error(`writeConnectorState(): cursor must be an object or null`);\n    }\n    if (\n      typeof state.cursor.kind !== \"string\" ||\n      typeof state.cursor.value !== \"string\" ||\n      typeof state.cursor.updatedAt !== \"string\"\n    ) {\n      throw new Error(\n        `writeConnectorState(): cursor must have string kind, value, and updatedAt`,\n      );\n    }\n  }\n  if (\n    typeof state.totalDocsImported !== \"number\" ||\n    !Number.isInteger(state.totalDocsImported) ||\n    state.totalDocsImported < 0\n  ) {\n    throw new Error(\n      `writeConnectorState(): totalDocsImported must be a non-negative integer`,\n    );\n  }\n  if (state.lastSyncError !== undefined && typeof state.lastSyncError !== \"string\") {\n    throw new Error(`writeConnectorState(): lastSyncError must be a string when provided`);\n  }\n  const truncatedError =\n    state.lastSyncError !== undefined && state.lastSyncError.length > MAX_ERROR_LENGTH\n      ? state.lastSyncError.slice(0, MAX_ERROR_LENGTH)\n      : state.lastSyncError;\n\n  const finalState: ConnectorState = {\n    id: state.id,\n    cursor: state.cursor,\n    lastSyncAt: state.lastSyncAt,\n    lastSyncStatus: state.lastSyncStatus,\n    ...(truncatedError !== undefined ? { lastSyncError: truncatedError } : {}),\n    totalDocsImported: state.totalDocsImported,\n    updatedAt: new Date().toISOString(),\n  };\n\n  const dir = resolveConnectorsDir(memoryDir);\n  const targetPath = path.join(dir, `${id}.json`);\n  // Reject planted symlinks before mkdir/write so a redirected target can't\n  // overwrite an arbitrary file outside the memory root. (PR #724 review.)\n  await assertNoSymlinkOnPath(memoryDir, targetPath);\n  await fs.mkdir(dir, { recursive: true });\n  const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n\n  const body = `${JSON.stringify(finalState, null, 2)}\\n`;\n  try {\n    await fs.writeFile(tmpPath, body, { encoding: \"utf-8\", mode: 0o600 });\n    await fs.rename(tmpPath, targetPath);\n  } catch (err) {\n    // Best-effort cleanup of the tmp file. Never touch `targetPath` — the\n    // previous good state must remain readable on failure.\n    try {\n      await fs.unlink(tmpPath);\n    } catch {\n      // ignore\n    }\n    throw err;\n  }\n  return finalState;\n}\n\n/**\n * Enumerate every persisted connector state. Returns an empty array when\n * the directory does not exist yet (clean install, no syncs ever run).\n *\n * Files that do not match the `<id>.json` naming rule are skipped — this\n * keeps stray editor backups (`.json~`, `.swp`) from breaking enumeration.\n *\n * Corruption (unparseable JSON, shape mismatch, id mismatch) is also\n * skipped so one bad file doesn't take down the listing. Operators\n * inspecting `state/connectors/` can still see the offending file by hand.\n *\n * **Genuine I/O failures (`EACCES`, `EIO`, etc.) are NOT swallowed** —\n * silently returning an incomplete state set would make active connectors\n * appear missing and trigger duplicate ingestion on the next scheduler tick.\n * (PR #724 review.)\n */\nexport async function listConnectorStates(memoryDir: string): Promise<ConnectorState[]> {\n  const dir = resolveConnectorsDir(memoryDir);\n  // Refuse to enumerate through a symlinked state directory — a planted\n  // symlink at <memoryDir>/state or <memoryDir>/state/connectors would\n  // otherwise let reads escape the memory root. (PR #724 review.)\n  await assertNoSymlinkOnPath(memoryDir, dir);\n  let entries: string[];\n  try {\n    entries = await fs.readdir(dir);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw err;\n  }\n  const out: ConnectorState[] = [];\n  for (const entry of entries) {\n    if (!entry.endsWith(\".json\")) continue;\n    const id = entry.slice(0, -\".json\".length);\n    if (!isValidConnectorId(id)) continue;\n    try {\n      const state = await readConnectorState(memoryDir, id);\n      if (state !== null) out.push(state);\n    } catch (err) {\n      if (err instanceof ConnectorStateCorruptionError) {\n        // Skip corrupt files; preserve availability of the rest.\n        continue;\n      }\n      // Anything else (EACCES, EIO, ENOTDIR, ...) is a real operational\n      // failure. Fail loudly so the scheduler / CLI can surface it.\n      throw err;\n    }\n  }\n  out.sort((a, b) => a.id.localeCompare(b.id));\n  return out;\n}\n\n/**\n * Test-only helper: resolve where a given connector's state lives. Exported\n * so tests can assert the on-disk layout without duplicating the path math.\n * Not part of the stable public API.\n *\n * @internal\n */\nexport function _connectorStatePathForTest(memoryDir: string, id: string): string {\n  return resolveConnectorStatePath(memoryDir, id);\n}\n","/**\n * @remnic/core — Live Connectors Framework (issue #683 PR 1/N)\n *\n * Defines the contract that every \"live\" connector (Drive, Notion, Gmail,\n * GitHub, ...) must satisfy. A live connector is **continuous**: it runs on a\n * schedule, persists a cursor to disk, and ingests *new* documents since the\n * last sync. This is distinct from one-shot importers in\n * `packages/remnic-core/src/importers/` which transform an entire export file\n * in a single pass.\n *\n * This module is intentionally pure types + interfaces. No I/O. No schedule\n * wiring. Concrete connectors (PRs 2–5), the maintenance scheduler hookup\n * (separate PR), and the CLI surface (PR 6) are deferred.\n *\n * Naming caveat: `packages/remnic-core/src/connectors/` is already scoped to\n * the Codex marketplace integration. The live-connector framework lives under\n * the `live/` subdirectory to avoid collision. Do not import Codex symbols\n * from here, and do not import live-connector symbols from the Codex code.\n */\n\n/**\n * Free-form connector configuration. Validated by each connector's\n * `validateConfig` implementation. Stored alongside the cursor in the state\n * store. MUST be JSON-serializable: no functions, no class instances, no\n * circular references.\n *\n * Connectors MUST NOT persist secrets here — credentials belong in OS keychain\n * / OAuth token storage (PR 2 design).\n */\nexport type ConnectorConfig = Record<string, unknown>;\n\n/**\n * Opaque cursor describing \"where the last sync left off\". Each connector\n * defines what `kind` and `value` mean (e.g. Drive: `{kind: \"pageToken\",\n * value: \"...\"}`, Gmail: `{kind: \"historyId\", value: \"...\"}`). The orchestrator\n * treats it as opaque and only round-trips it through the state store.\n *\n * `updatedAt` is an ISO 8601 timestamp set by the framework when the cursor is\n * written. It is informational — connectors MUST NOT use it to decide\n * monotonicity. They own the `value` semantics.\n */\nexport interface ConnectorCursor {\n  /** Connector-defined cursor kind (e.g. `\"pageToken\"`, `\"historyId\"`, `\"sinceTs\"`). */\n  readonly kind: string;\n  /** Connector-defined opaque cursor value. */\n  readonly value: string;\n  /** ISO 8601 timestamp of when this cursor was last written. */\n  readonly updatedAt: string;\n}\n\n/**\n * Provenance for a connector-ingested document. Required so downstream recall\n * can attribute facts back to their origin and avoid re-ingesting on the next\n * incremental pass.\n */\nexport interface ConnectorDocumentSource {\n  /** Stable connector id (matches `LiveConnector.id`). */\n  readonly connector: string;\n  /** Source-system identifier (Drive file id, Notion page id, Gmail msg id, ...). */\n  readonly externalId: string;\n  /** Optional source-system revision/version (etag, page version, history id). */\n  readonly externalRevision?: string;\n  /** Optional canonical URL pointing back at the source document. */\n  readonly externalUrl?: string;\n  /** ISO 8601 timestamp of when the connector fetched this document. */\n  readonly fetchedAt: string;\n}\n\n/**\n * A single document yielded by an incremental sync. Connectors are responsible\n * for chunking large source documents themselves if needed; the orchestrator\n * ingests `content` as a unit.\n */\nexport interface ConnectorDocument {\n  /** Connector-local stable id for this document. SHOULD match `source.externalId`. */\n  readonly id: string;\n  /** Optional human-readable title. */\n  readonly title?: string;\n  /** Body content. Plaintext or Markdown — connectors document their format. */\n  readonly content: string;\n  /** Provenance. Required. */\n  readonly source: ConnectorDocumentSource;\n}\n\n/**\n * Arguments passed to `syncIncremental`. The framework owns cursor/config\n * lifecycle; connectors only read these and return the next cursor.\n */\nexport interface SyncIncrementalArgs {\n  /** Last persisted cursor, or `null` on the first ever sync. */\n  readonly cursor: ConnectorCursor | null;\n  /** Validated connector config (already passed through `validateConfig`). */\n  readonly config: ConnectorConfig;\n  /** Optional abort signal. Connectors SHOULD honor it for cooperative cancellation. */\n  readonly abortSignal?: AbortSignal;\n}\n\n/**\n * Result of a single incremental sync pass.\n *\n * `newDocs` MAY be empty (no new documents since the last cursor). `nextCursor`\n * MUST always be returned — even on no-op syncs the framework persists it so\n * `updatedAt` reflects the most recent attempt.\n */\nexport interface SyncIncrementalResult {\n  readonly newDocs: ConnectorDocument[];\n  readonly nextCursor: ConnectorCursor;\n}\n\n/**\n * The contract every live connector implements.\n *\n * Connectors MUST be:\n *   - **Idempotent**: re-running with the same cursor MUST NOT duplicate\n *     documents. The `source.externalId` + `source.externalRevision` pair is\n *     used downstream for dedup.\n *   - **Read-only on the source**: live connectors never mutate the upstream\n *     system (no marking emails read, no editing Notion pages).\n *   - **Cancellable**: long-running syncs SHOULD periodically check\n *     `abortSignal.aborted` and bail cleanly.\n *   - **Privacy-aware**: connectors MUST NOT log document content. Logging\n *     metadata (counts, ids, timings) is fine.\n */\nexport interface LiveConnector {\n  /**\n   * Stable connector id. MUST match `CONNECTOR_ID_PATTERN` — lowercase\n   * alphanumeric plus dash, 1–64 chars, must start AND end with alphanumeric\n   * (no leading or trailing dash). The registry enforces this.\n   */\n  readonly id: string;\n  /** Short human-readable name shown in CLI / status output. */\n  readonly displayName: string;\n  /** Optional longer description. */\n  readonly description?: string;\n\n  /**\n   * Validate raw user-supplied config. MUST throw on malformed input — never\n   * silently default. The returned object is what gets persisted and passed\n   * back to `syncIncremental`. Connectors SHOULD strip unknown fields.\n   */\n  validateConfig(raw: unknown): ConnectorConfig;\n\n  /**\n   * Run one incremental sync pass. See `SyncIncrementalArgs` /\n   * `SyncIncrementalResult` for the contract.\n   */\n  syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult>;\n}\n\n/**\n * Regex enforcing the connector-id naming rule. Exported so connectors and\n * tests can validate ids consistently with the registry.\n *\n * Rule: lowercase alphanumeric + dash, 1..64 chars, must start AND end with\n * alphanumeric (no leading or trailing dash). Single-char ids are allowed.\n */\nexport const CONNECTOR_ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;\n\n/**\n * Returns `true` if `id` is a syntactically valid connector id.\n */\nexport function isValidConnectorId(id: unknown): id is string {\n  return typeof id === \"string\" && CONNECTOR_ID_PATTERN.test(id);\n}\n"],"mappings":"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","names":[]}