@inetafrica/open-claudia 3.5.71 → 3.5.73

package/core/packs.js

@@ -19,7 +19,11 @@ try { ({ DatabaseSync } = require("node:sqlite")); } catch (e) { /* old node —
 const CONFIG_DIR = require("../config-dir");
 const PACKS_DIR = process.env.PACKS_DIR ? path.resolve(process.env.PACKS_DIR) : path.join(CONFIG_DIR, "packs");
 
-const SECTIONS = ["Stance", "Procedure", "State", "Journal"];
+// Decisions: settled facts (dates, prices, choices, owners) as dated lines,
+// append-only. State is replaced every turn and Journal is capped, so a
+// decision kept only there falls out of memory (22 Oct: the launch dates and
+// seat price did).
+const SECTIONS = ["Stance", "Procedure", "State", "Decisions", "Journal"];
 const MAX_JOURNAL_ENTRIES = 30;
 // Enforced budget on LLM-edited State (the prompt's ~150-word target stays the
 // aspiration; this generous ceiling is the mechanical stop against drift — a
@@ -57,11 +61,11 @@ function parseFrontmatter(content) {
 }
 
 function parseSections(body) {
-  const out = { Stance: "", Procedure: "", State: "", Journal: "" };
+  const out = { Stance: "", Procedure: "", State: "", Decisions: "", Journal: "" };
   let current = null;
   const pre = [];
   for (const line of String(body || "").split("\n")) {
-    const h = line.match(/^##\s+(Stance|Procedure|State|Journal)\s*$/i);
+    const h = line.match(/^##\s+(Stance|Procedure|State|Decisions|Journal)\s*$/i);
     if (h) {
       current = SECTIONS.find((s) => s.toLowerCase() === h[1].toLowerCase());
       continue;
@@ -94,6 +98,7 @@ function serialize(pack) {
   if (pack.archived) fmLines.push(`archived: ${pack.archived}`);
   fmLines.push("---");
   const sections = SECTIONS
+    .filter((s) => s !== "Decisions" || (pack.sections?.Decisions || "").trim())
     .map((s) => `## ${s}\n\n${(pack.sections?.[s] || "").trim()}`)
     .join("\n\n");
   return fmLines.join("\n") + "\n\n" + sections + "\n";
@@ -266,7 +271,7 @@ function writePack(pack) {
   return pack.dir;
 }
 
-function createPack({ dir, name, description, tags, stance, procedure, state, journal, parent, skill, kind, learned_on, applied_on }, origin = "user") {
+function createPack({ dir, name, description, tags, stance, procedure, state, decisions, journal, parent, skill, kind, learned_on, applied_on }, origin = "user") {
   const d = slugify(dir || name);
   if (!d) throw new Error("pack needs a name");
   if (readPack(d)) throw new Error(`pack ${d} already exists`);
@@ -287,6 +292,7 @@ function createPack({ dir, name, description, tags, stance, procedure, state, jo
       State: origin !== "user" && (state || "").length > MAX_STATE_CHARS
         ? trimToBudget(state, MAX_STATE_CHARS)
         : (state || ""),
+      Decisions: appendDecisions("", decisions).text,
       Journal: journal ? `- [${today()}] ${journal}` : "",
     },
   };
@@ -295,6 +301,21 @@ function createPack({ dir, name, description, tags, stance, procedure, state, jo
   return pack;
 }
 
+// Append settled-decision lines (string or array) as dated bullets, skipping
+// any that restate a decision already stored. Never drops old lines.
+function appendDecisions(existing, decisions) {
+  const entries = String(existing || "").split("\n").filter((l) => l.trim());
+  let added = 0;
+  for (const raw of [].concat(decisions || [])) {
+    const m = /^-?\s*(?:\[(\d{4}-\d{2}-\d{2})\]\s*)?([\s\S]*)$/.exec(String(raw || "").trim().replace(/\n+/g, " "));
+    const line = m[2].trim();
+    if (!line || isNearDupJournal(line, entries)) continue;
+    entries.push(`- [${m[1] || today()}] ${line}`);
+    added++;
+  }
+  return { text: entries.join("\n"), added };
+}
+
 function today() {
   return new Date().toISOString().slice(0, 10);
 }
@@ -409,7 +430,7 @@ function isNearDupJournal(line, recentEntries) {
 
 // Apply a reviewer mutation. Only supplied fields change; journal entries
 // append (capped + deduped); state replaces (it represents "current truth").
-function updatePack(dir, { description, tags, stance, procedure, state, journal, skill, kind, learned_on } = {}, origin = "user") {
+function updatePack(dir, { description, tags, stance, procedure, state, decisions, journal, skill, kind, learned_on } = {}, origin = "user") {
   const pack = readPack(dir);
   if (!pack) throw new Error(`no pack: ${dir}`);
   pack.updated = new Date().toISOString();
@@ -456,6 +477,13 @@ function updatePack(dir, { description, tags, stance, procedure, state, journal,
     pack.sections.State = next;
     applied.push("State");
   }
+  if (decisions && [].concat(decisions).some((d) => String(d || "").trim())) {
+    const d = appendDecisions(pack.sections.Decisions, decisions);
+    if (d.added) {
+      pack.sections.Decisions = d.text;
+      applied.push("Decisions");
+    }
+  }
   if (typeof journal === "string" && journal.trim()) {
     const entries = pack.sections.Journal.split("\n").filter((l) => l.trim());
     const line = journal.trim().replace(/\n+/g, " ");

package/core/providers/claude.js

@@ -174,6 +174,21 @@ function appendToolLists(args, context) {
   }
 }
 
+// Claude Code's own timers, monitors and workflow runner die with the per-turn
+// process, so a foreground turn never sees them: the bot's scheduler (open-claudia
+// schedule-wakeup / watch-add / cron-add) is the only one that survives.
+// Hiding them also drops their long descriptions from every turn's prompt.
+const FOREGROUND_DISALLOWED_TOOLS = Object.freeze([
+  "ScheduleWakeup", "CronCreate", "CronDelete", "CronList", "Monitor",
+  "RemoteTrigger", "Workflow", "PushNotification", "mcp__claude_ai_Claude_Docs",
+]);
+
+function appendForegroundToolBlocks(args, context) {
+  const extra = Array.isArray(context.disallowedTools) ? context.disallowedTools : [];
+  const list = [...new Set([...FOREGROUND_DISALLOWED_TOOLS, ...extra])];
+  args.push("--disallowedTools", list.join(","));
+}
+
 function appendReadOnlyDirectories(args, context) {
   if (context.additionalReadOnlyDirectories === undefined || context.additionalReadOnlyDirectories === null) return;
   if (!context.readOnly) {
@@ -219,6 +234,12 @@ function createClaudeProvider(options = {}) {
 
     const binary = requireExecutable();
     const env = { ...buildEnv() };
+    // Claude Code's own auto-memory (MEMORY.md under ~/.claude/projects) loads
+    // on every turn beside the bot's lessons and packs. CLAUDE_AUTO_MEMORY=off
+    // turns it off once its rules live in the bot's memory.
+    if (!utility && /^(off|false|0)$/i.test(String(config.settingValue("CLAUDE_AUTO_MEMORY") || ""))) {
+      env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+    }
     let toolHookSettings = context.toolHookSettings || null;
     if (hookTransport) {
       try {
@@ -235,6 +256,7 @@ function createClaudeProvider(options = {}) {
 
     const args = ["-p"];
     if (utility) appendToolLists(args, context);
+    else appendForegroundToolBlocks(args, context);
     args.push(
       "--verbose",
       "--output-format", "stream-json",

package/core/recall/discoverer.js

@@ -65,8 +65,12 @@ function scoutToolGaps(userText, keptToolNames, allTools) {
   for (const d of OPERATIONAL_DOMAINS) {
     if (!d.test.test(text)) continue;
     if (d.covers && kept.some((n) => d.covers.test(n))) continue;
+    // The tool named for the domain first, then any name match, and only then
+    // a description match — first-hit-wins pointed kubectl at books-loader.
     const hit = d.covers
-      ? all.find((t) => d.covers.test(t.name) || d.covers.test(String(t.description || "")))
+      ? (d.slug && all.find((t) => t.name === d.slug))
+        || all.find((t) => d.covers.test(t.name))
+        || all.find((t) => d.covers.test(String(t.description || "")))
       : null;
     if (hit && kept.includes(hit.name.toLowerCase())) continue;
     const g = hit
@@ -211,7 +215,7 @@ function excerptFor(id, packsLib, entitiesLib) {
     if (id.startsWith("pack:")) {
       const p = packsLib.readPack(id.slice(5));
       if (!p) return null;
-      const body = [p.sections.Stance, p.sections.State].filter(Boolean).join("\n").trim();
+      const body = [p.sections.Stance, p.sections.State, p.sections.Decisions].filter(Boolean).join("\n").trim();
       return { id, name: p.name, description: p.description, excerpt: clip(body, EXCERPT_CHARS) };
     }
     if (id.startsWith("tool:")) {
@@ -641,7 +645,7 @@ async function run(ctx) {
   let episodeCands = [];
   if (tier === "full" && EPISODES_ENABLED && episodesAllowedForSpeaker() && transcriptIndex && transcriptIndex.available()) {
     try {
-      const { hits } = transcriptIndex.search(userText, { limit: tuning.get("episodeLimit") });
+      const { hits } = transcriptIndex.searchRelated(userText, { limit: tuning.get("episodeLimit") });
       episodeCands = (hits || []).map((h) => {
         const terms = [...String(h.snip || "").matchAll(/>>(.+?)<</g)].map((m) => m[1]).slice(0, 4);
         return {

package/core/recall/external.js

@@ -0,0 +1,113 @@
+// External recall engines: `x` and `mem0` (Sumeet, 25 Oct: swap the
+// per-turn auto-loader between the discoverer and two experimental memory
+// searches to feel which gives better replies).
+//
+// Each runs an outside command with the cleaned user message as the final
+// argument (execFile, no shell) and injects its stdout as one recall section
+// where the discoverer's packs would go. Timeout, error or empty output falls
+// back to the discoverer for that turn (classic on a live call, where the
+// discoverer's walk is dead air), and the reason is logged.
+
+const { execFile } = require("child_process");
+const discoverer = require("./discoverer");
+const classic = require("./classic");
+const metrics = require("./metrics");
+
+const PYTHON = "/Users/sumeetrajpal/Workspace/memory-pyramid/.venv312/bin/python";
+const MAX_CHARS = 8000;
+
+const SPECS = {
+  x: {
+    label: "X",
+    cmdEnv: "RECALL_X_CMD",
+    defaultCmd: `${PYTHON} /Users/sumeetrajpal/Workspace/memory-pyramid/facts/mem.py recall`,
+    env: { MEM_N: "10", MEM_CUTOFF: "2099-01-01T00:00:00Z" },
+    dropLine: null,
+  },
+  mem0: {
+    label: "Mem0",
+    cmdEnv: "RECALL_MEM0_CMD",
+    defaultCmd: `${PYTHON} /Users/sumeetrajpal/Workspace/memory-pyramid/mem0lab/lab.py search`,
+    env: {},
+    dropLine: /posthog|spacy|warn/i,
+  },
+};
+
+// From the process env or, failing that, the bot's .env file: the bot never
+// copies .env into process.env, so a .env-only RECALL_X_CMD was silently
+// ignored and the default command ran instead (25 Oct).
+function setting(key) {
+  try { return require("../config").settingValue(key); } catch (e) { return process.env[key]; }
+}
+
+function timeoutMs() {
+  const n = Number(setting("RECALL_EXTERNAL_TIMEOUT_MS"));
+  return Number.isFinite(n) && n > 0 ? n : 8000;
+}
+
+// Run the command; resolves { text } or { error } (never rejects).
+function runCommand(spec, query) {
+  // Split on whitespace: no shell, so a path with spaces is not supported.
+  const parts = String(setting(spec.cmdEnv) || spec.defaultCmd).trim().split(/\s+/).filter(Boolean);
+  if (!parts.length) return Promise.resolve({ error: "no-command" });
+  return new Promise((resolve) => {
+    try {
+      execFile(parts[0], [...parts.slice(1), query], {
+        timeout: timeoutMs(),
+        killSignal: "SIGKILL",
+        maxBuffer: 4 * 1024 * 1024,
+        env: { ...spec.env, ...process.env },
+        windowsHide: true,
+      }, (err, stdout, stderr) => {
+        if (err) {
+          if (err.killed || err.signal === "SIGKILL") return resolve({ error: "timeout" });
+          // The last stderr line is usually the actual exception.
+          const lastErr = String(stderr || "").trim().split("\n").pop();
+          return resolve({ error: `error: ${err.code || ""} ${lastErr || String(err.message || "").split("\n")[0]}`.trim() });
+        }
+        let lines = String(stdout || "").split("\n");
+        if (spec.dropLine) lines = lines.filter((line) => !spec.dropLine.test(line));
+        const text = lines.join("\n").trim();
+        if (!text) return resolve({ error: "empty" });
+        resolve({ text: text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n…(truncated)` : text });
+      });
+    } catch (e) {
+      resolve({ error: `error: ${e.message}` });
+    }
+  });
+}
+
+function makeEngine(name) {
+  const spec = SPECS[name];
+  async function run(ctx) {
+    const started = Date.now();
+    const query = String(ctx?.userText || "").trim();
+    const out = query ? await runCommand(spec, query) : { error: "no-query" };
+    const row = {
+      engine: name,
+      provider: ctx?.provider || "",
+      query,
+      tier: name,
+      latencyMs: Date.now() - started,
+      walker: "off",
+    };
+    if (out.text) {
+      metrics.logTurn(row);
+      return {
+        engine: name,
+        packBlock: `## Memory facts (${spec.label})\n${out.text}\n\n`,
+        entityBlock: "",
+        packMatches: [],
+        entityMatches: [],
+      };
+    }
+    const fallback = ctx?.liveCall === true ? classic : discoverer;
+    console.error(`[recall] ${name} engine fell back to ${fallback.name}: ${out.error}`);
+    metrics.logTurn({ ...row, fallback: `${out.error} -> ${fallback.name}` });
+    const result = await fallback.run(ctx);
+    return { ...result, engine: `${name}->${fallback.name}` };
+  }
+  return { name, run };
+}
+
+module.exports = { x: makeEngine("x"), mem0: makeEngine("mem0"), SPECS, MAX_CHARS };

package/core/recall/graph.js

@@ -355,7 +355,7 @@ function syncFromCorpus(packsLib, entitiesLib) {
       const parentId = resolve(String(p.parent).toLowerCase());
       if (parentId && addEdge(id, parentId, "parent")) count++;
     }
-    const body = [p.sections.Stance, p.sections.Procedure, p.sections.State, p.sections.Journal].join("\n");
+    const body = [p.sections.Stance, p.sections.Procedure, p.sections.State, p.sections.Decisions, p.sections.Journal].join("\n");
     for (const link of parseLinks(body)) {
       const target = resolve(link);
       if (!target || target === id) continue;

package/core/recall/index.js

@@ -9,16 +9,21 @@
 // the default: it's fail-open (falls back to the classic keyword baseline on
 // any error), so it never recalls worse than classic, only better. `ask`
 // injects nothing and points the model at on-demand recall instead
-// (`open-claudia recall query`) — pull, not push.
+// (`open-claudia recall query`) — pull, not push. `x` and `mem0` run an external
+// memory search per turn (core/recall/external.js), falling back to the
+// discoverer when it times out, fails or finds nothing.
 
 const classic = require("./classic");
 const discoverer = require("./discoverer");
 const ask = require("./ask");
+const external = require("./external");
 
 const ENGINES = {
   classic,
   discoverer,
   ask,
+  x: external.x,
+  mem0: external.mem0,
 };
 
 // The default recall engine for channels that haven't explicitly chosen one
@@ -41,4 +46,7 @@ function getEngine(name) {
   return ENGINES[name] || classic;
 }
 
-module.exports = { ENGINES, listEngines, activeEngineName, getEngine, DEFAULT_ENGINE };
+// Engines that spawn a local command: only the owner may switch to them.
+const OWNER_ONLY_ENGINES = ["x", "mem0"];
+
+module.exports = { ENGINES, listEngines, activeEngineName, getEngine, DEFAULT_ENGINE, OWNER_ONLY_ENGINES };

package/core/recall/metrics.js

@@ -26,7 +26,8 @@ function enabled() {
 //   { engine, query, tier, seeds:[{id,score}], activated:[{id,activation,hop}],
 //     cand:[{id,act}], kept:[{id,why}], auto:{kept:[],dropped:[],shadow:{checks,agree}},
 //     gated (bool), latencyMs, seedMs, expandMs, walkerMs,
-//     walker ("warm"|"cold"|"off"|"failed"), costUsd }
+//     walker ("warm"|"cold"|"off"|"failed"), costUsd,
+//     fallback (x/mem0 only: why that turn fell back) }
 function logTurn(entry) {
   if (!enabled()) return;
   try {
@@ -50,8 +51,12 @@ function logTurn(entry) {
       walkerMs: entry.walkerMs || 0,
       walker: entry.walker || "",
       costUsd: entry.costUsd || 0,
+      ...(entry.fallback ? { fallback: String(entry.fallback).slice(0, 200) } : {}),
     };
     fs.appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n");
+    // A fallback row (x/mem0 failed) is followed by the fallback engine's own
+    // row for the same turn; only that one counts in the rollups.
+    if (rec.fallback) return;
     bumpSummary(rec);
     bumpNodeStats(rec);
   } catch (e) {}

package/core/recall/query.js

@@ -143,7 +143,7 @@ async function query(question, opts = {}) {
   // own box); bot-side callers still pass through the per-turn engine's gate.
   if (opts.episodes !== false && transcriptIndex && transcriptIndex.available()) {
     try {
-      const { hits } = transcriptIndex.search(q, { limit: tuning.get("episodeLimit") });
+      const { hits } = transcriptIndex.searchRelated(q, { limit: tuning.get("episodeLimit") });
       for (const h of (hits || [])) {
         const terms = [...String(h.snip || "").matchAll(/>>(.+?)<</g)].map((m) => m[1]).slice(0, 4);
         candidates.push({

package/core/recall/tuning.js

@@ -69,13 +69,21 @@ function clampKnob(name, value) {
   return Math.min(spec.max, Math.max(spec.min, n));
 }
 
+// Operator pin for a knob: its env var, from the process env or the bot's
+// .env file (the bot never copies .env into process.env).
+function pinOf(spec) {
+  if (!spec.env) return undefined;
+  const live = process.env[spec.env];
+  if (live !== undefined && live !== "") return live;
+  try { return require("../config").settingValue(spec.env); } catch (e) { return undefined; }
+}
+
 // Effective value of a knob, honouring env pin > tuning file > default.
 function get(name) {
   const spec = KNOBS[name];
   if (!spec) return undefined;
-  if (spec.env && process.env[spec.env] !== undefined && process.env[spec.env] !== "") {
-    return clampKnob(name, process.env[spec.env]);
-  }
+  const pin = pinOf(spec);
+  if (pin !== undefined) return clampKnob(name, pin);
   const data = readFile();
   if (data.knobs && data.knobs[name] !== undefined) return clampKnob(name, data.knobs[name]);
   return spec.def;
@@ -89,7 +97,7 @@ function knobTable() {
     min: spec.min,
     max: spec.max,
     values: spec.values,
-    pinned: !!(spec.env && process.env[spec.env]),
+    pinned: pinOf(spec) !== undefined,
   }));
 }
 
@@ -98,7 +106,7 @@ function knobTable() {
 function set(name, value, { reason = "", evidence = "" } = {}) {
   const spec = KNOBS[name];
   if (!spec) return null;
-  if (spec.env && process.env[spec.env]) return null; // operator pin wins — don't fight it
+  if (pinOf(spec) !== undefined) return null; // operator pin wins — don't fight it
   const from = get(name);
   const to = clampKnob(name, value);
   if (to === from) return null;

package/core/session-core.js

@@ -0,0 +1,118 @@
+// A resumed Claude Code session keeps the system prompt it started with: the
+// --append-system-prompt on a --resume is ignored (proven 22 Oct 2026 — a
+// resumed session still answered from its first prompt and never saw the new
+// one). So an edit to the soul, persona, lessons or any core section never
+// reached a running conversation until it was compacted or restarted fresh.
+//
+// This remembers, per provider session, the core instructions it has been
+// told (one small file per session), and on the next turn hands over only the
+// lines that changed since, once. The baseline then moves to the new core, so
+// each change rides exactly one turn of each conversation.
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const CONFIG_DIR = require("../config-dir");
+
+const DIR = path.join(CONFIG_DIR, "cache", "session-core");
+const MAX_FILES = 300;
+const MAX_CHARS = 6000;
+// Lessons rotate in and out of the always-loaded block by budget, so a lesson
+// leaving it has NOT stopped applying; new lessons reach a running session
+// through system-prompt.js newLessonsSection instead.
+const SKIP_SECTIONS = [/^Lessons learned/i];
+
+function sectionsOf(core) {
+  const sections = {};
+  let heading = "(top)";
+  for (const line of String(core || "").split("\n")) {
+    if (/^## /.test(line)) { heading = line.slice(3).trim(); sections[heading] ||= []; continue; }
+    if (SKIP_SECTIONS.some((re) => re.test(heading))) continue;
+    if (!line.trim()) continue;
+    (sections[heading] ||= []).push(line);
+  }
+  return sections;
+}
+
+function fileFor(sessionId) {
+  const name = crypto.createHash("sha1").update(String(sessionId)).digest("hex").slice(0, 24);
+  return path.join(DIR, `${name}.json`);
+}
+
+function prune() {
+  try {
+    const files = fs.readdirSync(DIR)
+      .map((f) => ({ f, t: fs.statSync(path.join(DIR, f)).mtimeMs }))
+      .sort((a, b) => b.t - a.t);
+    for (const { f } of files.slice(MAX_FILES)) fs.rmSync(path.join(DIR, f), { force: true });
+  } catch (_) { /* best effort */ }
+}
+
+function save(sessionId, sections) {
+  fs.mkdirSync(DIR, { recursive: true });
+  const file = fileFor(sessionId);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ sessionId, at: new Date().toISOString(), sections }));
+  fs.renameSync(tmp, file);
+}
+
+function diffSections(before, after) {
+  const out = [];
+  const headings = [...new Set([...Object.keys(after), ...Object.keys(before)])];
+  for (const heading of headings) {
+    const old = before[heading];
+    const now = after[heading];
+    if (!old) { out.push({ heading, added: now, removed: [], isNew: true }); continue; }
+    if (!now) { out.push({ heading, added: [], removed: [], isGone: true }); continue; }
+    const oldSet = new Set(old);
+    const nowSet = new Set(now);
+    const added = now.filter((line) => !oldSet.has(line));
+    const removed = old.filter((line) => !nowSet.has(line));
+    if (added.length || removed.length) out.push({ heading, added, removed });
+  }
+  return out;
+}
+
+function render(changes) {
+  const parts = [];
+  let used = 0;
+  let cut = 0;
+  for (const change of changes) {
+    const lines = [`### ${change.heading}${change.isNew ? " (new section)" : ""}`];
+    if (change.isGone) lines.push("This whole section was removed and no longer applies.");
+    for (const line of change.added) lines.push(`+ ${line}`);
+    for (const line of change.removed) lines.push(`- (no longer applies) ${line}`);
+    const block = lines.join("\n");
+    if (used + block.length > MAX_CHARS) { cut += 1; continue; }
+    parts.push(block);
+    used += block.length;
+  }
+  if (!parts.length && !cut) return "";
+  return [
+    "## Instruction changes since this conversation started",
+    "Your instructions were updated after this conversation began. Lines marked + are now part of them; lines marked - no longer apply. Follow the new wording over the old.",
+    ...parts,
+    ...(cut ? [`(${cut} more changed section(s) did not fit; they apply in full from the next new conversation.)`] : []),
+  ].join("\n\n");
+}
+
+// sessionId: the provider session being resumed (null on a fresh run: that
+// run is given the current core directly). currentCore: freshly built core.
+function changesSince(sessionId, currentCore) {
+  if (!sessionId || !currentCore) return "";
+  try {
+    const now = sectionsOf(currentCore);
+    const file = fileFor(sessionId);
+    if (!fs.existsSync(file)) {
+      // First sight of this session: it was started with (about) this core.
+      save(sessionId, now);
+      prune();
+      return "";
+    }
+    const before = JSON.parse(fs.readFileSync(file, "utf8")).sections || {};
+    const text = render(diffSections(before, now));
+    if (text) save(sessionId, now);
+    return text;
+  } catch (_) { return ""; }
+}
+
+module.exports = { changesSince, sectionsOf, diffSections, render, DIR };