@inetafrica/open-claudia 2.6.36 → 2.6.38

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.37
+- **`/recall [on|off]` — watch recall work.** A per-chat debug toggle that, when on, posts a short `🧠 Recall this turn` line just before each reply listing the packs/entities that surfaced — and on the **discoverer** engine, the one-line why-bullet for each. On a gated turn (pre-gate skipped recall) it says so; on a quiet turn with no matches it stays silent. The engines now return a `why` map + `gated` flag, `promptWithDynamicContext` captures a recall summary into the per-turn `consumeLastInjected()` buffer, and `runner.js` renders it when `settings.showRecall` is set. Off by default; flip with `/recall` (buttons) or `/recall on`.
+
 ## v2.6.36
 - **Docs: document the dual-engine recall feature.** v2.6.34/v2.6.35 shipped the pluggable recall engine and `/engine` switch but the README and `.env.example` were never updated. This release fills the gap: README gains a "Pluggable recall" Features bullet, the `/engine` command row, a "Recall engines" narrative section, the `recall-stats` / `recall graph` CLI commands, and env-table rows for `RECALL_ENGINE` / `RECALL_GRAPH_DB` / `RECALL_METRICS` / `DREAM_TIER` (plus the corrected `DREAM_MODEL` default). `.env.example` gains `RECALL_ENGINE` and `DREAM_TIER`. Docs-only — no code changes.
 

package/README.md

@@ -189,6 +189,7 @@ When you select a project, the last conversation is automatically resumed. Tap "
 | `/learn [<hint>]` | Capture the last piece of work into the matching context pack |
 | `/skills [show\|remove <name>]` | List, show, or remove legacy learned skills |
 | `/engine [classic\|discoverer]` | Switch the per-chat memory recall engine (default `classic`) |
+| `/recall [on\|off]` | Toggle a per-turn "🧠 Recall this turn" debug line showing which packs/entities surfaced (and why, on discoverer) |
 | `/soul` | View/edit assistant identity and personality |
 | `/dreamsummary [on\|off]` | Toggle the post-dream memory summary in chat |
 
@@ -264,7 +265,7 @@ Open Claudia layers three memory systems on top of the backend's native sessions
 
 **Entity memory** (`~/.open-claudia/entities/<slug>.md`) works the same way for the people, places, projects, orgs, and systems you mention — who they are, current truth, and a dated observation log. Mentioning a name injects its note.
 
-**Recall engines** — how packs and entities get matched and surfaced is pluggable per chat via `/engine` (or the `RECALL_ENGINE` env default). **classic** (the default) is keyword FTS plus a relevance judge with headline injection — stable and unchanged. **discoverer** (opt-in) adds a typed-edge graph over the same corpus (`parent`/`governed-by`/`related` edges with weights in `recall-graph.db`) and runs: a pre-gate that skips recall on trivial turns → FTS seeding → spreading activation across the graph (1–2 hops — auto-pulls cross-cutting concerns the query never named) → a walker that reads each candidate and returns the genuinely-relevant set with one-line why-bullets (fail-open to keyword seeds, so it never recalls worse than classic). Edges form structurally from pack `parent` frontmatter and `[[links]]`, and strengthen via Hebbian co-use when the agent opens packs together (📖); weights decay over time. Inspect with `open-claudia recall-stats` and `open-claudia recall graph [--sync]`. Switch back any time with `/engine classic`.
+**Recall engines** — how packs and entities get matched and surfaced is pluggable per chat via `/engine` (or the `RECALL_ENGINE` env default). **classic** (the default) is keyword FTS plus a relevance judge with headline injection — stable and unchanged. **discoverer** (opt-in) adds a typed-edge graph over the same corpus (`parent`/`governed-by`/`related` edges with weights in `recall-graph.db`) and runs: a pre-gate that skips recall on trivial turns → FTS seeding → spreading activation across the graph (1–2 hops — auto-pulls cross-cutting concerns the query never named) → a walker that reads each candidate and returns the genuinely-relevant set with one-line why-bullets (fail-open to keyword seeds, so it never recalls worse than classic). Edges form structurally from pack `parent` frontmatter and `[[links]]`, and strengthen via Hebbian co-use when the agent opens packs together (📖); weights decay over time. Inspect with `open-claudia recall-stats` and `open-claudia recall graph [--sync]`, or flip on `/recall` to watch — per turn — which packs/entities surfaced and why, right in the chat. Switch back any time with `/engine classic`.
 
 **Dream consolidation** — while the per-turn reviewer takes quick notes, *dream* is the slow overnight pass (default 4am, on a high-tier model — opus by default, set `DREAM_TIER` or `DREAM_MODEL`): it merges packs that drifted into the same topic, builds parent/sub pack trees with umbrella summaries, tightens descriptions and tags so the router matches with less noise, dedupes entities, cross-links notes, and tends the recall graph (structural sync, weight decay, orphan prune). Anything merged away is backed up under `~/.open-claudia/backup/dream-<stamp>/` first, and every dream that changes something reports in chat. Configure with `DREAM_CRON` / `DREAM_MODEL`, disable with `DREAM=off`.
 

