@inetafrica/open-claudia 2.6.21 → 2.6.23

package/core/handlers.js

@@ -25,6 +25,7 @@ const { isNewerVersion } = require("./version");
 const jobs = require("./jobs");
 const scheduler = require("./scheduler");
 const skillsLib = require("./skills");
+const packsLib = require("./packs");
 const {
   runClaude, compactActiveSession, getActiveSessionId, effectiveCompactThreshold,
 } = require("./runner");
@@ -946,7 +947,10 @@ register({
   },
 });
 
-// ── Learned skills ──────────────────────────────────────────────────
+// ── 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
+// ~/.claude/skills dir get surfaced as a one-line migration nudge.
 
 register({
   name: "skills", description: "List, show, or remove learned skills", args: "[show|remove <name>]",
@@ -956,26 +960,35 @@ register({
     const name = rest.join(" ");
 
     if (sub === "show" && name) {
-      const skill = skillsLib.findSkill(name);
-      if (!skill) return send(`No skill named "${name}". /skills to list.`);
+      const pack = packsLib.findPack(name);
+      if (!pack) return send(`No skill named "${name}". /skills to list.`);
+      const file = path.join(packsLib.PACKS_DIR, pack.dir, "PACK.md");
       let content;
-      try { content = fs.readFileSync(skill.file, "utf-8"); } catch (e) { return send(`Could not read ${skill.file}: ${e.message}`); }
+      try { content = fs.readFileSync(file, "utf-8"); } catch (e) { return send(`Could not read ${file}: ${e.message}`); }
       const preview = content.length > 3500 ? content.slice(0, 3500) + "\n…(truncated)" : content;
       await send(preview);
-      return send(`File: ${skill.file}`);
+      return send(`File: ${file}`);
     }
 
     if (sub === "remove" && name) {
-      const skill = skillsLib.findSkill(name);
-      if (!skill) return send(`No skill named "${name}". /skills to list.`);
-      skillsLib.removeSkill(name);
-      return send(`Removed skill: ${skill.name} (${skill.file})`);
+      const pack = packsLib.findPack(name);
+      if (!pack) return send(`No skill named "${name}". /skills to list.`);
+      packsLib.removePack(pack.dir);
+      return send(`Removed skill pack: ${pack.name} (${pack.dir})`);
     }
 
-    const skills = skillsLib.listSkills();
-    if (skills.length === 0) return send("No learned skills yet. I save them automatically after complex tasks, or use /learn to capture the last piece of work.");
-    const lines = skills.map((s) => `• ${s.dir} — ${s.description || "(no description)"}`);
-    return send(`Learned skills (${skills.length}):\n\n${lines.join("\n")}\n\n/skills show <name> · /skills remove <name> · /learn [hint]`);
+    const packs = packsLib.listPacks();
+    const legacy = skillsLib.listSkills();
+    if (packs.length === 0 && legacy.length === 0) {
+      return send("No skills yet. I save them automatically as context packs after complex tasks, or use /learn to capture the last piece of work.");
+    }
+    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")}`;
+    if (legacy.length) {
+      msg += `\n\n${legacy.length} legacy skill(s) still in ~/.claude/skills — run open-claudia pack migrate to fold them in.`;
+    }
+    msg += `\n\n/skills show <name> · /skills remove <name> · /learn [hint]`;
+    return send(msg);
   },
 });
 
@@ -988,9 +1001,10 @@ register({
     const hint = tail ? ` The user's hint about what to capture: "${tail}".` : "";
     const prompt =
       `The user typed /learn: capture the most recent substantial piece of work in this conversation as a reusable skill.${hint} ` +
-      `Follow the Skill learning rules in your system prompt: check ~/.claude/skills/ first and patch an existing skill instead of duplicating; ` +
-      `otherwise write ~/.claude/skills/<kebab-name>/SKILL.md with name + a when-to-use description in the frontmatter, then prerequisites, exact commands in order, and pitfalls. ` +
-      `No secrets or tokens. When done, reply with one short line saying which skill you created or updated and what it covers. ` +
+      `Skills live in context packs (~/.open-claudia/packs/<dir>/PACK.md), NOT the legacy ~/.claude/skills dir. ` +
+      `First check the already-injected packs and 'open-claudia pack list' for a pack this work belongs to; if one fits, fold the reusable how-to into that pack's Procedure section (exact commands in order, prerequisites, pitfalls) and append a dated Journal line — edit the PACK.md directly. ` +
+      `Only if no pack fits, create a new one: 'open-claudia pack' has no create subcommand, so write ~/.open-claudia/packs/<kebab-name>/PACK.md following the four-section format (Stance, Procedure, State, Journal) with name + a when-to-use description in the frontmatter. ` +
+      `No secrets or tokens. When done, reply with one short line naming the pack you created or updated and what it covers. ` +
       `If the recent work is genuinely not reusable, say so instead of forcing a skill.`;
     await runClaude(prompt, currentState().currentSession.dir, env.messageId);
   },

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.21",
+  "version": "2.6.23",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {