@remnic/plugin-openclaw 1.0.3 → 1.0.4

package/dist/chunk-J2FCINY7.js

@@ -0,0 +1,960 @@
+import {
+  StorageManager
+} from "./chunk-5VTGFKKU.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-YHH3SXKD.js";
+import {
+  log
+} from "./chunk-UFU5GGGA.js";
+
+// ../remnic-core/src/connectors/codex-materialize-runner.ts
+import path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// ../remnic-core/src/connectors/codex-materialize.ts
+import {
+  createHash
+} from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+var MATERIALIZE_VERSION = 1;
+var SENTINEL_FILE = ".remnic-managed";
+var TMP_DIR = ".remnic-tmp";
+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 codexHome = resolveCodexHome(options.codexHome);
+  const memoriesDir = path.join(codexHome, "memories");
+  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 (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: ""
+    };
+  }
+  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) => 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 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 = statSync(stalePath);
+        if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;
+        rmSync(stalePath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  mkdirSync(tmpDir, { recursive: true });
+  mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
+  const filesWritten = [];
+  writeFileSync(path.join(tmpDir, "memory_summary.md"), memorySummary);
+  filesWritten.push("memory_summary.md");
+  writeFileSync(path.join(tmpDir, "MEMORY.md"), memoryMd);
+  filesWritten.push("MEMORY.md");
+  writeFileSync(path.join(tmpDir, "raw_memories.md"), rawMemories);
+  filesWritten.push("raw_memories.md");
+  for (const rollout of rolloutFiles) {
+    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);
+    renameSync(src, dest);
+  }
+  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
+  mkdirSync(destRolloutsDir, { recursive: true });
+  if (rolloutsSupplied) {
+    const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));
+    try {
+      for (const entry of readdirSync(destRolloutsDir, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.endsWith(".md")) continue;
+        if (retainedRolloutNames.has(entry.name)) continue;
+        try {
+          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);
+    renameSync(src, dest);
+  }
+  const sentinel = {
+    version: MATERIALIZE_VERSION,
+    namespace,
+    updated_at: now.toISOString(),
+    content_hash: hash
+  };
+  writeFileSync(sentinelPath, `${JSON.stringify(sentinel, null, 2)}
+`);
+  try {
+    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 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 = process.env.CODEX_HOME;
+  if (fromEnv && fromEnv.trim().length > 0) return fromEnv;
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path.join(home, ".codex");
+}
+function readSentinel(sentinelPath) {
+  if (!existsSync(sentinelPath)) return null;
+  try {
+    const raw = 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");
+}
+
+// ../remnic-core/src/connectors/codex-materialize-runner.ts
+async function runCodexMaterialize(options) {
+  const cfg = options.config;
+  if (!cfg.codexMaterializeMemories) {
+    log.debug(`[codex-materialize] skipped \u2014 codexMaterializeMemories=false`);
+    return null;
+  }
+  if (options.reason === "session_end" && cfg.codexMaterializeOnSessionEnd === false) {
+    log.debug(
+      `[codex-materialize] skipped \u2014 session-end disabled via codexMaterializeOnSessionEnd=false`
+    );
+    return null;
+  }
+  const namespace = resolveNamespace(options.namespace, cfg);
+  const memoryDir = options.memoryDir ?? cfg.memoryDir;
+  if (!memoryDir) {
+    log.warn(`[codex-materialize] skipped \u2014 no memoryDir available`);
+    return null;
+  }
+  let memories;
+  if (options.memories) {
+    memories = options.memories;
+  } else {
+    const nsDir = resolveNamespaceDir(memoryDir, namespace, cfg);
+    const storage = new StorageManager(nsDir);
+    try {
+      memories = await storage.readAllMemories();
+    } catch (error) {
+      log.warn(
+        `[codex-materialize] skipped \u2014 failed to read memories from ${nsDir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  const result = materializeForNamespace(namespace, {
+    memories,
+    codexHome: options.codexHome,
+    maxSummaryTokens: cfg.codexMaterializeMaxSummaryTokens,
+    rolloutRetentionDays: cfg.codexMaterializeRolloutRetentionDays,
+    rolloutSummaries: options.rolloutSummaries,
+    now: options.now
+  });
+  if (options.reason) {
+    log.debug(
+      `[codex-materialize] ran reason=${options.reason} wrote=${result.wrote} files=${result.filesWritten.length}`
+    );
+  }
+  return result;
+}
+async function runPostConsolidationMaterialize(logPrefix, options) {
+  if (!options.config.codexMaterializeMemories) return null;
+  if (!options.config.codexMaterializeOnConsolidation) return null;
+  try {
+    return await runCodexMaterialize({
+      config: options.config,
+      namespace: options.namespace,
+      memories: options.memories,
+      memoryDir: options.memoryDir,
+      codexHome: options.codexHome,
+      rolloutSummaries: options.rolloutSummaries,
+      now: options.now,
+      reason: "consolidation"
+    });
+  } catch (error) {
+    log.warn(
+      `${logPrefix} Codex materialize post-hook failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function resolveNamespace(override, cfg) {
+  const requested = (override ?? cfg.codexMaterializeNamespace ?? "auto").trim();
+  if (requested.length === 0 || requested === "auto") {
+    return cfg.defaultNamespace && cfg.defaultNamespace.length > 0 ? cfg.defaultNamespace : "default";
+  }
+  return requested;
+}
+function resolveNamespaceDir(memoryDir, namespace, cfg) {
+  if (!cfg.namespacesEnabled) return memoryDir;
+  const ns = namespace || cfg.defaultNamespace || "default";
+  const namespacedRoot = path2.join(memoryDir, "namespaces", ns);
+  if (ns === cfg.defaultNamespace) {
+    return existsSync2(namespacedRoot) ? namespacedRoot : memoryDir;
+  }
+  return namespacedRoot;
+}
+
+// ../remnic-core/src/memory-extension-host/host-discovery.ts
+import { readdir, readFile, lstat, realpath } from "fs/promises";
+import path3 from "path";
+var REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT = 5e3;
+var MAX_EXAMPLES_PER_EXTENSION = 10;
+var VALID_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "procedure", "reference"]);
+async function discoverMemoryExtensions(root, log2) {
+  let rootStat;
+  try {
+    rootStat = await lstat(root);
+  } catch {
+    return [];
+  }
+  if (rootStat.isSymbolicLink()) {
+    let resolved;
+    try {
+      resolved = await realpath(root);
+    } catch {
+      return [];
+    }
+    let expectedParent;
+    try {
+      expectedParent = await realpath(path3.resolve(path3.dirname(root)));
+    } catch {
+      return [];
+    }
+    if (!resolved.startsWith(expectedParent + path3.sep) && resolved !== expectedParent) {
+      log2.warn?.(
+        `[memory-extensions] root "${root}" is a symlink resolving outside the expected parent directory, skipping`
+      );
+      return [];
+    }
+    try {
+      rootStat = await lstat(resolved);
+    } catch {
+      return [];
+    }
+  }
+  if (!rootStat.isDirectory()) {
+    return [];
+  }
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return [];
+  }
+  const extensions = [];
+  for (const entry of entries) {
+    const entryPath = path3.join(root, entry);
+    let entryStat;
+    try {
+      entryStat = await lstat(entryPath);
+    } catch {
+      continue;
+    }
+    if (entryStat.isSymbolicLink()) {
+      log2.warn?.(
+        `[memory-extensions] skipping "${entry}": symlinks are not followed for security`
+      );
+      continue;
+    }
+    if (!entryStat.isDirectory()) continue;
+    if (!VALID_SLUG_RE.test(entry)) {
+      log2.warn?.(
+        `[memory-extensions] skipping "${entry}": invalid slug (must be lowercase alphanumeric + hyphens, 1-64 chars)`
+      );
+      continue;
+    }
+    const instructionsPath = path3.join(entryPath, "instructions.md");
+    if (await isSymlink(instructionsPath)) {
+      log2.warn?.(
+        `[memory-extensions] skipping "${entry}": instructions.md is a symlink`
+      );
+      continue;
+    }
+    let instructions;
+    try {
+      instructions = await readFile(instructionsPath, "utf-8");
+    } catch {
+      log2.warn?.(
+        `[memory-extensions] skipping "${entry}": missing instructions.md`
+      );
+      continue;
+    }
+    let schema;
+    const schemaPath = path3.join(entryPath, "schema.json");
+    if (await isSymlink(schemaPath)) {
+      log2.warn?.(
+        `[memory-extensions] "${entry}": schema.json is a symlink, ignoring schema`
+      );
+    } else {
+      try {
+        const schemaRaw = await readFile(schemaPath, "utf-8");
+        const parsed = JSON.parse(schemaRaw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          schema = validateSchema(parsed);
+        } else {
+          log2.warn?.(
+            `[memory-extensions] "${entry}": schema.json is not a valid object, ignoring schema`
+          );
+        }
+      } catch (err) {
+        if (isFileNotFoundError(err)) {
+        } else {
+          log2.warn?.(
+            `[memory-extensions] "${entry}": malformed schema.json, ignoring schema`
+          );
+        }
+      }
+    }
+    const examplesPaths = [];
+    const examplesDir = path3.join(entryPath, "examples");
+    try {
+      const exampleEntries = await readdir(examplesDir);
+      const mdFiles = exampleEntries.filter((f) => f.endsWith(".md")).sort().slice(0, MAX_EXAMPLES_PER_EXTENSION);
+      for (const f of mdFiles) {
+        examplesPaths.push(path3.join(examplesDir, f));
+      }
+    } catch {
+    }
+    extensions.push({
+      name: entry,
+      root: entryPath,
+      instructionsPath,
+      instructions,
+      schema,
+      examplesPaths
+    });
+  }
+  extensions.sort((a, b) => {
+    if (a.name < b.name) return -1;
+    if (a.name > b.name) return 1;
+    return 0;
+  });
+  return extensions;
+}
+function validateSchema(raw) {
+  const memoryTypes = (() => {
+    if (!Array.isArray(raw.memoryTypes)) return void 0;
+    const valid = raw.memoryTypes.filter(
+      (t) => typeof t === "string" && VALID_MEMORY_TYPES.has(t)
+    );
+    return valid.length > 0 ? valid : void 0;
+  })();
+  const groupingHints = (() => {
+    if (!Array.isArray(raw.groupingHints)) return void 0;
+    const valid = raw.groupingHints.filter(
+      (h) => typeof h === "string" && h.length > 0
+    );
+    return valid.length > 0 ? valid : void 0;
+  })();
+  const version = typeof raw.version === "string" && raw.version.length > 0 ? raw.version : void 0;
+  return {
+    ...memoryTypes ? { memoryTypes } : {},
+    ...groupingHints ? { groupingHints } : {},
+    ...version ? { version } : {}
+  };
+}
+function isFileNotFoundError(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+async function isSymlink(filePath) {
+  try {
+    const s = await lstat(filePath);
+    return s.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function resolveExtensionsRoot(config) {
+  if (config.memoryExtensionsRoot.length > 0) {
+    return config.memoryExtensionsRoot;
+  }
+  return path3.join(path3.dirname(config.memoryDir), "memory_extensions");
+}
+
+// ../remnic-core/src/memory-extension-host/render-extensions-block.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function renderExtensionsBlock(extensions) {
+  if (extensions.length === 0) return "";
+  const header = `## Active memory extensions
+
+You are running with the following third-party memory extensions. Each
+extension's \`instructions.md\` tells you how to interpret memories that
+extension produces or curates.
+
+`;
+  let budget = REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT;
+  budget -= estimateTokens(header);
+  const inlined = [];
+  const omitted = [];
+  for (const ext of extensions) {
+    const block = `### remnic-extension/${ext.name}
+\`\`\`
+${ext.instructions}
+\`\`\`
+
+`;
+    const cost = estimateTokens(block);
+    if (cost <= budget) {
+      inlined.push(block);
+      budget -= cost;
+    } else {
+      omitted.push(ext.name);
+    }
+  }
+  let result = header;
+  result += inlined.join("");
+  if (omitted.length > 0) {
+    result += `> **Note:** ${omitted.length} extension(s) omitted due to token budget: ${omitted.join(", ")}
+`;
+  }
+  return result;
+}
+function renderExtensionsFooter(extensions) {
+  if (extensions.length === 0) return "";
+  const names = extensions.map((ext) => ext.name).join(", ");
+  return `Active extensions: ${names}`;
+}
+
+// ../remnic-core/src/semantic-consolidation.ts
+function findSimilarClusters(memories, config) {
+  const excluded = new Set(config.excludeCategories);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const cat = m.frontmatter.category;
+    if (excluded.has(cat)) continue;
+    if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+    const list = byCategory.get(cat) ?? [];
+    list.push(m);
+    byCategory.set(cat, list);
+  }
+  const clusters = [];
+  let totalCandidates = 0;
+  for (const [category, mems] of byCategory) {
+    if (totalCandidates >= config.maxPerRun) break;
+    const tokenized = mems.map((m) => ({
+      memory: m,
+      tokens: new Set(normalizeRecallTokens(m.content, []))
+    }));
+    const clustered = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {
+      if (clustered.has(tokenized[i].memory.frontmatter.id)) continue;
+      const cluster = [tokenized[i].memory];
+      let totalOverlap = 0;
+      let comparisons = 0;
+      for (let j = i + 1; j < tokenized.length; j++) {
+        if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;
+        const aTokens = tokenized[i].tokens;
+        const bTokens = tokenized[j].tokens;
+        if (aTokens.size === 0 || bTokens.size === 0) continue;
+        const overlap = countRecallTokenOverlap(aTokens, [...bTokens].join(" "));
+        const maxTokens = Math.max(aTokens.size, bTokens.size);
+        const score = maxTokens > 0 ? overlap / maxTokens : 0;
+        if (score >= config.threshold) {
+          cluster.push(tokenized[j].memory);
+          totalOverlap += score;
+          comparisons++;
+          if (totalCandidates + cluster.length >= config.maxPerRun) break;
+        }
+      }
+      if (cluster.length >= config.minClusterSize) {
+        for (const m of cluster) clustered.add(m.frontmatter.id);
+        clusters.push({
+          category,
+          memories: cluster,
+          overlapScore: comparisons > 0 ? totalOverlap / comparisons : 0
+        });
+        totalCandidates += cluster.length;
+      }
+    }
+  }
+  return clusters;
+}
+function buildConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system. The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Synthesize them into ONE canonical memory that:
+1. Preserves ALL unique information from every source memory
+2. Removes redundancy and repetition
+3. Uses clear, concise language
+4. Maintains the same category and tone
+5. Does NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Write ONLY the consolidated memory content (no metadata, no explanation, no preamble):`;
+}
+function parseConsolidationResponse(response) {
+  return response.trim();
+}
+async function buildExtensionsBlockForConsolidation(config) {
+  if (!config.memoryExtensionsEnabled) return "";
+  const root = resolveExtensionsRoot(config);
+  const extensions = await discoverMemoryExtensions(root, log);
+  if (extensions.length === 0) return "";
+  return renderExtensionsBlock(extensions);
+}
+async function materializeAfterSemanticConsolidation(options) {
+  return runPostConsolidationMaterialize("[semantic-consolidation]", options);
+}
+
+export {
+  discoverMemoryExtensions,
+  resolveExtensionsRoot,
+  renderExtensionsFooter,
+  runPostConsolidationMaterialize,
+  findSimilarClusters,
+  buildConsolidationPrompt,
+  parseConsolidationResponse,
+  buildExtensionsBlockForConsolidation,
+  materializeAfterSemanticConsolidation
+};