@vibeiao/sdk 0.1.25 → 0.1.30

package/dist/chunk-JJNRDU7F.js

@@ -0,0 +1,675 @@
+// src/compoundingMemory.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { createHash } from "crypto";
+var COMPOUNDING_MEMORY_VERSION = 1;
+var META_FILE = ".vibeiao-compounding-memory.json";
+var UPGRADE_MARKER = "<!-- vibeiao:compounding-memory-upgrade -->";
+var resolveRoot = (root = ".") => path.resolve(root);
+var asDateKey = (date, timeZone = "UTC") => {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(date);
+  const year = parts.find((p) => p.type === "year")?.value;
+  const month = parts.find((p) => p.type === "month")?.value;
+  const day = parts.find((p) => p.type === "day")?.value;
+  if (!year || !month || !day) {
+    return date.toISOString().slice(0, 10);
+  }
+  return `${year}-${month}-${day}`;
+};
+var ensureDir = async (dir) => {
+  await fs.mkdir(dir, { recursive: true });
+};
+var readIfExists = async (filePath) => {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var ensureFile = async (filePath, content, result) => {
+  try {
+    await fs.access(filePath);
+    result.existed.push(filePath);
+    return false;
+  } catch {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, "utf-8");
+    result.created.push(filePath);
+    return true;
+  }
+};
+var appendBlockIfMissing = async (filePath, marker, block, result) => {
+  const current = await readIfExists(filePath) ?? "";
+  if (current.includes(marker)) return false;
+  const next = `${current.trimEnd()}
+
+${block.trim()}
+`;
+  await fs.writeFile(filePath, next, "utf-8");
+  result.touched.push(filePath);
+  return true;
+};
+var ensureHeading = async (filePath, heading, defaultBody, result) => {
+  const current = await readIfExists(filePath) ?? "";
+  if (current.includes(`## ${heading}`)) return false;
+  const block = `## ${heading}
+${defaultBody.trim()}
+`;
+  const next = `${current.trimEnd()}
+
+${block}`;
+  await fs.writeFile(filePath, `${next.trimEnd()}
+`, "utf-8");
+  result.touched.push(filePath);
+  return true;
+};
+var buildWorkingStateTemplate = () => `# WORKING_STATE.md \u2014 Minimal Always-Loaded State
+
+Purpose: keep the agent working set bounded while memory compounds on disk.
+
+## Now (1\u20133 bullets)
+- Keep current priorities explicit and small.
+
+## Active threads (queue)
+- Move details into project dossiers and daily logs.
+
+## Next actions (do next)
+- Keep this file concise; prefer pointers over prose.
+
+## Constraints / defaults (operational)
+- Timezone default for scheduling/interpretation.
+- Avoid duplicate notifications.
+
+## Pointers (where the truth lives)
+- Curated memory: MEMORY.md
+- Daily logs: memory/YYYY-MM-DD.md
+- Graph memory: memory/graph/*
+- Projects: PROJECTS.md + projects/*
+`;
+var buildMemoryTemplate = () => `# MEMORY.md \u2014 Long-Term Memory (Curated)
+
+This file stores stable, durable facts. Keep details in daily logs.
+
+## User Archetype / Preferences
+- Name:
+- Timezone:
+- Communication style:
+
+## Identity / Directives (Assistant)
+- Name:
+- Vibe:
+
+## Active Systems / Automation
+- 
+
+## Project Status (Current)
+- 
+
+## Lessons Learned / Working Conventions
+- Text > Brain: if it matters, write it down.
+- Keep WORKING_STATE.md bounded.
+
+## Sensitive / Do-Not-Guess
+- Confirm before external sends/posts/payments/deletions/production actions.
+`;
+var buildProjectsTemplate = () => `# PROJECTS.md \u2014 Active Project Index
+
+Use this as the pointer index. Keep each project's detail in projects/<name>/.
+
+## Active
+- Example: projects/example/{STATE,DECISIONS,RUNBOOKS,BACKLOG}.md
+`;
+var buildDailyLedgerTemplate = (dateKey) => `# ${dateKey}
+
+## Context
+- 
+
+## Decisions
+- 
+
+## Commands / Changes
+- 
+
+## Preferences
+- 
+
+## Open Questions / Next
+- 
+`;
+var buildMemoryReadme = () => `# memory/ \u2014 Daily Ledger
+
+This folder is the ground-truth log.
+
+Related: WORKING_STATE.md in workspace root is the bounded working set (what matters now).
+
+## Format
+- Files named YYYY-MM-DD.md
+- Capture context, decisions, commands/changes, preferences, and next actions.
+
+## Rule
+- If it should survive restarts, write it to a file.
+`;
+var buildGraphReadme = () => `# memory/graph \u2014 Phase 0.5 (Write-enabled, evidence-gated)
+
+This directory stores the local memory knowledge graph for retrieval reliability.
+
+## Files
+- schema.v1.json \u2014 constraints
+- policy.v1.json \u2014 merge/apply policy
+- nodes.jsonl / edges.jsonl \u2014 graph store
+- review_queue.jsonl \u2014 unresolved proposals
+- checkpoints/ \u2014 rollback snapshots
+- proposals/ \u2014 validation/apply artifacts
+- GOLDEN_QUERIES_V1.md \u2014 retrieval regression prompts
+
+## Rules
+- Require source evidence refs.
+- Keep duplicate/conflict checks green.
+- Run golden-query regression after extractor policy changes.
+`;
+var buildGoldenQueries = () => `# Memory Graph Golden Queries (v1)
+
+1) User timezone preference
+2) Notification dedupe preference
+3) Current active project priorities
+4) Safety constraints for external actions
+5) Most recent high-impact decision
+
+Acceptance: each query should return at least one relevant graph node with evidence refs.
+`;
+var GRAPH_SCHEMA = `{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Memory Graph Schema v1",
+  "version": "v1",
+  "node": {
+    "required": ["id", "type", "name", "summary", "status", "created_at", "updated_at", "source_refs", "confidence"],
+    "types": ["person", "project", "system", "artifact", "decision", "preference", "constraint", "event"]
+  },
+  "edge": {
+    "required": ["from", "to", "type", "weight", "evidence_refs", "created_at", "updated_at", "confidence", "state"],
+    "types": ["related_to", "depends_on", "decided_by", "supersedes", "blocked_by", "enables", "prefers", "conflicts_with"],
+    "states": ["active", "soft_deleted"]
+  },
+  "policy": {
+    "mode": "phase0.5",
+    "evidence_required": true,
+    "auto_apply": true
+  }
+}
+`;
+var GRAPH_POLICY = `{
+  "version": "v1",
+  "mode": "apply",
+  "auto_apply": true,
+  "min_confidence_node": 0.9,
+  "min_confidence_edge": 0.92,
+  "require_evidence": true,
+  "conflict_policy": "queue",
+  "duplicate_policy": "replace",
+  "max_apply_per_run": 50,
+  "rollback": {
+    "enabled": true,
+    "retain_checkpoints": 30
+  }
+}
+`;
+var writeVersionMeta = async (root, version) => {
+  const filePath = path.join(root, META_FILE);
+  const payload = {
+    version,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs.writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+};
+var readCompoundingMemoryVersion = async (root = ".") => {
+  try {
+    const raw = await fs.readFile(path.join(resolveRoot(root), META_FILE), "utf-8");
+    const parsed = JSON.parse(raw);
+    const version = Number(parsed?.version);
+    return Number.isFinite(version) ? version : 0;
+  } catch {
+    return 0;
+  }
+};
+var upgradeCompoundingMemorySystem = async (options = {}) => {
+  const root = resolveRoot(options.root);
+  const includeGraph = options.includeGraph !== false;
+  const includeProjects = options.includeProjects !== false;
+  const appendUpgradeNote = options.appendUpgradeNote !== false;
+  const timeZone = options.timeZone || "UTC";
+  const dateKey = asDateKey(options.now ?? /* @__PURE__ */ new Date(), timeZone);
+  await ensureDir(root);
+  const result = {
+    root,
+    memoryDir: path.join(root, "memory"),
+    graphDir: includeGraph ? path.join(root, "memory", "graph") : null,
+    projectsDir: includeProjects ? path.join(root, "projects") : null,
+    dateKey,
+    dailyLedgerPath: path.join(root, "memory", `${dateKey}.md`),
+    created: [],
+    touched: [],
+    existed: [],
+    changed: false,
+    version: COMPOUNDING_MEMORY_VERSION
+  };
+  await ensureFile(path.join(root, "WORKING_STATE.md"), buildWorkingStateTemplate(), result);
+  await ensureFile(path.join(root, "MEMORY.md"), buildMemoryTemplate(), result);
+  await ensureFile(path.join(root, "PROJECTS.md"), buildProjectsTemplate(), result);
+  await ensureFile(path.join(root, "memory", "README.md"), buildMemoryReadme(), result);
+  await ensureFile(result.dailyLedgerPath, buildDailyLedgerTemplate(dateKey), result);
+  if (includeProjects) {
+    await ensureDir(path.join(root, "projects"));
+    await ensureFile(path.join(root, "projects", ".gitkeep"), "", result);
+  }
+  if (includeGraph) {
+    const graphRoot = path.join(root, "memory", "graph");
+    await ensureDir(graphRoot);
+    await ensureDir(path.join(graphRoot, "checkpoints"));
+    await ensureDir(path.join(graphRoot, "proposals"));
+    await ensureFile(path.join(graphRoot, "README.md"), buildGraphReadme(), result);
+    await ensureFile(path.join(graphRoot, "schema.v1.json"), GRAPH_SCHEMA, result);
+    await ensureFile(path.join(graphRoot, "policy.v1.json"), GRAPH_POLICY, result);
+    await ensureFile(path.join(graphRoot, "nodes.jsonl"), "", result);
+    await ensureFile(path.join(graphRoot, "edges.jsonl"), "", result);
+    await ensureFile(path.join(graphRoot, "review_queue.jsonl"), "", result);
+    await ensureFile(path.join(graphRoot, "audit.log"), "", result);
+    await ensureFile(path.join(graphRoot, "GOLDEN_QUERIES_V1.md"), buildGoldenQueries(), result);
+  }
+  await ensureHeading(
+    path.join(root, "MEMORY.md"),
+    "Lessons Learned / Working Conventions",
+    "- Keep WORKING_STATE.md bounded and current.\n- Distill stable facts here; keep detail in daily logs.",
+    result
+  );
+  await ensureHeading(
+    path.join(root, "MEMORY.md"),
+    "Sensitive / Do-Not-Guess",
+    "- Confirm before external actions (posts, payments, deletions, production ops).",
+    result
+  );
+  await ensureHeading(
+    path.join(root, "WORKING_STATE.md"),
+    "Pointers (where the truth lives)",
+    "- Curated memory: MEMORY.md\n- Daily ledger: memory/YYYY-MM-DD.md\n- Memory graph: memory/graph/*\n- Project index: PROJECTS.md",
+    result
+  );
+  if (appendUpgradeNote) {
+    await appendBlockIfMissing(
+      result.dailyLedgerPath,
+      UPGRADE_MARKER,
+      `${UPGRADE_MARKER}
+- Initialized/upgraded compounding memory scaffold (v${COMPOUNDING_MEMORY_VERSION}).`,
+      result
+    );
+  }
+  await writeVersionMeta(root, COMPOUNDING_MEMORY_VERSION);
+  result.changed = result.created.length > 0 || result.touched.length > 0;
+  return result;
+};
+var DEFAULT_WORKING_STATE_MAX_LINES = 200;
+var DEFAULT_WORKING_STATE_MAX_CHARS = 12e3;
+var DEFAULT_WORKING_STATE_MAX_OVERFLOW_CHARS = 8e3;
+var DEFAULT_BACKUP_RETENTION = 14;
+var DEFAULT_REQUIRED_SET_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REQUIRED_GRAPH_FILES = [
+  "README.md",
+  "schema.v1.json",
+  "policy.v1.json",
+  "nodes.jsonl",
+  "edges.jsonl",
+  "review_queue.jsonl",
+  "audit.log",
+  "GOLDEN_QUERIES_V1.md"
+];
+var asIsoStamp = (date) => date.toISOString();
+var countLines = (text) => {
+  if (!text) return 0;
+  return text.replace(/\n$/, "").split("\n").length;
+};
+var selectBackupCandidates = async (root) => {
+  const candidates = [
+    ".vibeiao-compounding-memory.json",
+    "WORKING_STATE.md",
+    "MEMORY.md",
+    "PROJECTS.md"
+  ];
+  const files = [];
+  for (const rel of candidates) {
+    const full = path.join(root, rel);
+    try {
+      const stat = await fs.stat(full);
+      if (stat.isFile()) files.push(rel);
+    } catch {
+    }
+  }
+  const walk = async (dirRel) => {
+    const fullDir = path.join(root, dirRel);
+    let entries;
+    try {
+      entries = await fs.readdir(fullDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const rel = path.join(dirRel, String(entry.name));
+      if (entry.isDirectory()) {
+        await walk(rel);
+      } else if (entry.isFile()) {
+        files.push(rel);
+      }
+    }
+  };
+  await walk("memory");
+  await walk("projects");
+  return Array.from(new Set(files)).sort();
+};
+var ensureTextFile = async (filePath) => {
+  const content = await fs.readFile(filePath, "utf-8");
+  return content;
+};
+var resolveBackupDir = (root, backupDir) => backupDir ? path.resolve(backupDir) : path.join(root, "memory", ".backup", "compounding-memory");
+var appendDailyLedgerNote = async (root, timeZone, now, title, body) => {
+  const dateKey = asDateKey(now, timeZone);
+  const ledgerPath = path.join(root, "memory", `${dateKey}.md`);
+  const stamp = asIsoStamp(now);
+  const block = `
+### ${stamp} ${title}
+${body.trim()}
+`;
+  await ensureDir(path.dirname(ledgerPath));
+  await fs.appendFile(ledgerPath, block, "utf-8");
+  return ledgerPath;
+};
+var enforceWorkingStateDiscipline = async (options = {}) => {
+  const timeZone = options.timeZone || "UTC";
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const maxLines = Math.max(20, Number(options.maxLines ?? DEFAULT_WORKING_STATE_MAX_LINES));
+  const maxChars = Math.max(1e3, Number(options.maxChars ?? DEFAULT_WORKING_STATE_MAX_CHARS));
+  const maxOverflowChars = Math.max(256, Number(options.maxOverflowChars ?? DEFAULT_WORKING_STATE_MAX_OVERFLOW_CHARS));
+  const upgrade = await upgradeCompoundingMemorySystem({
+    root: options.root,
+    timeZone,
+    now,
+    appendUpgradeNote: false
+  });
+  const root = upgrade.root;
+  const filePath = path.join(root, "WORKING_STATE.md");
+  const current = await ensureTextFile(filePath);
+  const lineCount = countLines(current);
+  const charCount = current.length;
+  if (lineCount <= maxLines && charCount <= maxChars) {
+    return {
+      filePath,
+      ledgerPath: upgrade.dailyLedgerPath,
+      lineCount,
+      charCount,
+      maxLines,
+      maxChars,
+      bounded: true,
+      trimmed: false,
+      movedChars: 0
+    };
+  }
+  let next = current;
+  const lines = current.split("\n");
+  if (lines.length > maxLines) {
+    next = `${lines.slice(0, maxLines).join("\n")}
+`;
+  }
+  if (next.length > maxChars) {
+    next = `${next.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026
+`;
+  }
+  let overflow = current.slice(next.length).trim();
+  if (!overflow && next !== current) {
+    overflow = current.replace(next, "").trim();
+  }
+  const moved = overflow ? overflow.slice(0, maxOverflowChars) : "";
+  await fs.writeFile(filePath, next.trimEnd() + "\n", "utf-8");
+  let ledgerPath = upgrade.dailyLedgerPath;
+  if (moved) {
+    ledgerPath = await appendDailyLedgerNote(
+      root,
+      timeZone,
+      now,
+      "[working-state-compaction]",
+      `- Auto-compacted WORKING_STATE.md to stay within budget (${maxLines} lines / ${maxChars} chars).
+- Overflow snapshot:
+
+\`\`\`
+${moved}
+\`\`\``
+    );
+  }
+  const written = await ensureTextFile(filePath);
+  return {
+    filePath,
+    ledgerPath,
+    lineCount: countLines(written),
+    charCount: written.length,
+    maxLines,
+    maxChars,
+    bounded: countLines(written) <= maxLines && written.length <= maxChars,
+    trimmed: true,
+    movedChars: moved.length
+  };
+};
+var checkRecallSubstrate = async (options = {}) => {
+  const root = resolveRoot(options.root);
+  const graphRoot = path.join(root, "memory", "graph");
+  const issues = [];
+  for (const rel of REQUIRED_GRAPH_FILES) {
+    try {
+      await fs.access(path.join(graphRoot, rel));
+    } catch {
+      issues.push(`missing_graph_file:${rel}`);
+    }
+  }
+  let goldenQueryCount = 0;
+  try {
+    const golden = await fs.readFile(path.join(graphRoot, "GOLDEN_QUERIES_V1.md"), "utf-8");
+    goldenQueryCount = golden.split("\n").filter((line) => /^\s*\d+\)/.test(line.trim())).length;
+    if (goldenQueryCount < 3) {
+      issues.push("golden_queries_too_few");
+    }
+  } catch {
+    issues.push("golden_queries_unreadable");
+  }
+  let nodeCount = 0;
+  let edgeCount = 0;
+  try {
+    const nodes = await fs.readFile(path.join(graphRoot, "nodes.jsonl"), "utf-8");
+    nodeCount = nodes.split("\n").map((x) => x.trim()).filter(Boolean).length;
+  } catch {
+    issues.push("nodes_unreadable");
+  }
+  try {
+    const edges = await fs.readFile(path.join(graphRoot, "edges.jsonl"), "utf-8");
+    edgeCount = edges.split("\n").map((x) => x.trim()).filter(Boolean).length;
+  } catch {
+    issues.push("edges_unreadable");
+  }
+  return {
+    ok: issues.length === 0,
+    goldenQueryCount,
+    nodeCount,
+    edgeCount,
+    issues
+  };
+};
+var createCompoundingMemoryBackup = async (options = {}) => {
+  const root = resolveRoot(options.root);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const backupDir = resolveBackupDir(root, options.backupDir);
+  const retention = Math.max(1, Number(options.retention ?? DEFAULT_BACKUP_RETENTION));
+  await ensureDir(backupDir);
+  const files = await selectBackupCandidates(root);
+  const payloadFiles = [];
+  for (const rel of files) {
+    const content = await ensureTextFile(path.join(root, rel));
+    payloadFiles.push({ path: rel.replace(/\\/g, "/"), content });
+  }
+  const payload = {
+    version: COMPOUNDING_MEMORY_VERSION,
+    createdAt: asIsoStamp(now),
+    root,
+    files: payloadFiles
+  };
+  const body = JSON.stringify(payload, null, 2);
+  const sha256 = createHash("sha256").update(body).digest("hex");
+  const stamp = asIsoStamp(now).replace(/[:.]/g, "-");
+  const backupPath = path.join(backupDir, `compounding-memory-${stamp}.json`);
+  await fs.writeFile(backupPath, body, "utf-8");
+  const entries = (await fs.readdir(backupDir)).filter((name) => name.startsWith("compounding-memory-") && name.endsWith(".json")).sort();
+  const excess = entries.length - retention;
+  if (excess > 0) {
+    const toDelete = entries.slice(0, excess);
+    await Promise.all(toDelete.map((name) => fs.unlink(path.join(backupDir, name))));
+  }
+  const stat = await fs.stat(backupPath);
+  return {
+    backupPath,
+    createdAt: payload.createdAt,
+    fileCount: payloadFiles.length,
+    sizeBytes: stat.size,
+    sha256
+  };
+};
+var runCompoundingMemoryRestoreDrill = async (options = {}) => {
+  const root = resolveRoot(options.root);
+  const backup = await createCompoundingMemoryBackup(options);
+  const raw = await fs.readFile(backup.backupPath, "utf-8");
+  const payload = JSON.parse(raw);
+  const files = Array.isArray(payload.files) ? payload.files : [];
+  const restoreRoot = path.join(root, "memory", ".restore-drill", Date.now().toString());
+  await ensureDir(restoreRoot);
+  for (const row of files) {
+    if (!row?.path || typeof row.path !== "string" || typeof row.content !== "string") continue;
+    const rel = row.path.replace(/^\/+/, "").replace(/\\/g, "/");
+    if (!rel || rel.includes("..")) continue;
+    const target = path.join(restoreRoot, rel);
+    await ensureDir(path.dirname(target));
+    await fs.writeFile(target, row.content, "utf-8");
+  }
+  const checkedFiles = [
+    "WORKING_STATE.md",
+    "MEMORY.md",
+    "PROJECTS.md",
+    "memory/README.md",
+    "memory/graph/policy.v1.json"
+  ];
+  for (const rel of checkedFiles) {
+    await fs.access(path.join(restoreRoot, rel));
+  }
+  const restoredFiles = files.length;
+  if (!options.keepRestoreRoot) {
+    await fs.rm(restoreRoot, { recursive: true, force: true });
+  }
+  return {
+    ok: true,
+    backup,
+    restoredFiles,
+    checkedFiles,
+    restoreRoot
+  };
+};
+var runCompoundingMemoryRequiredSet = async (options = {}) => {
+  const timeZone = options.timeZone || "UTC";
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const upgrade = await upgradeCompoundingMemorySystem({
+    root: options.root,
+    timeZone,
+    now
+  });
+  const workingState = await enforceWorkingStateDiscipline({
+    root: upgrade.root,
+    timeZone,
+    now,
+    maxLines: options.workingStateMaxLines,
+    maxChars: options.workingStateMaxChars
+  });
+  const recall = await checkRecallSubstrate({ root: upgrade.root });
+  let restoreDrill = null;
+  if (options.runBackupRestoreDrill !== false) {
+    restoreDrill = await runCompoundingMemoryRestoreDrill({
+      root: upgrade.root,
+      backupDir: options.backupDir,
+      retention: options.backupRetention,
+      now
+    });
+    await appendDailyLedgerNote(
+      upgrade.root,
+      timeZone,
+      now,
+      "[restore-drill]",
+      `- status: OK
+- backup: ${restoreDrill.backup.backupPath}
+- restoredFiles: ${restoreDrill.restoredFiles}`
+    );
+  }
+  return {
+    ok: workingState.bounded && recall.ok && (restoreDrill ? restoreDrill.ok : true),
+    root: upgrade.root,
+    upgrade,
+    workingState,
+    recall,
+    restoreDrill,
+    checkedAt: asIsoStamp(now)
+  };
+};
+var createCompoundingMemoryRequiredSetScheduler = (options = {}) => {
+  const intervalMs = Math.max(6e4, Number(options.intervalMs ?? DEFAULT_REQUIRED_SET_INTERVAL_MS));
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const result = await runCompoundingMemoryRequiredSet(options);
+      if (options.onSuccess) {
+        await options.onSuccess(result);
+      }
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("compounding_memory_required_set_failed");
+      if (options.onError) {
+        await options.onError(error);
+      }
+      throw error;
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    stopped = false;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(() => {
+      void runOnce();
+    }, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var ensureCompoundingMemorySystem = upgradeCompoundingMemorySystem;
+
+export {
+  COMPOUNDING_MEMORY_VERSION,
+  readCompoundingMemoryVersion,
+  upgradeCompoundingMemorySystem,
+  enforceWorkingStateDiscipline,
+  checkRecallSubstrate,
+  createCompoundingMemoryBackup,
+  runCompoundingMemoryRestoreDrill,
+  runCompoundingMemoryRequiredSet,
+  createCompoundingMemoryRequiredSetScheduler,
+  ensureCompoundingMemorySystem
+};