package/bin/cli.js

@@ -289,6 +289,21 @@ switch (command) {
     break;
   }
 
+  case "lessons": {
+    require("./lessons").run(args.slice(1));
+    break;
+  }
+
+  case "ideas": {
+    require("./ideas").run(args.slice(1));
+    break;
+  }
+
+  case "keyring": {
+    require("./keyring").run(args.slice(1));
+    break;
+  }
+
   case "agent": {
     require("./agent").run(args.slice(1));
     break;
@@ -351,6 +366,9 @@ Memory tools:
                                              (alias: tw; --help for options)
   open-claudia pack list|show|match|archive|restore|archived  Context packs: living topic docs (skills + memory)
   open-claudia entity list|show|match|note   Entity notes: people/places/projects memory
+  open-claudia lessons list|add|remove|show  Always-loaded learned rules (cross-cutting, promoted after a miss)
+  open-claudia ideas list|add|remove|show    Self-improvement backlog (captured by the nightly dream)
+  open-claudia keyring list|get|set|remove   Operational creds the agent can reuse (plaintext; vault for secrets)
   open-claudia dream [--dry-run]             Run the memory consolidation pass now
 
 Background work (only inside an active bot-spawned task):

package/bin/ideas.js

@@ -0,0 +1,69 @@
+// CLI: inspect and manage the self-improvement ideas backlog (ideas.md).
+//   open-claudia ideas list                        — show all ideas (newest first)
+//   open-claudia ideas add "<idea>" [--scope oc|work] — add one
+//   open-claudia ideas remove <id|text>            — remove one
+//   open-claudia ideas show                         — raw file
+//   open-claudia ideas path                         — print the file path
+
+const fs = require("fs");
+const ideas = require("../core/ideas");
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list": {
+      const all = ideas.listIdeas();
+      if (all.length === 0) return console.log(`No ideas yet (${ideas.IDEAS_FILE}).`);
+      console.log(`${all.length} idea(s) — self-improvement backlog (newest first):\n`);
+      for (const i of all) {
+        const date = i.date ? `${i.date} ` : "";
+        const scope = i.scope ? `(${i.scope}) ` : "";
+        console.log(`[${i.id}] ${date}${scope}${i.text}`);
+      }
+      console.log(`\nCap ${ideas.MAX_IDEAS}; edit: ${ideas.IDEAS_FILE}`);
+      break;
+    }
+
+    case "add": {
+      let scope = "";
+      const words = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--scope") { scope = rest[++i] || ""; continue; }
+        words.push(rest[i]);
+      }
+      const text = words.join(" ").trim();
+      if (!text) { console.error('Usage: ideas add "<idea>" [--scope oc|work]'); process.exitCode = 1; return; }
+      const r = ideas.addIdea({ text, scope });
+      if (r.added) console.log(`Added idea [${r.id}] (now ${r.count}).`);
+      else if (r.duplicate) console.log(`Already had that one [${r.id}].`);
+      else { console.error(`Not added: ${r.reason}`); process.exitCode = 1; }
+      break;
+    }
+
+    case "remove":
+    case "rm": {
+      const key = rest.join(" ").trim();
+      if (!key) { console.error("Usage: ideas remove <id|text>"); process.exitCode = 1; return; }
+      console.log(ideas.removeIdea(key) ? `Removed ${key}.` : `No matching idea: ${key}`);
+      break;
+    }
+
+    case "show": {
+      let raw = "";
+      try { raw = fs.readFileSync(ideas.IDEAS_FILE, "utf-8"); } catch (e) { raw = "(no ideas file yet)"; }
+      console.log(`=== ${ideas.IDEAS_FILE} ===\n${raw}`);
+      break;
+    }
+
+    case "path":
+      console.log(ideas.IDEAS_FILE);
+      break;
+
+    default:
+      console.log('Usage: open-claudia ideas [list|add "<idea>" [--scope oc|work]|remove <id|text>|show|path]');
+  }
+}
+
+module.exports = { run };

