@inetafrica/open-claudia 2.6.22 → 2.6.24

package/bin/cli.js

@@ -335,7 +335,7 @@ Memory tools:
                                              (alias: ts; --all for every project; --help for options)
   open-claudia transcript-window <pattern>   Search project transcript, show hits with context
                                              (alias: tw; --help for options)
-  open-claudia pack list|show|match|migrate  Context packs: living topic docs (skills + memory)
+  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 dream [--dry-run]             Run the memory consolidation pass now
 

package/bin/pack.js

@@ -19,9 +19,36 @@ function run(args) {
       const all = packs.listPacks();
       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)}` : "";
+        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 archived = packs.listArchived();
+      if (archived.length) console.log(`\n(${archived.length} archived — open-claudia pack archived)`);
+      break;
+    }
+
+    case "archive": {
+      const p = packs.archivePack(rest[0]);
+      if (!p) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(`Archived pack ${p.dir} → ${path.join(packs.PACKS_DIR, ".archived", p.dir)}\nRestore with: open-claudia pack restore ${p.dir}`);
+      break;
+    }
+
+    case "restore": {
+      let p;
+      try { p = packs.restorePack(rest[0]); }
+      catch (e) { console.error(e.message); process.exitCode = 1; return; }
+      if (!p) { console.error(`No archived pack: ${rest[0]}`); process.exitCode = 1; return; }
+      console.log(`Restored pack ${p.dir}.`);
+      break;
+    }
+
+    case "archived": {
+      const all = packs.listArchived();
+      if (all.length === 0) return console.log("No archived packs.");
+      for (const p of all) {
+        console.log(`${p.dir} — ${p.name}  (archived ${(p.archived || "").slice(0, 10)}, last-used ${(p.last_used || "never").slice(0, 10)}, ${p.usage_count || 0}×)`);
+      }
       break;
     }
 
@@ -93,7 +120,7 @@ function run(args) {
     }
 
     default:
-      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|reindex]");
+      console.log("Usage: open-claudia pack [list|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
   }
 }
 

package/core/dream.js

@@ -14,6 +14,7 @@ const path = require("path");
 const cron = require("node-cron");
 
 const CONFIG_DIR = require("../config-dir");
+const { config } = require("./config");
 const packs = require("./packs");
 const entities = require("./entities");
 const persona = require("./persona");
@@ -23,7 +24,13 @@ const DREAM_MODEL = process.env.DREAM_MODEL || "sonnet";
 const DREAM_CRON = process.env.DREAM_CRON || "0 4 * * *";
 const MAX_PACK_CHARS = 2500;
 const MAX_ENTITY_CHARS = 900;
-const LIMITS = { merges: 3, umbrellas: 2, parents: 8, retag: 8, entity_merges: 3, entity_notes: 4 };
+const LIMITS = { merges: 3, umbrellas: 2, parents: 8, retag: 8, entity_merges: 3, entity_notes: 4, archive: 5 };
+
+// Retirement guard: even if the model proposes archiving, only act when a pack
+// is genuinely cold — old enough, idle long enough, and rarely used. Protects
+// freshly-created packs the user just made.
+const ARCHIVE_IDLE_DAYS = Number(process.env.DREAM_ARCHIVE_IDLE_DAYS || 30);
+const ARCHIVE_MAX_USAGE = Number(process.env.DREAM_ARCHIVE_MAX_USAGE || 3);
 
 let _dreaming = false;
 
@@ -31,6 +38,15 @@ function enabled() {
   return (process.env.DREAM || "on").toLowerCase() !== "off";
 }
 
+// Whether to post the post-dream summary into the owner's chat. On by
+// default; toggled with /dreamsummary (persisted to .env, read back from
+// config on restart, with the live process.env taking precedence so the
+// toggle takes effect without a restart).
+function summaryEnabled() {
+  const v = process.env.DREAM_SUMMARY ?? config.DREAM_SUMMARY ?? "on";
+  return String(v).toLowerCase() !== "off";
+}
+
 function clip(s, n) {
   const t = String(s || "");
   return t.length > n ? t.slice(0, n) + "\n…[truncated]" : t;
@@ -45,7 +61,7 @@ function buildDreamPrompt() {
     `name: ${p.name}`,
     `description: ${p.description}`,
     `tags: ${p.tags.join(", ")}`,
-    `last_used: ${p.last_used || "never"}`,
+    `last_used: ${p.last_used || "never"} (used ${p.usage_count || 0}×)`,
     `Stance: ${p.sections.Stance}`,
     `Procedure: ${p.sections.Procedure}`,
     `State: ${p.sections.State}`,
@@ -83,13 +99,14 @@ Your job — decide what consolidation, if any, is warranted:
 4. retag: tighten descriptions and tags. The router FTS-matches incoming messages against name/description/tags, so generic words there cause false matches. Descriptions should be one specific line; tags specific nouns.
 5. entity_merges: the same real-world entity recorded twice gets merged (the better slug wins).
 6. entity_notes: rewrite an entity's Notes to be current and cross-linked — mention related packs as [[pack-dir]] and related entities by name.
-7. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
-8. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
+7. archive: retire packs that have gone cold — long unused AND rarely used over their life (consult last_used and the usage count). Archiving moves a pack out of the live index (reversibly, backed up) so it stops adding recall noise. ONLY propose packs idle ≥${ARCHIVE_IDLE_DAYS} days and used ≤${ARCHIVE_MAX_USAGE}× total; never an umbrella/parent pack that still has children; when in doubt, leave it. Give a one-line reason.
+8. persona: evolve the persona GENTLY — keep its structure and length (under 2200 chars), adjust only what recent work justifies (a new habit, a sharpened quirk). Most dreams should return null here.
+9. report: a short chat message to the owner, written AS Open Claudia in first person — warm, a little playful, a few emojis, mobile-friendly (2-6 short lines). Say what you tidied and why it helps. If you changed nothing, say the memory is in good shape, charmingly.
 
 Hard rules:
 - Never invent packs/entities not listed above; reference them by exact dir/slug.
 - Never store secrets, tokens, passwords, or credentials anywhere.
-- Limits: ≤${LIMITS.merges} merges, ≤${LIMITS.umbrellas} umbrellas, ≤${LIMITS.parents} parents, ≤${LIMITS.retag} retags, ≤${LIMITS.entity_merges} entity merges, ≤${LIMITS.entity_notes} entity note rewrites.
+- Limits: ≤${LIMITS.merges} merges, ≤${LIMITS.umbrellas} umbrellas, ≤${LIMITS.parents} parents, ≤${LIMITS.retag} retags, ≤${LIMITS.entity_merges} entity merges, ≤${LIMITS.entity_notes} entity note rewrites, ≤${LIMITS.archive} archives.
 - An empty decision is a perfectly good decision.
 
 Reply with ONLY a JSON object, no prose, no code fences:
@@ -99,6 +116,7 @@ Reply with ONLY a JSON object, no prose, no code fences:
  "retag": [{"pack": "<dir>", "description": "<one specific line>", "tags": ["..."]}],
  "entity_merges": [{"into": "<slug>", "from": ["<slug>"], "notes": "<merged Notes or null>"}],
  "entity_notes": [{"entity": "<slug>", "notes": "<rewritten Notes>"}],
+ "archive": [{"pack": "<dir>", "reason": "<one line: why it's cold>"}],
  "persona": null,
  "report": "<chat message>"}`;
 }
