@remnic/core 1.1.11 → 1.1.13

package/dist/chunk-RHY3HH7P.js

@@ -0,0 +1,601 @@
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-XIG5PDM7.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/connectors/codex-materialize.ts
+import {
+  createHash
+} from "crypto";
+import fs from "fs";
+import path from "path";
+var MATERIALIZE_VERSION = 1;
+var SENTINEL_FILE = ".remnic-managed";
+var TMP_DIR = ".remnic-tmp";
+var OWNED_FILES = /* @__PURE__ */ new Set([
+  "memory_summary.md",
+  "MEMORY.md",
+  "raw_memories.md"
+]);
+var ROLLOUT_SUBDIR = "rollout_summaries";
+function materializeForNamespace(namespace, options) {
+  const logger = options.logger ?? {
+    info: (msg) => log.info(`[codex-materialize] ${msg}`),
+    warn: (msg) => log.warn(`[codex-materialize] ${msg}`),
+    debug: (msg) => log.debug(`[codex-materialize] ${msg}`)
+  };
+  const memoriesDir = resolveCodexMemoriesDir(options.codexHome);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const maxSummaryTokens = typeof options.maxSummaryTokens === "number" && options.maxSummaryTokens >= 0 ? options.maxSummaryTokens : 4500;
+  const rolloutRetentionDays = typeof options.rolloutRetentionDays === "number" && options.rolloutRetentionDays >= 0 ? options.rolloutRetentionDays : 30;
+  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  const existingSentinel = readSentinel(sentinelPath);
+  if (!existingSentinel) {
+    if (fs.existsSync(memoriesDir)) {
+      logger.warn(
+        `sentinel ${SENTINEL_FILE} missing in ${memoriesDir}; skipping materialization to preserve hand-edits`
+      );
+    } else {
+      logger.debug?.(
+        `skipping materialization \u2014 ${memoriesDir} does not exist (user not opted in)`
+      );
+    }
+    return {
+      namespace,
+      memoriesDir,
+      wrote: false,
+      skippedNoSentinel: true,
+      skippedIdempotent: false,
+      filesWritten: [],
+      contentHash: ""
+    };
+  }
+  fs.mkdirSync(memoriesDir, { recursive: true });
+  const memories = [...options.memories];
+  const rolloutsSupplied = options.rolloutSummaries !== void 0;
+  const rolloutSummaries = options.rolloutSummaries ?? [];
+  const retainedRollouts = pruneRollouts(rolloutSummaries, rolloutRetentionDays, now);
+  const dedupedRollouts = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  const parseTs = (value) => {
+    if (!value) return Number.NEGATIVE_INFINITY;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+  };
+  for (const r of retainedRollouts) {
+    const name = `${sanitizeSlug(r.slug)}.md`;
+    const existingIdx = seenNames.get(name);
+    if (existingIdx === void 0) {
+      seenNames.set(name, dedupedRollouts.length);
+      dedupedRollouts.push(r);
+      continue;
+    }
+    const existing = dedupedRollouts[existingIdx];
+    if (parseTs(r.updatedAt) > parseTs(existing.updatedAt)) {
+      dedupedRollouts[existingIdx] = r;
+    }
+  }
+  const memorySummary = renderMemorySummary({
+    namespace,
+    memories,
+    rolloutSummaries: dedupedRollouts,
+    maxTokens: maxSummaryTokens
+  });
+  const memoryMd = renderMemoryMd({
+    namespace,
+    memories,
+    rolloutSummaries: dedupedRollouts
+  });
+  const validation = validateMemoryMd(memoryMd);
+  if (!validation.valid) {
+    const reason = validation.errors.join("; ");
+    logger.warn(`MEMORY.md failed schema validation: ${reason}`);
+    throw new Error(`codex-materialize: MEMORY.md schema validation failed: ${reason}`);
+  }
+  const rawMemories = renderRawMemories({ memories });
+  const rolloutFiles = dedupedRollouts.map((r) => ({
+    name: `${sanitizeSlug(r.slug)}.md`,
+    body: renderRolloutSummary(r)
+  }));
+  const hash = computeContentHash({
+    namespace,
+    memorySummary,
+    memoryMd,
+    rawMemories,
+    rolloutFiles
+  });
+  if (existingSentinel.content_hash === hash) {
+    const requiredFiles = [
+      path.join(memoriesDir, "memory_summary.md"),
+      path.join(memoriesDir, "MEMORY.md"),
+      path.join(memoriesDir, "raw_memories.md"),
+      ...rolloutFiles.map((r) => path.join(memoriesDir, ROLLOUT_SUBDIR, r.name))
+    ];
+    const allPresent = requiredFiles.every((f) => fs.existsSync(f));
+    if (allPresent) {
+      logger.debug?.(`no-op materialization for namespace=${namespace} (hash unchanged)`);
+      return {
+        namespace,
+        memoriesDir,
+        wrote: false,
+        skippedNoSentinel: false,
+        skippedIdempotent: true,
+        filesWritten: [],
+        contentHash: hash
+      };
+    }
+    logger.debug?.(
+      `hash unchanged for namespace=${namespace} but managed file missing \u2014 forcing rewrite`
+    );
+  }
+  const runTag = `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  const tmpDir = path.join(memoriesDir, `${TMP_DIR}-${runTag}`);
+  const TMP_STALE_MS = 60 * 60 * 1e3;
+  const wallClockMs = Date.now();
+  try {
+    for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith(TMP_DIR)) continue;
+      const stalePath = path.join(memoriesDir, entry.name);
+      try {
+        const stat = fs.statSync(stalePath);
+        if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;
+        fs.rmSync(stalePath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  fs.mkdirSync(tmpDir, { recursive: true });
+  fs.mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
+  const filesWritten = [];
+  fs.writeFileSync(path.join(tmpDir, "memory_summary.md"), memorySummary);
+  filesWritten.push("memory_summary.md");
+  fs.writeFileSync(path.join(tmpDir, "MEMORY.md"), memoryMd);
+  filesWritten.push("MEMORY.md");
+  fs.writeFileSync(path.join(tmpDir, "raw_memories.md"), rawMemories);
+  filesWritten.push("raw_memories.md");
+  for (const rollout of rolloutFiles) {
+    fs.writeFileSync(path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);
+    filesWritten.push(path.join(ROLLOUT_SUBDIR, rollout.name));
+  }
+  for (const rel of ["memory_summary.md", "MEMORY.md", "raw_memories.md"]) {
+    const src = path.join(tmpDir, rel);
+    const dest = path.join(memoriesDir, rel);
+    fs.renameSync(src, dest);
+  }
+  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
+  fs.mkdirSync(destRolloutsDir, { recursive: true });
+  if (rolloutsSupplied) {
+    const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));
+    try {
+      for (const entry of fs.readdirSync(destRolloutsDir, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.endsWith(".md")) continue;
+        if (retainedRolloutNames.has(entry.name)) continue;
+        try {
+          fs.unlinkSync(path.join(destRolloutsDir, entry.name));
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  for (const rollout of rolloutFiles) {
+    const src = path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);
+    const dest = path.join(destRolloutsDir, rollout.name);
+    fs.renameSync(src, dest);
+  }
+  const sentinel = {
+    version: MATERIALIZE_VERSION,
+    namespace,
+    updated_at: now.toISOString(),
+    content_hash: hash
+  };
+  fs.writeFileSync(sentinelPath, `${JSON.stringify(sentinel, null, 2)}
+`);
+  try {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+  }
+  logger.info(
+    `materialized namespace=${namespace} files=${filesWritten.length} hash=${hash.slice(0, 12)}`
+  );
+  return {
+    namespace,
+    memoriesDir,
+    wrote: true,
+    skippedNoSentinel: false,
+    skippedIdempotent: false,
+    filesWritten,
+    contentHash: hash
+  };
+}
+function ensureSentinel(memoriesDir, namespace, now = /* @__PURE__ */ new Date()) {
+  fs.mkdirSync(memoriesDir, { recursive: true });
+  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  if (fs.existsSync(sentinelPath)) return;
+  const sentinel = {
+    version: MATERIALIZE_VERSION,
+    namespace,
+    updated_at: now.toISOString(),
+    content_hash: ""
+  };
+  fs.writeFileSync(sentinelPath, `${JSON.stringify(sentinel, null, 2)}
+`);
+}
+function renderMemorySummary(ctx) {
+  const lines = [];
+  lines.push("# Memory Summary");
+  lines.push("");
+  lines.push(`_namespace: ${ctx.namespace}_`);
+  lines.push(`_source: remnic_`);
+  lines.push("");
+  const highValue = selectSummaryMemories(ctx.memories, 12);
+  if (highValue.length > 0) {
+    lines.push("## Top memories");
+    lines.push("");
+    for (const mem of highValue) {
+      lines.push(`- ${oneLineSummary(mem)}`);
+    }
+    lines.push("");
+  }
+  if (ctx.rolloutSummaries.length > 0) {
+    lines.push("## Recent rollouts");
+    lines.push("");
+    const sorted = [...ctx.rolloutSummaries].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")).slice(0, 5);
+    for (const r of sorted) {
+      const when = r.updatedAt ? ` (${r.updatedAt})` : "";
+      lines.push(`- ${r.slug}${when}`);
+    }
+    lines.push("");
+  }
+  const full = lines.join("\n").replace(/\n+$/u, "\n");
+  return truncateToTokenBudget(full, ctx.maxTokens);
+}
+function renderMemoryMd(ctx) {
+  const lines = [];
+  lines.push(`# Task Group: ${ctx.namespace}`);
+  lines.push(`scope: ${ctx.namespace}`);
+  lines.push(`applies_to: cwd=*; reuse_rule=namespace-match`);
+  lines.push("");
+  const byCategory = groupMemoriesByCategory(ctx.memories);
+  let taskIndex = 1;
+  if (byCategory.size === 0) {
+    lines.push(`## Task ${taskIndex}: baseline \u2014 no memories yet`);
+    lines.push("");
+    lines.push("### rollout_summary_files");
+    for (const r of ctx.rolloutSummaries) {
+      lines.push(
+        `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? "*"}, rollout_path=${r.rolloutPath ?? ""}, updated_at=${r.updatedAt ?? ""}, thread_id=${r.threadId ?? ""})`
+      );
+    }
+    if (ctx.rolloutSummaries.length === 0) {
+      lines.push("- (none)");
+    }
+    lines.push("");
+    lines.push("### keywords");
+    lines.push(`- ${ctx.namespace}`);
+    lines.push("");
+    taskIndex += 1;
+  } else {
+    for (const [category, mems] of byCategory) {
+      lines.push(`## Task ${taskIndex}: ${category} memories, outcome=surface-to-codex`);
+      lines.push("");
+      lines.push("### rollout_summary_files");
+      const relevantRollouts = ctx.rolloutSummaries.slice(0, 5);
+      if (relevantRollouts.length === 0) {
+        lines.push("- (none)");
+      } else {
+        for (const r of relevantRollouts) {
+          lines.push(
+            `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? "*"}, rollout_path=${r.rolloutPath ?? ""}, updated_at=${r.updatedAt ?? ""}, thread_id=${r.threadId ?? ""})`
+          );
+        }
+      }
+      lines.push("");
+      lines.push("### keywords");
+      const keywords = collectKeywords(mems, category, ctx.namespace);
+      lines.push(`- ${keywords.join(", ")}`);
+      lines.push("");
+      taskIndex += 1;
+    }
+  }
+  lines.push("## User preferences");
+  const prefs = pickCategory(ctx.memories, ["preference"]);
+  if (prefs.length === 0) {
+    lines.push("- (none recorded)");
+  } else {
+    for (const pref of prefs.slice(0, 20)) {
+      lines.push(`- ${oneLineSummary(pref)}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Reusable knowledge");
+  const knowledge = pickCategory(ctx.memories, ["fact", "decision", "principle", "rule", "skill"]);
+  if (knowledge.length === 0) {
+    lines.push("- (none recorded)");
+  } else {
+    for (const mem of knowledge.slice(0, 30)) {
+      lines.push(`- ${oneLineSummary(mem)}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Failures and how to do differently");
+  const corrections = pickCategory(ctx.memories, ["correction"]);
+  if (corrections.length === 0) {
+    lines.push("- (none recorded)");
+  } else {
+    for (const mem of corrections.slice(0, 20)) {
+      lines.push(`- ${oneLineSummary(mem)}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderRawMemories(ctx) {
+  const sorted = [...ctx.memories].sort((a, b) => {
+    const aUpdated = a.frontmatter.updated ?? a.frontmatter.created ?? "";
+    const bUpdated = b.frontmatter.updated ?? b.frontmatter.created ?? "";
+    return bUpdated.localeCompare(aUpdated);
+  });
+  const lines = ["# Raw Memories", "", "_source: remnic \u2014 latest first_", ""];
+  for (const mem of sorted) {
+    const fm = mem.frontmatter;
+    const id = fm.id ?? "unknown";
+    const category = fm.category ?? "unknown";
+    const updated = fm.updated ?? fm.created ?? "";
+    lines.push(`## ${id} (${category}, updated=${updated})`);
+    lines.push("");
+    lines.push(mem.content.trim());
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderRolloutSummary(input) {
+  const lines = [];
+  lines.push(`# Rollout Summary: ${input.slug}`);
+  lines.push("");
+  const meta = [];
+  if (input.cwd) meta.push(`cwd=${input.cwd}`);
+  if (input.rolloutPath) meta.push(`rollout_path=${input.rolloutPath}`);
+  if (input.updatedAt) meta.push(`updated_at=${input.updatedAt}`);
+  if (input.threadId) meta.push(`thread_id=${input.threadId}`);
+  if (meta.length > 0) {
+    lines.push(`_${meta.join("; ")}_`);
+    lines.push("");
+  }
+  if (input.keywords && input.keywords.length > 0) {
+    lines.push(`**keywords:** ${input.keywords.join(", ")}`);
+    lines.push("");
+  }
+  lines.push(input.body.trim());
+  lines.push("");
+  return lines.join("\n");
+}
+function validateMemoryMd(content) {
+  const errors = [];
+  const lines = content.split(/\r?\n/u);
+  const taskGroupIndex = lines.findIndex((l) => /^#\s+Task Group:\s+\S+/u.test(l));
+  if (taskGroupIndex === -1) {
+    errors.push("missing `# Task Group:` header");
+  } else {
+    const tail = lines.slice(taskGroupIndex + 1, taskGroupIndex + 5);
+    if (!tail.some((l) => /^scope:\s*\S+/u.test(l))) {
+      errors.push("missing `scope:` line under Task Group header");
+    }
+    if (!tail.some((l) => /^applies_to:\s*\S+/u.test(l))) {
+      errors.push("missing `applies_to:` line under Task Group header");
+    }
+  }
+  const taskHeaders = lines.filter((l) => /^##\s+Task\s+\d+:/u.test(l));
+  if (taskHeaders.length === 0) {
+    errors.push("at least one `## Task N:` section is required");
+  }
+  const sectionRegex = /^##\s+/u;
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^##\s+Task\s+\d+:/u.test(lines[i])) continue;
+    let hasRollout = false;
+    let hasKeywords = false;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (sectionRegex.test(lines[j])) break;
+      if (/^###\s+rollout_summary_files\s*$/u.test(lines[j])) hasRollout = true;
+      if (/^###\s+keywords\s*$/u.test(lines[j])) hasKeywords = true;
+    }
+    if (!hasRollout) errors.push(`task block at line ${i + 1} missing \`### rollout_summary_files\``);
+    if (!hasKeywords) errors.push(`task block at line ${i + 1} missing \`### keywords\``);
+  }
+  const requiredSections = [
+    /^##\s+User preferences\s*$/u,
+    /^##\s+Reusable knowledge\s*$/u,
+    /^##\s+Failures and how to do differently\s*$/u
+  ];
+  for (const re of requiredSections) {
+    if (!lines.some((l) => re.test(l))) {
+      errors.push(`missing required section: ${re.source}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function resolveCodexHome(override) {
+  if (override && override.trim().length > 0) return override;
+  const fromEnv = readEnvVar("CODEX_HOME");
+  if (fromEnv && fromEnv.trim().length > 0) return fromEnv;
+  return path.join(resolveHomeDir(), ".codex");
+}
+function resolveCodexMemoriesDir(codexHome) {
+  return path.join(resolveCodexHome(codexHome), "memories");
+}
+function hasCodexMaterializeSentinel(codexHome) {
+  return readSentinel(path.join(resolveCodexMemoriesDir(codexHome), SENTINEL_FILE)) !== null;
+}
+function readSentinel(sentinelPath) {
+  if (!fs.existsSync(sentinelPath)) return null;
+  try {
+    const raw = fs.readFileSync(sentinelPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : MATERIALIZE_VERSION,
+      namespace: typeof parsed.namespace === "string" ? parsed.namespace : "",
+      updated_at: typeof parsed.updated_at === "string" ? parsed.updated_at : "",
+      content_hash: typeof parsed.content_hash === "string" ? parsed.content_hash : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function selectSummaryMemories(memories, limit) {
+  const scored = memories.filter((m) => !m.frontmatter.status || m.frontmatter.status === "active").map((m) => {
+    const confidence = typeof m.frontmatter.confidence === "number" ? m.frontmatter.confidence : 0;
+    const importance = typeof m.frontmatter.importance === "object" && m.frontmatter.importance !== null && typeof m.frontmatter.importance.score === "number" ? m.frontmatter.importance.score ?? 0 : 0;
+    const updated = m.frontmatter.updated ?? m.frontmatter.created ?? "";
+    return { memory: m, score: importance * 2 + confidence, updated };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.updated.localeCompare(a.updated);
+  });
+  return scored.slice(0, limit).map((s) => s.memory);
+}
+function oneLineSummary(memory) {
+  const raw = memory.content.replace(/\s+/gu, " ").trim();
+  if (raw.length <= 160) return raw;
+  return `${raw.slice(0, 157)}...`;
+}
+function groupMemoriesByCategory(memories) {
+  const map = /* @__PURE__ */ new Map();
+  for (const memory of memories) {
+    if (memory.frontmatter.status && memory.frontmatter.status !== "active") continue;
+    const category = memory.frontmatter.category ?? "unknown";
+    const list = map.get(category) ?? [];
+    list.push(memory);
+    map.set(category, list);
+  }
+  return map;
+}
+function pickCategory(memories, categories) {
+  const allowed = new Set(categories);
+  return memories.filter(
+    (m) => (!m.frontmatter.status || m.frontmatter.status === "active") && allowed.has(m.frontmatter.category ?? "")
+  );
+}
+function collectKeywords(memories, category, namespace) {
+  const keywords = /* @__PURE__ */ new Set();
+  keywords.add(category);
+  keywords.add(namespace);
+  for (const mem of memories.slice(0, 10)) {
+    for (const tag of mem.frontmatter.tags ?? []) {
+      if (typeof tag === "string" && tag.trim().length > 0) keywords.add(tag.trim());
+    }
+  }
+  return [...keywords].slice(0, 16);
+}
+function pruneRollouts(rollouts, retentionDays, now) {
+  if (retentionDays < 0) return rollouts;
+  const cutoffMs = now.getTime() - retentionDays * 24 * 60 * 60 * 1e3;
+  return rollouts.filter((r) => {
+    if (!r.updatedAt) return true;
+    const t = Date.parse(r.updatedAt);
+    if (!Number.isFinite(t)) return true;
+    return t >= cutoffMs;
+  });
+}
+function sanitizeSlug(slug) {
+  return slug.toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 96) || "rollout";
+}
+function approximateTokenCount(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return 0;
+  return trimmed.split(/\s+/u).length;
+}
+function truncateToTokenBudget(text, maxTokens) {
+  if (maxTokens <= 0) return "";
+  if (approximateTokenCount(text) <= maxTokens) return text;
+  const lineMarker = "_[truncated for summary budget]_";
+  const tailMarker = "[truncated]";
+  const lineMarkerTokens = approximateTokenCount(lineMarker);
+  const tailMarkerTokens = approximateTokenCount(tailMarker);
+  const lines = text.split(/\r?\n/u);
+  const lineBudget = Math.max(0, maxTokens - lineMarkerTokens);
+  while (lines.length > 0 && approximateTokenCount(lines.join("\n")) > lineBudget) {
+    lines.pop();
+  }
+  lines.push(lineMarker);
+  let result = lines.join("\n");
+  if (approximateTokenCount(result) > maxTokens) {
+    const tokens = result.split(/\s+/u);
+    const keep = Math.max(0, maxTokens - tailMarkerTokens);
+    result = keep > 0 ? `${tokens.slice(0, keep).join(" ")} ${tailMarker}` : tailMarker;
+  }
+  return result;
+}
+function computeContentHash(input) {
+  const hash = createHash("sha256");
+  hash.update(`v${MATERIALIZE_VERSION}
+`);
+  hash.update(`namespace=${input.namespace}
+`);
+  hash.update("---memory_summary---\n");
+  hash.update(input.memorySummary);
+  hash.update("\n---memory_md---\n");
+  hash.update(input.memoryMd);
+  hash.update("\n---raw_memories---\n");
+  hash.update(input.rawMemories);
+  const sortedRollouts = [...input.rolloutFiles].sort((a, b) => a.name.localeCompare(b.name));
+  for (const r of sortedRollouts) {
+    hash.update(`
+---rollout:${r.name}---
+`);
+    hash.update(r.body);
+  }
+  return hash.digest("hex");
+}
+function describeMemoriesDir(memoriesDir) {
+  if (!fs.existsSync(memoriesDir)) return null;
+  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  const sentinel = readSentinel(sentinelPath);
+  const files = [];
+  for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {
+    if (entry.isFile() && OWNED_FILES.has(entry.name)) files.push(entry.name);
+  }
+  const rolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
+  if (fs.existsSync(rolloutsDir)) {
+    try {
+      for (const entry of fs.readdirSync(rolloutsDir, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          files.push(path.join(ROLLOUT_SUBDIR, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    exists: true,
+    hasSentinel: sentinel !== null,
+    files: files.sort(),
+    sentinel
+  };
+}
+
+export {
+  MATERIALIZE_VERSION,
+  SENTINEL_FILE,
+  TMP_DIR,
+  materializeForNamespace,
+  ensureSentinel,
+  renderMemorySummary,
+  renderMemoryMd,
+  renderRawMemories,
+  renderRolloutSummary,
+  validateMemoryMd,
+  resolveCodexMemoriesDir,
+  hasCodexMaterializeSentinel,
+  approximateTokenCount,
+  truncateToTokenBudget,
+  describeMemoriesDir
+};
+//# sourceMappingURL=chunk-RHY3HH7P.js.map