package/bin/keyring.js

@@ -0,0 +1,64 @@
+// CLI: inspect and manage the operational keyring — plaintext creds the
+// agent is allowed to use on its own (API keys, base URLs, account IDs).
+//   open-claudia keyring list              — show all keys (values masked)
+//   open-claudia keyring get <name>        — print the full value (local use)
+//   open-claudia keyring set <name> <value> — store/replace a credential
+//   open-claudia keyring remove <name>     — delete one
+//   open-claudia keyring path              — print the file path
+//
+// For genuine personal secrets the bot should NOT use unattended, use the
+// vault (/vault) instead — it stays encrypted and locked.
+
+const keyring = require("../core/keyring");
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list": {
+      const entries = keyring.list();
+      const names = Object.keys(entries);
+      if (names.length === 0) return console.log(`Keyring is empty (${keyring.KEYRING_FILE}).`);
+      console.log(`${names.length} credential(s) — available to the agent as env vars:\n`);
+      for (const k of names) console.log(`${k} = ${entries[k]}`);
+      console.log(`\nFile: ${keyring.KEYRING_FILE}`);
+      break;
+    }
+
+    case "get": {
+      const key = rest[0];
+      if (!key) { console.error("Usage: keyring get <name>"); process.exitCode = 1; return; }
+      const v = keyring.get(key);
+      if (v === null) { console.error(`No such key: ${key}`); process.exitCode = 1; return; }
+      console.log(v);
+      break;
+    }
+
+    case "set": {
+      const key = rest[0];
+      const value = rest.slice(1).join(" ").trim();
+      if (!key || !value) { console.error('Usage: keyring set <name> <value>'); process.exitCode = 1; return; }
+      keyring.set(key, value);
+      console.log(`Stored ${key} (available to the agent next turn).`);
+      break;
+    }
+
+    case "remove":
+    case "rm": {
+      const key = rest[0];
+      if (!key) { console.error("Usage: keyring remove <name>"); process.exitCode = 1; return; }
+      console.log(keyring.remove(key) ? `Removed ${key}.` : `No such key: ${key}`);
+      break;
+    }
+
+    case "path":
+      console.log(keyring.KEYRING_FILE);
+      break;
+
+    default:
+      console.log('Usage: open-claudia keyring [list|get <name>|set <name> <value>|remove <name>|path]');
+  }
+}
+
+module.exports = { run };

package/bin/lessons.js