@@ -118,6 +136,7 @@ function parseDream(text) {
       retag: arr("retag"),
       entity_merges: arr("entity_merges"),
       entity_notes: arr("entity_notes"),
+      archive: arr("archive"),
       persona: typeof obj.persona === "string" ? obj.persona : null,
       report: typeof obj.report === "string" ? obj.report.trim() : "",
     };
@@ -259,6 +278,27 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] entity notes failed: ${e.message}`); }
   }
 
+  if (decision.archive && decision.archive.length) {
+    const allPacks = packs.listPacks();
+    for (const a of decision.archive) {
+      try {
+        const dir = a?.pack;
+        if (!dir || gone.has(dir)) continue;
+        const pack = packs.readPack(dir);
+        if (!pack) continue;
+        if (allPacks.some((p) => p.parent === dir)) continue; // never orphan children
+        const ageDays = pack.created ? (Date.now() - Date.parse(pack.created)) / 86400000 : Infinity;
+        const idleDays = pack.last_used ? (Date.now() - Date.parse(pack.last_used)) / 86400000 : ageDays;
+        const uses = Number(pack.usage_count) || 0;
+        if (ageDays < ARCHIVE_IDLE_DAYS || idleDays < ARCHIVE_IDLE_DAYS || uses > ARCHIVE_MAX_USAGE) continue;
+        backupPack(dir, backupRoot);
+        packs.archivePack(dir);
+        gone.add(dir);
+        lines.push(`🗃 Archived ${dir} — ${a.reason || `idle ${Math.round(idleDays)}d, used ${uses}×`}`);
+      } catch (e) { console.warn(`[dream] archive failed: ${e.message}`); }
+    }
+  }
+
   if (decision.persona) {
     try {
       if (persona.personaExists()) {
@@ -305,8 +345,9 @@ async function runDream({ trigger = "manual" } = {}) {
 }
 
 // In-bot scheduler: one quiet-hours cron, reporting to the owner's
-// Telegram chat. Silent (console only) when the dream changed nothing —
-// a nightly "all tidy" ping would be noise.
+// Telegram chat. When the dream summary is on (default) it posts a short
+// note after every run — including the charming "all tidy" line when
+// nothing changed. /dreamsummary off mutes it to console only.
 function initDream(adapters) {
   if (!enabled()) return;
   if (!cron.validate(DREAM_CRON)) {
@@ -318,7 +359,8 @@ function initDream(adapters) {
       const res = await runDream({ trigger: "cron" });
       if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return; }
       console.log(`dream: applied ${res.applied.length} change(s)`);
-      if (res.applied.length === 0) return;
+      if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return; }
+      if (!res.message) return;
       const { CHAT_ID } = require("./config");
       const tg = (adapters || []).find((a) => a.type === "telegram");
       if (tg && CHAT_ID) await tg.send(CHAT_ID, res.message);
@@ -329,4 +371,4 @@ function initDream(adapters) {
   console.log(`dream: scheduled (${DREAM_CRON}, model ${DREAM_MODEL})`);
 }
 
-module.exports = { runDream, initDream, buildDreamPrompt, parseDream, applyDream, enabled, DREAM_CRON, DREAM_MODEL };
+module.exports = { runDream, initDream, buildDreamPrompt, parseDream, applyDream, enabled, summaryEnabled, DREAM_CRON, DREAM_MODEL };

package/core/handlers.js

@@ -125,7 +125,7 @@ register({
       "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode",
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
-      "Automation: /cron /vault /soul",
+      "Automation: /cron /vault /soul /dreamsummary",
       "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
       "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
       "System: /doctor /requirements /restart /upgrade",
@@ -947,6 +947,24 @@ register({
   },
 });
 
+register({
+  name: "dreamsummary", description: "Toggle the post-dream memory summary in chat", args: "[on|off]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const dream = require("./dream");
+    const arg = (tail || "").trim().toLowerCase();
+    if (arg !== "on" && arg !== "off") {
+      const on = dream.summaryEnabled();
+      return send(`Dream summary is ${on ? "on" : "off"}.\n\nAfter each nightly memory consolidation I ${on ? "post a short summary here" : "tidy up silently"}.\n\nToggle: /dreamsummary on · /dreamsummary off`);
+    }
+    saveEnvKey("DREAM_SUMMARY", arg);
+    process.env.DREAM_SUMMARY = arg;
+    return send(arg === "on"
+      ? "Dream summary on — I'll drop a short note here after each nightly memory tidy-up. 💤"
+      : "Dream summary off — I'll consolidate memory silently. Backups are still kept, so nothing is lost.");
+  },
+});
+
 // ── Learned skills (now backed by context packs) ────────────────────
 // Skills migrated into context packs (~/.open-claudia/packs). /skills is a
 // thin window onto that store; any stragglers still in the legacy
@@ -984,6 +1002,10 @@ register({
     }
     const lines = packs.map((p) => `• ${p.dir} — ${p.description || p.name || "(no description)"}`);
     let msg = `Skills / context packs (${packs.length}):\n\n${lines.join("\n")}`;
+    const archived = packsLib.listArchived();
+    if (archived.length) {
+      msg += `\n\n${archived.length} archived (cold packs retired by the nightly dream) — open-claudia pack archived to view, pack restore <dir> to bring one back.`;
+    }
     if (legacy.length) {
       msg += `\n\n${legacy.length} legacy skill(s) still in ~/.claude/skills — run open-claudia pack migrate to fold them in.`;
     }

package/core/packs.js

@@ -70,8 +70,10 @@ function serialize(pack) {
     `created: ${pack.created || new Date().toISOString()}`,
     `updated: ${pack.updated || new Date().toISOString()}`,
     `last_used: ${pack.last_used || ""}`,
-    "---",
+    `usage_count: ${pack.usage_count || 0}`,
   );
+  if (pack.archived) fmLines.push(`archived: ${pack.archived}`);
+  fmLines.push("---");
   const sections = SECTIONS
     .map((s) => `## ${s}\n\n${(pack.sections?.[s] || "").trim()}`)
     .join("\n\n");