@@ -0,0 +1,72 @@
+// CLI: inspect and manage the always-loaded Lessons tier.
+//   open-claudia lessons list                       — show all lessons
+//   open-claudia lessons add "<rule>" [--src <pack>] — add one (origin=user)
+//   open-claudia lessons remove <id|text>           — remove one
+//   open-claudia lessons show                        — raw file + injected block
+//   open-claudia lessons path                        — print the file path
+
+const fs = require("fs");
+const lessons = require("../core/lessons");
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list": {
+      const all = lessons.listLessons();
+      if (all.length === 0) return console.log(`No lessons yet (${lessons.LESSONS_FILE}).`);
+      console.log(`${all.length} lesson(s) — always loaded into every conversation:\n`);
+      for (const l of all) {
+        const r = l.reinforced ? ` ·  reinforced ${l.reinforced}×` : "";
+        const src = l.src ? ` ·  src: ${l.src}` : "";
+        console.log(`[${l.id}] ${l.text}\n    origin: ${l.origin || "user"}${src}${r}`);
+      }
+      console.log(`\nCap ${lessons.MAX_LESSONS}; edit: ${lessons.LESSONS_FILE}`);
+      break;
+    }
+
+    case "add": {
+      // Pull optional --src <pack>, rest is the lesson text.
+      let src = "";
+      const words = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--src") { src = rest[++i] || ""; continue; }
+        words.push(rest[i]);
+      }
+      const text = words.join(" ").trim();
+      if (!text) { console.error('Usage: lessons add "<rule>" [--src <pack>]'); process.exitCode = 1; return; }
+      const r = lessons.addLesson({ text, src, origin: "user" });
+      if (r.added) console.log(`Added lesson [${r.id}]${r.overCap ? ` (now ${r.count}, over cap ${lessons.MAX_LESSONS} — the nightly dream will tidy)` : ""}.`);
+      else if (r.reinforced) console.log(`Already had that one — reinforced [${r.id}].`);
+      else { console.error(`Not added: ${r.reason}`); process.exitCode = 1; }
+      break;
+    }
+
+    case "remove":
+    case "rm": {
+      const key = rest.join(" ").trim();
+      if (!key) { console.error("Usage: lessons remove <id|text>"); process.exitCode = 1; return; }
+      console.log(lessons.removeLesson(key) ? `Removed ${key}.` : `No matching lesson: ${key}`);
+      break;
+    }
+
+    case "show": {
+      let raw = "";
+      try { raw = fs.readFileSync(lessons.LESSONS_FILE, "utf-8"); } catch (e) { raw = "(no lessons file yet)"; }
+      console.log(`=== ${lessons.LESSONS_FILE} ===\n${raw}`);
+      const block = lessons.loadLessonsBlock();
+      console.log(`\n=== injected block (${block.length} chars, budget ${lessons.MAX_LESSONS_CHARS}) ===\n${block || "(empty — nothing injected)"}`);
+      break;
+    }
+
+    case "path":
+      console.log(lessons.LESSONS_FILE);
+      break;
+
+    default:
+      console.log('Usage: open-claudia lessons [list|add "<rule>" [--src <pack>]|remove <id|text>|show|path]');
+  }
+}
+
+module.exports = { run };

package/bin/pack.js

@@ -20,13 +20,56 @@ function run(args) {
       if (all.length === 0) return console.log(`No packs yet (${packs.PACKS_DIR}).`);
       for (const p of all) {
         const used = p.last_used ? ` last-used ${p.last_used.slice(0, 10)} (${p.usage_count || 0}×)` : "";
-        console.log(`${p.dir} — ${p.name}${p.tags.length ? ` [${p.tags.join(", ")}]` : ""}${used}\n    ${p.description}`);
+        const skill = p.skill ? " ★skill" : "";
+        const ability = p.kind === "ability" ? " ◆ability" : "";
+        console.log(`${p.dir} — ${p.name}${skill}${ability}${p.tags.length ? ` [${p.tags.join(", ")}]` : ""}${used}\n    ${p.description}`);
       }
       const archived = packs.listArchived();
       if (archived.length) console.log(`\n(${archived.length} archived — open-claudia pack archived)`);
       break;
     }
 
+    case "skills": {
+      const all = packs.listSkillPacks();
+      if (all.length === 0) return console.log("No skill-flagged packs yet. Flag one: open-claudia pack skill <dir> on");
+      console.log(`${all.length} skill(s) — always surfaced in the system prompt:\n`);
+      for (const p of all) console.log(`${p.dir} — ${p.name}\n    ${p.description}`);
+      break;
+    }
+
+    case "skill": {
+      const dir = rest[0];
+      const on = (rest[1] || "on").toLowerCase() !== "off";
+      if (!dir) { console.error("Usage: pack skill <dir> [on|off]"); process.exitCode = 1; return; }
+      const p = packs.setSkill(dir, on);
+      if (!p) { console.error(`No pack: ${dir}`); process.exitCode = 1; return; }
+      console.log(`${p.dir} skill flag → ${on ? "on (now always indexed)" : "off"}.`);
+      break;
+    }
+
+    case "abilities": {
+      const all = packs.listAbilities();
+      if (all.length === 0) return console.log("No abilities yet. Mark one: open-claudia pack kind <dir> ability");
+      console.log(`${all.length} ability(ies) — reusable how-tos that transfer across projects:\n`);
+      for (const p of all) {
+        const prov = p.learned_on
+          ? `\n    learned on ${p.learned_on}${p.applied_on.length ? `, applied on ${p.applied_on.join(", ")}` : ""}`
+          : "";
+        console.log(`${p.dir} — ${p.name}${p.skill ? " ★always-on" : ""}\n    ${p.description}${prov}`);
+      }
+      break;
+    }
+
+    case "kind": {
+      const dir = rest[0];
+      const kind = rest[1];
+      if (!dir || !kind) { console.error("Usage: pack kind <dir> <ability|context>"); process.exitCode = 1; return; }
+      const p = packs.setKind(dir, kind);
+      if (!p) { console.error(`No pack: ${dir}`); process.exitCode = 1; return; }
+      console.log(`${p.dir} kind → ${p.kind}.`);
+      break;
+    }
+
     case "archive": {
       const p = packs.archivePack(rest[0]);
       if (!p) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
@@ -123,7 +166,7 @@ function run(args) {
     }
 
     default:
-      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
+      console.log("Usage: open-claudia pack [list|skills|abilities|skill <dir> [on|off]|kind <dir> <ability|context>|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
   }
 }
 

package/bot.js

@@ -23,6 +23,14 @@ require("./core/handlers"); // side-effect: register slash commands
 
 const CURRENT_VERSION = require(path.join(__dirname, "package.json")).version;
 
+// Register existing operational-keyring values so the redactor scrubs them
+// from any output we ship to chat. (New ones are registered on /keyring set.)
+try {
+  const keyring = require("./core/keyring");
+  const { registerSecrets } = require("./core/redact");
+  registerSecrets(Object.values(keyring.all()));
+} catch (e) { /* keyring optional — never block startup */ }
+
 registry.setHandlers({ onMessage, onAction });
 const adapters = registry.bootstrap();
 

package/core/actions.js

@@ -277,9 +277,17 @@ async function handleAction(envelope) {
   if (d.startsWith("eng:")) {
     const v = d.slice(4);
     const recall = require("./recall");
-    state.settings.recallEngine = recall.listEngines().includes(v) ? v : null;
+    // The default engine is stored as null (so it shows "(default)"); any other
+    // known engine is stored explicitly as an opt-out.
+    state.settings.recallEngine = (v === recall.DEFAULT_ENGINE || !recall.listEngines().includes(v)) ? null : v;
     saveState();
-    await send(`Recall engine: ${state.settings.recallEngine || "classic (default)"}`);
+    await send(`Recall engine: ${recall.activeEngineName(state.settings)}${state.settings.recallEngine ? "" : " (default)"}`);
+    return;
+  }
+  if (d.startsWith("rcl:")) {
+    state.settings.showRecall = d.slice(4) === "on";
+    saveState();
+    await send(`Recall debug: ${state.settings.showRecall ? "on" : "off"}`);
     return;
   }
   if (d.startsWith("cw:")) {

package/core/config.js

@@ -200,7 +200,16 @@ function loadChannels() {
 }
 
 function botSubprocessEnv() {
-  return { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+  const base = { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+  // Merge operational keyring creds so the agent can *use* what it remembered.
+  // Read fresh each spawn so a cred set mid-session is live next turn without a
+  // restart. process.env wins on conflict — bot infra config is authoritative.
+  try {
+    const keyring = require("./keyring");
+    return { ...keyring.all(), ...base };
+  } catch (e) {
+    return base;
+  }
 }
 
 module.exports = {

package/core/day-seeds.js

@@ -0,0 +1,98 @@
+// Per-day seed log. The compaction engine already archives each full brief to
+// briefs/ (one file per compaction). This module keeps a per-DAY rollup — one
+// file per calendar day, global across projects/channels — that appends the
+// condensed "what seeds the next conversation" digest every time a compaction
+// fires. It is the raw material the nightly dream reads to learn what was
+// actually worked on that day: the input for self-introspection [3b] and for
+// second-chance lesson promotion [1]. Detailed text stays in briefs/; this is
+// the digest, labelled by project + time so the dream can reconstruct the day.
+//
+// Seeds are read-only for the dream (raw input, never edited by it) and never
+// hold secrets beyond whatever the compaction summary already contains.
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+
+const SEEDS_DIR = process.env.DAY_SEEDS_DIR ? path.resolve(process.env.DAY_SEEDS_DIR) : path.join(CONFIG_DIR, "seeds");
+// Safety cap on a single day's file; if exceeded we trim from the front so the
+// most recent compactions always survive.
+const MAX_DAY_SEED_CHARS = Number(process.env.DAY_SEED_MAX_CHARS || 60000);
+
+// Local calendar day (YYYY-MM-DD). Local, not UTC, so "what I worked on today"
+// lines up with the user's day and the 4am dream reads the right file.
+function dayStamp(d = new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function daySeedPath(date) {
+  return path.join(SEEDS_DIR, `${date || dayStamp()}.md`);
+}
+
+// Append one compaction digest to today's seed file. Best-effort: never throws
+// into the compaction path (a seed-log failure must not break compaction).
+function appendDaySeed(entry = {}) {
+  try {
+    const body = String(entry.summary || "").trim();
+    if (!body) return null;
+    fs.mkdirSync(SEEDS_DIR, { recursive: true, mode: 0o700 });
+    const when = entry.when ? new Date(entry.when) : new Date();
+    const date = dayStamp(when);
+    const file = daySeedPath(date);
+    const head = [
+      `## ${when.toISOString()}`,
+      entry.project ? `Project: ${entry.project}` : null,
+      entry.channel ? `Channel: ${entry.channel}` : null,
+      entry.briefPath ? `Full brief: ${entry.briefPath}` : null,
+      "",
+    ].filter((l) => l !== null).join("\n");
+    const block = `${head}${body}\n\n`;
+
+    let existing = "";
+    try { existing = fs.readFileSync(file, "utf-8"); } catch (e) {}
+    const fileHeader = `# Day seed — ${date}\nCondensed compaction digests captured this day. The nightly dream reviews these to learn what was worked on.\n\n`;
+    let next = existing ? existing + block : fileHeader + block;
+    if (next.length > MAX_DAY_SEED_CHARS) next = next.slice(next.length - MAX_DAY_SEED_CHARS);
+    fs.writeFileSync(file, next, { mode: 0o600 });
+    return file;
+  } catch (e) {
+    return null;
+  }
+}
+
+function listDaySeedDates() {
+  try {
+    return fs.readdirSync(SEEDS_DIR)
+      .filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f))
+      .map((f) => f.replace(/\.md$/, ""))
+      .sort();
+  } catch (e) { return []; }
+}
+
+function readDaySeed(date) {
+  try { return fs.readFileSync(daySeedPath(date), "utf-8"); }
+  catch (e) { return ""; }
+}
+
+// The dream's view: the last `days` calendar days that actually have content.
+// The dream fires at 04:00, so "today" is usually empty and the work lives in
+// the prior day(s); pulling a small window catches work that straddles midnight.
+function recentDaySeeds({ days = 2 } = {}) {
+  const all = listDaySeedDates();
+  const picked = [];
+  const texts = [];
+  for (let i = all.length - 1; i >= 0 && picked.length < days; i--) {
+    const t = readDaySeed(all[i]);
+    if (t.trim()) { picked.unshift(all[i]); texts.unshift(t); }
+  }
+  return { dates: picked, text: texts.join("\n\n") };
+}
+
+module.exports = {
+  SEEDS_DIR, MAX_DAY_SEED_CHARS,
+  dayStamp, daySeedPath,
+  appendDaySeed, readDaySeed, listDaySeedDates, recentDaySeeds,
+};