@@ -99,6 +101,8 @@ function readPack(dir) {
     created: fm.created || "",
     updated: fm.updated || (stat ? stat.mtime.toISOString() : ""),
     last_used: fm.last_used || "",
+    usage_count: Number(fm.usage_count || 0) || 0,
+    archived: fm.archived || "",
     sections,
   };
 }
@@ -193,10 +197,68 @@ function touchUsed(dirs) {
     const pack = readPack(dir);
     if (!pack) continue;
     pack.last_used = now;
+    pack.usage_count = (Number(pack.usage_count) || 0) + 1;
     try { writePack(pack); } catch (e) {}
   }
 }
 
+// ---------------------------------------------------------------------------
+// Lifecycle: archive stale packs to PACKS_DIR/.archived/<dir>. listPacks and
+// the FTS index skip dot-dirs, so an archived pack stops matching but the file
+// is kept and fully restorable. This is the brake on an index that only grows.
+
+const ARCHIVE_DIRNAME = ".archived";
+function archiveRoot() { return path.join(PACKS_DIR, ARCHIVE_DIRNAME); }
+
+function archivePack(nameOrDir) {
+  const pack = findPack(nameOrDir);
+  if (!pack) return null;
+  ensureDir();
+  fs.mkdirSync(archiveRoot(), { recursive: true, mode: 0o700 });
+  pack.archived = new Date().toISOString();
+  try { fs.writeFileSync(packFile(pack.dir), serialize(pack), { mode: 0o600 }); } catch (e) {}
+  const dest = path.join(archiveRoot(), pack.dir);
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.renameSync(path.join(PACKS_DIR, pack.dir), dest);
+  markIndexDirty();
+  return pack;
+}
+
+function listArchived() {
+  let entries;
+  try { entries = fs.readdirSync(archiveRoot()); } catch (e) { return []; }
+  const out = [];
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    let content;
+    try { content = fs.readFileSync(path.join(archiveRoot(), name, "PACK.md"), "utf-8"); }
+    catch (e) { continue; }
+    const { fm } = parseFrontmatter(content);
+    out.push({
+      dir: name,
+      name: fm.name || name,
+      description: fm.description || "",
+      last_used: fm.last_used || "",
+      usage_count: Number(fm.usage_count || 0) || 0,
+      archived: fm.archived || "",
+    });
+  }
+  return out.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
+function restorePack(nameOrDir) {
+  const needle = String(nameOrDir || "").trim().toLowerCase();
+  if (!needle) return null;
+  const found = listArchived().find((p) => p.dir.toLowerCase() === needle || p.name.toLowerCase() === needle);
+  if (!found) return null;
+  if (readPack(found.dir)) throw new Error(`an active pack ${found.dir} already exists`);
+  fs.renameSync(path.join(archiveRoot(), found.dir), path.join(PACKS_DIR, found.dir));
+  const pack = readPack(found.dir);
+  if (pack) { pack.archived = ""; pack.updated = new Date().toISOString(); try { writePack(pack); } catch (e) {} }
+  markIndexDirty();
+  return pack;
+}
+
 // Recognise a Write/Edit aimed at a pack file (for chat announcements).
 function packNameFromPath(filePath) {
   if (!filePath) return null;
@@ -333,4 +395,5 @@ module.exports = {
   PACKS_DIR, SECTIONS, slugify,
   listPacks, findPack, readPack, writePack, createPack, updatePack, removePack,
   touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
+  archivePack, restorePack, listArchived,
 };

package/core/system-prompt.js

@@ -291,6 +291,19 @@ const packsInjectedFor = new Map(); // `${adapterId}:${channelId}:${dir}` -> `${
 const PACK_INJECT_MAX_CHARS = 4000;
 const DEFAULT_MEMORY_RECALL_MAX_CHARS = 9000;
 
+// Progressive disclosure: when on, a matched pack is injected as a cheap
+// teaser (Stance + State + a pointer) rather than its full body. Heavy
+// reference sections (Procedure, Journal) are fetched on demand via
+// `open-claudia pack show`. Because each teaser is small we can widen the
+// match count — surface more relevant packs for the same budget and let the
+// agent decide which to read further.
+function packProgressive() {
+  return String(config.PACK_PROGRESSIVE ?? process.env.PACK_PROGRESSIVE ?? "on").toLowerCase() === "on";
+}
+function packMatchLimit() {
+  return intSetting("PACK_MATCH_LIMIT", packProgressive() ? 6 : 3);
+}
+
 function intSetting(key, fallback) {
   const raw = config[key] ?? process.env[key];
   if (raw === undefined || raw === null || raw === "") return fallback;
@@ -332,7 +345,8 @@ function consumeLastInjected() {
   return out;
 }
 
-function formatPackForContext(pack, packsLib) {
+function formatPackForContext(pack, packsLib, opts = {}) {
+  const progressive = !!opts.progressive;
   const clip = (s, n) => (s.length > n ? s.slice(0, n) + "\n…[truncated — read the full pack file]" : s);
   const parts = [`### Pack: ${pack.name} (${pack.dir})`];
   if (pack.description) parts.push(pack.description);
@@ -345,12 +359,21 @@ function formatPackForContext(pack, packsLib) {
     const childLines = children.map((c) => `- ${c.dir}: ${c.description || c.name}`).join("\n");
     parts.push(`Sub-packs (dig deeper with \`open-claudia pack show <dir>\`):\n${childLines}`);
   }
-  for (const section of ["Stance", "Procedure", "State"]) {
+  // Progressive mode injects only the live sections (Stance = how to think,
+  // State = where we are) plus a pointer; full mode also inlines Procedure
+  // and the recent Journal.
+  const sections = progressive ? ["Stance", "State"] : ["Stance", "Procedure", "State"];
+  for (const section of sections) {
     const body = (pack.sections[section] || "").trim();
     if (body) parts.push(`#### ${section}\n${body}`);
   }
-  const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
-  if (journal) parts.push(`#### Journal (recent)\n${journal}`);
+  if (progressive) {
+    const hasMore = (pack.sections.Procedure || "").trim() || (pack.sections.Journal || "").trim();
+    if (hasMore) parts.push(`#### More\nProcedure + Journal not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
+  } else {
+    const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
+    if (journal) parts.push(`#### Journal (recent)\n${journal}`);
+  }
   return clip(parts.join("\n\n"), PACK_INJECT_MAX_CHARS);
 }
 
@@ -362,6 +385,7 @@ function buildPackBlock(matches, budget) {
     const adapter = currentAdapter();
     const channelId = currentChannelId();
     const sess = state.lastSessionId || "new";
+    const progressive = packProgressive();
     const blocks = [];
     const used = [];
     for (const m of matches) {
@@ -370,13 +394,13 @@ function buildPackBlock(matches, budget) {
       used.push(m.dir);
       const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.dir}`;
       const stamp = `${sess}:${pack.updated}`;
-      // Inject a pack's full body once per (channel, session, version). A
+      // Inject a pack's body once per (channel, session, version). A
       // compaction mints a new session id, which changes the stamp and
-      // forces a fresh full re-injection on the next turn (same mechanism
+      // forces a fresh re-injection on the next turn (same mechanism
       // as the task tree), so the pack survives compaction without paying
       // to re-stamp an anchor on every intervening turn.
       if (packsInjectedFor.get(key) === stamp) continue;
-      const block = formatPackForContext(pack, packsLib);
+      const block = formatPackForContext(pack, packsLib, { progressive });
       if (!tryUseRecallBudget(budget, block)) continue;
       packsInjectedFor.set(key, stamp);
       lastInjected.packs.push(pack.name || m.dir);
@@ -536,10 +560,11 @@ async function promptWithDynamicContext(prompt, opts = {}) {
     const entitiesLib = require("./entities");
     let packMatches = [];
     let entityMatches = [];
+    const packLimit = packMatchLimit();
     try {
       packMatches = mergeMatches(
-        packsLib.matchPacks(userText, { limit: 3 }),
-        fullContext ? packsLib.matchPacks(fullContext, { limit: 3 }) : [],
+        packsLib.matchPacks(userText, { limit: packLimit }),
+        fullContext ? packsLib.matchPacks(fullContext, { limit: packLimit }) : [],
         (m) => m.dir,
       );
     } catch (e) {}
@@ -553,7 +578,7 @@ async function promptWithDynamicContext(prompt, opts = {}) {
     const candPacks = packMatches;
     const candEntities = entityMatches;
     ({ packMatches, entityMatches } = await filterMatches(userText, fullContext, packMatches, entityMatches));
-    packMatches = packMatches.slice(0, 3);
+    packMatches = packMatches.slice(0, packLimit);
     entityMatches = entityMatches.slice(0, 4);
     logRecall(userText, candPacks, candEntities, packMatches, entityMatches);
     const budget = memoryRecallBudget();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.22",
+  "version": "2.6.24",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {