@inetafrica/open-claudia 2.6.36 → 2.6.38

package/core/recall/discoverer.js

@@ -145,7 +145,7 @@ async function run(ctx) {
   // 1: pre-gate.
   if (!needsRecall(userText, seedCount)) {
     metrics.logTurn({ engine: "discoverer", query: userText, gated: true, latencyMs: Date.now() - started });
-    return { packBlock: "", entityBlock: "", packMatches: [], entityMatches: [] };
+    return { packBlock: "", entityBlock: "", packMatches: [], entityMatches: [], why: {}, gated: true };
   }
 
   // 3: spreading activation from seeds across the graph.
@@ -225,7 +225,10 @@ async function run(ctx) {
     latencyMs: Date.now() - started,
   });
 
-  return { packBlock, entityBlock, packMatches: finalPacks, entityMatches: finalEnts };
+  return {
+    packBlock, entityBlock, packMatches: finalPacks, entityMatches: finalEnts,
+    why: whyById ? Object.fromEntries(whyById) : {}, gated: false,
+  };
 }
 
 module.exports = { name: "discoverer", run, needsRecall, walk };

package/core/recall/graph.js

@@ -264,6 +264,7 @@ function parseLinks(text) {
 }
 
 function isSharedConcern(pack) {
+  if (pack && pack.kind === "ability") return true;
   const tags = (pack.tags || []).map((t) => t.toLowerCase());
   return tags.includes("shared") || tags.includes("concern") || tags.includes("cross-cutting");
 }
@@ -303,6 +304,22 @@ function syncFromCorpus(packsLib, entitiesLib) {
       const type = targetPack && isSharedConcern(targetPack) ? "governed-by" : "related";
       if (addEdge(id, target, type)) count++;
     }
+    // Abilities transfer across projects: derive governed-by edges from the
+    // ability's OWN provenance (learned_on + applied_on) so the link forms after
+    // the FIRST occurrence, without having to mutate the project packs. Direction
+    // matches the [[link]] convention — project (child) → ability (concern).
+    if (p.kind === "ability") {
+      const projects = new Set(
+        [p.learned_on, ...(p.applied_on || [])]
+          .map((x) => String(x || "").trim().toLowerCase())
+          .filter(Boolean)
+      );
+      for (const proj of projects) {
+        const src = resolve(proj);
+        if (!src || src === id) continue;
+        if (addEdge(src, id, "governed-by")) count++;
+      }
+    }
   }
   for (const e of entities) {
     const id = `entity:${e.slug}`;

package/core/recall/index.js

@@ -4,8 +4,10 @@
 // Each engine implements: async run(ctx) -> { packBlock, entityBlock,
 // packMatches, entityMatches }. The active engine is chosen per channel via
 // the `recallEngine` setting (set by the /engine slash command), falling back
-// to the RECALL_ENGINE env var, then to "classic". Unknown names fall back to
-// classic so a bad value can never break recall.
+// to the RECALL_ENGINE env var, then to DEFAULT_ENGINE. Unknown names fall
+// back to the default so a bad value can never break recall. The discoverer is
+// 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.
 
 const classic = require("./classic");
 const discoverer = require("./discoverer");
@@ -15,6 +17,11 @@ const ENGINES = {
   discoverer,
 };
 
+// The default recall engine for channels that haven't explicitly chosen one
+// (recallEngine === null). Single source of truth — flip this to change the
+// product default. `classic` remains selectable as an explicit opt-out.
+const DEFAULT_ENGINE = "discoverer";
+
 function listEngines() {
   return Object.keys(ENGINES);
 }
@@ -22,12 +29,12 @@ function listEngines() {
 function activeEngineName(settings) {
   const fromSettings = settings && settings.recallEngine;
   const fromEnv = process.env.RECALL_ENGINE;
-  const name = String(fromSettings || fromEnv || "classic").toLowerCase();
-  return ENGINES[name] ? name : "classic";
+  const name = String(fromSettings || fromEnv || DEFAULT_ENGINE).toLowerCase();
+  return ENGINES[name] ? name : DEFAULT_ENGINE;
 }
 
 function getEngine(name) {
   return ENGINES[name] || classic;
 }
 
-module.exports = { ENGINES, listEngines, activeEngineName, getEngine };
+module.exports = { ENGINES, listEngines, activeEngineName, getEngine, DEFAULT_ENGINE };

package/core/redact.js

@@ -1,15 +1,37 @@
 // Secret-redaction + terminal-control stripping. Used everywhere we ship
 // CLI output (stderr, stdout, transcripts) back to a chat surface.
 
+// Known literal secrets (operational keyring values) registered at startup
+// and whenever one is set. Matched by literal substring, not regex, so a
+// value containing regex metacharacters can't break or widen the match.
+const dynamicSecrets = new Set();
+
+// Register one or more secret literals to scrub from all future output.
+// Short values are ignored to avoid redacting common substrings.
+function registerSecrets(values) {
+  for (const v of [].concat(values || [])) {
+    const s = String(v == null ? "" : v);
+    if (s.length >= 6) dynamicSecrets.add(s);
+  }
+}
+
+function redactDynamic(text) {
+  let out = String(text);
+  for (const secret of dynamicSecrets) {
+    if (out.includes(secret)) out = out.split(secret).join("[REDACTED_SECRET]");
+  }
+  return out;
+}
+
 function redactSensitive(value) {
-  return String(value || "")
+  return redactDynamic(String(value || "")
     .replace(/sk-ant-[A-Za-z0-9._-]+/g, "[REDACTED_TOKEN]")
     .replace(/sk-proj-[A-Za-z0-9._-]+/g, "[REDACTED_OPENAI_KEY]")
     .replace(/sk-[A-Za-z0-9._-]{20,}/g, "[REDACTED_OPENAI_KEY]")
     .replace(/(Bearer\s+)[A-Za-z0-9._=-]+/gi, "$1[REDACTED_TOKEN]")
     .replace(/(CLAUDE_CODE_OAUTH_TOKEN\s*=\s*)\S+/gi, "$1[REDACTED_TOKEN]")
     .replace(/(OPENAI_API_KEY\s*=\s*)\S+/gi, "$1[REDACTED_OPENAI_KEY]")
-    .replace(/([?&](?:token|access_token|refresh_token|api_key)=)[^\s&]+/gi, "$1[REDACTED]");
+    .replace(/([?&](?:token|access_token|refresh_token|api_key)=)[^\s&]+/gi, "$1[REDACTED]"));
 }
 
 function stripTerminalControls(value) {
@@ -23,4 +45,4 @@ function extractUrls(text) {
   return [...stripTerminalControls(text).matchAll(/https?:\/\/[^\s)]+/g)].map((m) => m[0]);
 }
 
-module.exports = { redactSensitive, stripTerminalControls, extractUrls };
+module.exports = { redactSensitive, registerSecrets, stripTerminalControls, extractUrls };

package/core/runner.js

@@ -726,6 +726,16 @@ async function compactActiveSession(cwd, opts = {}) {
 
   const { fullBrief, condensed } = splitCompactionBrief(summary);
   const briefPath = archiveCompactionBrief(fullBrief, state);
+  // Append the condensed digest to today's per-day seed file so the nightly
+  // dream can review what was worked on across the day. Best-effort.
+  try {
+    require("./day-seeds").appendDaySeed({
+      summary: condensed || fullBrief,
+      project: state.currentSession ? `${state.currentSession.name} (${state.currentSession.dir})` : null,
+      channel: currentChannelId(),
+      briefPath,
+    });
+  } catch (e) {}
   // Only seed with the condensed version when the full text actually made it to disk.
   const seedSummary = (condensed && briefPath) ? condensed : (condensed ? `${fullBrief}\n\n${condensed}` : fullBrief);
   const repoFacts = collectRepoStateFacts(cwd);
@@ -881,7 +891,17 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // `open-claudia pack show <dir>` / `entity show <slug>` — so the banner
   // reflects what was read, not what was pushed. (consumeLastInjected is
   // drained here to keep the per-turn buffer from leaking into the next turn.)
-  try { require("./system-prompt").consumeLastInjected(); } catch (e) { /* best-effort */ }
+  try {
+    const injected = require("./system-prompt").consumeLastInjected();
+    if (settings.showRecall && injected && injected.recall) {
+      const r = injected.recall;
+      const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      const fmt = (arr, icon) => arr.map((x) => (x.why ? `${icon} <b>${esc(x.name)}</b> — ${esc(x.why)}` : `${icon} <b>${esc(x.name)}</b>`));
+      const lines = [...fmt(r.packs || [], "📦"), ...fmt(r.entities || [], "👤")];
+      if (lines.length) send(`🧠 <b>Recall this turn</b> (${esc(r.engine)})\n${lines.join("\n")}`).catch(() => {});
+      else if (r.gated) send(`🧠 <b>Recall</b> (${esc(r.engine)}): skipped by pre-gate — trivial turn.`).catch(() => {});
+    }
+  } catch (e) { /* best-effort */ }
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
@@ -1135,10 +1155,16 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     if (settings.budget) settings.budget = null;
     state.statusMessageId = null;
 
+    // Outcome signal: only learn from turns that actually completed. A turn that
+    // errored out is not evidence that a recalled pattern "helped" — reinforcing
+    // or recording reuse on it would teach the wrong lesson (gap: reinforcement
+    // must track "helped", not merely "opened").
+    const turnSucceeded = (code === 0 || code === null);
+
     // Hebbian co-use: nodes the agent actually opened together this turn get
     // their `related` edges reinforced, so future spreading activation pulls
     // the cluster together. Reinforce on co-USE (📖), never co-recall.
-    if (openedThisTurn.size > 0) {
+    if (turnSucceeded && openedThisTurn.size > 0) {
       try {
         const recallGraph = require("./recall/graph");
         if (openedThisTurn.size > 1) recallGraph.reinforceSet([...openedThisTurn]);
@@ -1146,6 +1172,22 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       } catch (e) { /* best-effort */ }
     }
 
+    // Close the learning loop: when an ABILITY pack is opened in the same turn
+    // as a project (context) pack, the ability was demonstrably applied while
+    // working on that project. recordCoUse grows the ability's applied_on, which
+    // forms the project→ability governed-by edge on the next structural sync —
+    // so reuse transfers AUTOMATICALLY from actual use, without waiting on the
+    // reviewer to infer it. This runs before the (async) reviewer, so it wins
+    // the race and the reviewer sees applied_on already set (no double-announce).
+    if (turnSucceeded && openedThisTurn.size > 1) {
+      try {
+        for (const t of packsLib.recordCoUse([...openedThisTurn])) {
+          notifySkill(`applied:${t.ability}:${t.project}`,
+            `🧩 Reused the "${t.abilityName}" ability on ${t.projectName} — it transfers there now too.`);
+        }
+      } catch (e) { /* best-effort */ }
+    }
+
     // Post-turn pack review: fire-and-forget on a cheap model; never
     // blocks queue drain or the next turn.
     if ((code === 0 || code === null) && assistantText.trim()) {

package/core/subagent.js

@@ -55,14 +55,30 @@ async function spawnSubagent(prompt, opts = {}) {
   }
 
   return new Promise((resolve, reject) => {
-    const args = [
-      "-p",
+    const args = ["-p"];
+    // Tool restriction. --allowedTools/--disallowedTools take variadic
+    // <tools...>, which would greedily swallow the trailing prompt arg — so we
+    // pass a single comma-joined token AND place these flags first, where the
+    // next arg (--output-format) is itself a flag, which stops the variadic.
+    // With --dangerously-skip-permissions on, a whitelist is the structural way
+    // to make a sub-agent genuinely read-only (e.g. the dream's introspection).
+    if (opts.allowedTools) args.push("--allowedTools", [].concat(opts.allowedTools).join(","));
+    if (opts.disallowedTools) args.push("--disallowedTools", [].concat(opts.disallowedTools).join(","));
+    args.push(
       "--output-format", opts.json ? "json" : "text",
       "--verbose",
       "--append-system-prompt", opts.systemPrompt || buildSubagentSystemPrompt(role),
-      "--dangerously-skip-permissions",
-    ];
+    );
+    // Permissions. A genuinely read-only sub-agent (e.g. the dream's
+    // introspection) must use plan mode — verified to be the ONLY mechanism
+    // that blocks writes: --dangerously-skip-permissions OVERRIDES both
+    // --allowedTools and --disallowedTools, so a whitelist alone does NOT
+    // restrict. Default remains skip-permissions for research sub-agents that
+    // legitimately need Bash/Write.
+    if (opts.permissionMode) args.push("--permission-mode", opts.permissionMode);
+    else args.push("--dangerously-skip-permissions");
     if (opts.model) args.push("--model", opts.model);
+    if (opts.effort) args.push("--effort", opts.effort);
     args.push(prompt);
     const env = { ...botSubprocessEnv(), ...claudeSubprocessEnv() };
     const proc = spawn(CLAUDE_PATH, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });

package/core/system-prompt.js

@@ -30,6 +30,42 @@ function buildPersonaBlock() {
   }
 }
 
+// Always-injected lessons: cross-cutting rules learned from past mistakes.
+// Unlike packs/entities these are NOT topic-gated — they load every turn
+// because the whole point is they apply when the topic ISN'T matched. They
+// are binding defaults that override generic assumptions; the (src: pack)
+// pointer is where the full context lives.
+function buildLessonsBlock() {
+  try {
+    const { loadLessonsBlock, LESSONS_FILE } = require("./lessons");
+    const block = loadLessonsBlock();
+    if (!block) return "";
+    return `\n## Lessons learned\nHard-won rules distilled from past mistakes — things you got wrong before and were corrected on. These are always loaded (unlike topic-matched packs/notes) precisely because they apply when the topic ISN'T matched. Treat them as binding defaults that override generic assumptions; before acting on one, verify against its "(src: <pack>)" pointer, which holds the full context. Edit via /lessons or ${LESSONS_FILE}.\n\n${block}\n`;
+  } catch (e) {
+    return "";
+  }
+}
+
+// Always-on skill index (Hermes Tier-1): names + descriptions of packs you've
+// flagged as reusable how-tos, so the agent knows each skill exists every turn
+// even when the topic isn't matched. The full Procedure is NOT injected here —
+// it loads on demand via `open-claudia pack show <dir>` (Tier-3 progressive
+// disclosure). Only skill-flagged packs appear; the 80+ project-tracker packs
+// stay topic-gated so this stays a short, high-signal list.
+function buildSkillIndexBlock() {
+  try {
+    const packs = require("./packs").listSkillPacks();
+    if (!packs.length) return "";
+    const lines = packs
+      .slice(0, 30)
+      .map((p) => `- ${p.name} (\`${p.dir}\`) — ${p.description || "(no description)"}`)
+      .join("\n");
+    return `\n### Skills you've learned (always available)\nVerified how-tos you've been taught and can re-run. This is the index only — before doing one, load its full steps with \`open-claudia pack show <dir>\` and follow them rather than improvising (the Procedure encodes prerequisites and pitfalls you hit before):\n\n${lines}\n`;
+  } catch (e) {
+    return "";
+  }
+}
+
 function buildSystemPrompt() {
   const state = currentState();
   const soul = loadSoul();
@@ -112,6 +148,7 @@ Keep replies clean and mobile-readable. Use short paragraphs and bullets. Avoid
   return `
 ${soul}
 ${buildPersonaBlock()}
+${buildLessonsBlock()}
 ## Runtime Context
 - Interface: ${channelLabel} chat through Open Claudia.
 - Active project path: ${state.currentSession ? state.currentSession.dir : "none"}
@@ -122,11 +159,13 @@ ${buildPersonaBlock()}
 Open Claudia learned skills are stored as context packs under ${path.join(CONFIG_DIR, "packs")}. Older \`~/.claude/skills/<name>/SKILL.md\` skills may have been migrated into packs; their reusable instructions live in the pack's Procedure section.
 
 If the user asks for a skill by name, do not rely only on the backend harness's native "Available skills" list. First use any Active context pack injected into the current request as the requested Open Claudia skill. If no matching pack was injected, inspect with \`open-claudia pack list\` / \`open-claudia pack show <dir>\` and legacy \`/skills\` paths before saying the skill does not exist.
+${buildSkillIndexBlock()}
 
 ## Stable Local Paths
 - Bot code: ${path.join(BOT_DIR, "bot.js")}
 - Soul file (identity + hard rules): ${SOUL_FILE}
 - Persona file (voice, evolved by dream): ${require("./persona").PERSONA_FILE}
+- Lessons file (always-loaded learned rules; /lessons): ${require("./lessons").LESSONS_FILE}
 - Cron config: ${CRONS_FILE}
 - Vault file: ${VAULT_FILE}
 - Bot environment: ${path.join(BOT_DIR, ".env")} (sensitive; never expose values)
@@ -349,10 +388,10 @@ function tryUseRecallBudget(budget, text) {
 // What the last promptWithDynamicContext call freshly injected (not the
 // deduped repeats) — consumed by the runner to announce recalls in chat,
 // mirroring the write-side announcements.
-let lastInjected = { packs: [], entities: [] };
+let lastInjected = { packs: [], entities: [], recall: null };
 function consumeLastInjected() {
   const out = lastInjected;
-  lastInjected = { packs: [], entities: [] };
+  lastInjected = { packs: [], entities: [], recall: null };
   return out;
 }
 
@@ -613,7 +652,7 @@ function bumpFtsMissCounter(n) {
 }
 
 async function promptWithDynamicContext(prompt, opts = {}) {
-  lastInjected = { packs: [], entities: [] };
+  lastInjected = { packs: [], entities: [], recall: null };
   try {
     const { userText, contextText } = recallMatchParts(prompt);
     let historyText = "";
@@ -633,9 +672,17 @@ async function promptWithDynamicContext(prompt, opts = {}) {
       packsLib, entitiesLib, mergeMatches, filterMatches, logRecall,
       buildPackBlock, buildEntityBlock,
     };
-    const { packBlock, entityBlock } = await engine.run({
+    const result = await engine.run({
       userText, contextText, fullContext, packLimit, budget, helpers,
     });
+    const { packBlock, entityBlock } = result;
+    const why = result.why || {};
+    lastInjected.recall = {
+      engine: engine.name || recall.activeEngineName(settings),
+      gated: !!result.gated,
+      packs: (result.packMatches || []).map((m) => ({ name: m.name || m.dir, why: why[`pack:${m.dir}`] || "" })),
+      entities: (result.entityMatches || []).map((m) => ({ name: m.name || m.slug, why: why[`entity:${m.slug}`] || "" })),
+    };
     const budgetNote = budget.omitted > 0
       ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
       : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.36",
+  "version": "2.6.38",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js"
+    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-learning-e2e.js"
   },
   "files": [
     "bot.js",
@@ -33,7 +33,15 @@
     "test-usage-accounting.js",
     "test-recall-engine.js",
     "test-recall-graph.js",
-    "test-recall-discoverer.js"
+    "test-recall-discoverer.js",
+    "test-project-transcripts-smoke.js",
+    "test-abilities.js",
+    "test-ability-extraction.js",
+    "test-ability-couse.js",
+    "test-ability-transfer.js",
+    "test-ability-tiers.js",
+    "test-ability-merge-guard.js",
+    "test-learning-e2e.js"
   ],
   "keywords": [
     "claude",

package/test-abilities.js

@@ -0,0 +1,53 @@
+// Abilities are first-class packs (kind:"ability") with reuse provenance
+// (learned_on / applied_on). Verify the frontmatter round-trips, context packs
+// stay churn-free, and the helpers behave.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "abilities-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+
+const packs = require("./core/packs");
+
+// An ability with reuse provenance.
+packs.createPack({
+  dir: "mobile-app-deploy", name: "Mobile App Deploy",
+  description: "Ship a mobile app: versionCode bump, APK, in-app updater",
+  stance: "Reusable how-to.", procedure: "1. bump 2. build 3. update",
+  kind: "ability", learned_on: "chat-mobile", applied_on: ["chat-mobile"],
+});
+let p = packs.readPack("mobile-app-deploy");
+assert.strictEqual(p.kind, "ability", "kind persists");
+assert.strictEqual(p.learned_on, "chat-mobile", "learned_on persists");
+assert.deepStrictEqual(p.applied_on, ["chat-mobile"], "applied_on persists");
+
+// A default pack is context and emits NO kind line (no churn on 121 existing packs).
+packs.createPack({ dir: "billing", name: "Billing", description: "invoices" });
+assert.strictEqual(packs.readPack("billing").kind, "context", "default kind is context");
+const raw = fs.readFileSync(path.join(process.env.PACKS_DIR, "billing", "PACK.md"), "utf-8");
+assert.ok(!/^kind:/m.test(raw), "context packs emit no kind line");
+assert.ok(!/^learned_on:/m.test(raw), "context packs emit no learned_on line");
+
+// listAbilities returns only abilities.
+assert.deepStrictEqual(packs.listAbilities().map((a) => a.dir), ["mobile-app-deploy"], "listAbilities filters to abilities");
+
+// recordApplied appends + dedupes, sets learned_on if unset.
+packs.recordApplied("mobile-app-deploy", "spaces");
+packs.recordApplied("mobile-app-deploy", "spaces");
+p = packs.readPack("mobile-app-deploy");
+assert.deepStrictEqual(p.applied_on, ["chat-mobile", "spaces"], "applied_on appends + dedupes");
+
+// setSkill promotes to always-on AND implies ability (promoted things are abilities).
+packs.createPack({ dir: "ci-verify", name: "CI Verify", description: "verify ci" });
+packs.setSkill("ci-verify", true);
+const sk = packs.readPack("ci-verify");
+assert.strictEqual(sk.skill, true, "setSkill sets skill flag");
+assert.strictEqual(sk.kind, "ability", "setSkill implies kind:ability");
+
+// setKind can demote/relabel.
+packs.setKind("ci-verify", "context");
+assert.strictEqual(packs.readPack("ci-verify").kind, "context", "setKind relabels");
+
+console.log("abilities OK — kind/learned_on/applied_on round-trip; helpers behave; context packs churn-free");

package/test-ability-couse.js

@@ -0,0 +1,68 @@
+// PROOF (closed loop / automatic transfer): when the agent actually OPENS an
+// ability pack alongside a project pack in one turn (the 📖 co-use signal),
+// recordCoUse records the application, the governed-by edge forms on the next
+// sync, and the ability becomes graph-discoverable from that project — WITHOUT
+// the reviewer inferring anything. This is the automatic feedback loop.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "ability-couse-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+
+const packs = require("./core/packs");
+const graph = require("./core/recall/graph");
+const entStub = { listEntities: () => [] };
+
+// An ability learned on spaces, plus two other project context packs it has NOT
+// been applied on yet.
+packs.createPack({
+  dir: "mobile-app-deploy", name: "Mobile App Deploy",
+  description: "Ship a mobile app: bump versionCode, build APK, push in-app updater",
+  tags: ["mobile", "deploy", "apk"], kind: "ability",
+  learned_on: "spaces", applied_on: ["spaces"], procedure: "1. bump 2. build 3. update",
+});
+packs.createPack({ dir: "spaces", name: "Spaces", description: "Spaces app" });
+packs.createPack({ dir: "chat-mobile", name: "Chat Mobile", description: "Spaces chat client" });
+packs.createPack({ dir: "billing", name: "Billing", description: "invoices" });
+
+// ── 1. CO-USE: the agent opens the ability and the chat-mobile project pack in
+//    the same turn. recordCoUse records the transfer and reports it as new.
+const transferred = packs.recordCoUse(["pack:mobile-app-deploy", "pack:chat-mobile"]);
+assert.strictEqual(transferred.length, 1, "one new transfer recorded");
+assert.strictEqual(transferred[0].ability, "mobile-app-deploy");
+assert.strictEqual(transferred[0].project, "chat-mobile");
+assert.deepStrictEqual(packs.readPack("mobile-app-deploy").applied_on, ["spaces", "chat-mobile"], "applied_on grew from real use");
+
+// Idempotent: opening them together again is not a NEW transfer (no re-announce).
+assert.strictEqual(packs.recordCoUse(["pack:mobile-app-deploy", "pack:chat-mobile"]).length, 0, "repeat co-use is not new");
+
+// Guard rails: an ability opened alone, or two context packs together, or an
+// ability + entity, record nothing.
+assert.strictEqual(packs.recordCoUse(["pack:mobile-app-deploy"]).length, 0, "ability alone records nothing");
+assert.strictEqual(packs.recordCoUse(["pack:spaces", "pack:billing"]).length, 0, "two context packs record nothing");
+assert.strictEqual(packs.recordCoUse(["pack:mobile-app-deploy", "entity:someone"]).length, 0, "ability + entity records nothing");
+assert.deepStrictEqual(packs.readPack("billing").applied_on, [], "billing never gained applied_on");
+
+if (!graph.available()) { console.log("ability co-use OK (graph asserts skipped — no node:sqlite)"); process.exit(0); }
+
+// ── 2. The edge forms from the use-grown provenance, and the ability is now
+//    discoverable from chat-mobile via the graph.
+graph.syncFromCorpus(packs, entStub);
+const edges = graph.allEdges();
+assert.ok(
+  edges.some((e) => e.src === "pack:chat-mobile" && e.dst === "pack:mobile-app-deploy" && e.type === "governed-by"),
+  "governed-by edge formed for chat-mobile from co-use"
+);
+const fromChat = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});
+assert.ok(fromChat.has("pack:mobile-app-deploy"), "ability surfaces from chat-mobile after co-use");
+
+// Negative control: billing was never co-used, so it does not surface it.
+const fromBilling = graph.expand([{ id: "pack:billing", score: 4 }], {});
+assert.ok(!fromBilling.has("pack:mobile-app-deploy"), "ability does NOT surface from an unrelated project");
+
+console.log("ability co-use OK — actual use auto-records reuse, forms the edge, transfers the ability cross-project");
+console.log("  applied_on after co-use:", packs.readPack("mobile-app-deploy").applied_on.join(", "));
+console.log("  working on chat-mobile  → graph pulls in:", [...fromChat.keys()].join(", ") || "(none)");

package/test-ability-extraction.js

@@ -0,0 +1,109 @@
+// PROOF (capture-time extraction): a reusable how-to demonstrated on ONE turn is
+// extracted by the REVIEWER into an ability pack, the project→ability link forms
+// after that FIRST occurrence (no [[link]] hand-authoring), and once the ability
+// is re-applied to a SECOND project it becomes graph-discoverable from there too.
+// Runs the real reviewer applyAction, real packs.js store, and real recall graph.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "ability-extract-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+
+const packs = require("./core/packs");
+const graph = require("./core/recall/graph");
+const review = require("./core/pack-review");
+const entStub = { listEntities: () => [] };
+
+// Two real project context packs (so learned_on/applied_on can resolve to nodes),
+// plus a negative-control project.
+packs.createPack({ dir: "spaces", name: "Spaces", description: "Spaces app", stance: "Spaces project." });
+packs.createPack({ dir: "chat-mobile", name: "Chat Mobile", description: "Spaces chat client", stance: "Chat project." });
+packs.createPack({ dir: "billing", name: "Billing", description: "invoices and payments", stance: "Billing project." });
+
+// ── 1. CAPTURE: the reviewer extracts an ability from a turn that shipped a
+//    mobile build on `spaces`. This is exactly the JSON the model is now told to
+//    emit (kind:"ability" + activity name/desc/tags + learned_on).
+const created = review.applyAction({
+  action: "create",
+  dir: "mobile-app-deploy",
+  name: "Mobile App Deploy",
+  description: "Ship a mobile app: bump versionCode, build the APK, push the in-app updater",
+  tags: ["mobile", "deploy", "apk", "versioncode", "release"],
+  kind: "ability",
+  learned_on: "spaces",
+  applied_on: ["spaces"],
+  procedure: "1. bump versionCode 2. build APK 3. push in-app updater",
+  journal: "Shipped the spaces mobile build via versionCode bump + APK + in-app updater.",
+});
+assert.strictEqual(created.kind, "create", "ability is created");
+assert.strictEqual(created.ability, true, "create result is flagged as an ability");
+assert.strictEqual(created.learned_on, "spaces", "learned_on surfaces for the chat announcement");
+
+const ability = packs.readPack("mobile-app-deploy");
+assert.strictEqual(ability.kind, "ability", "persisted as kind:ability");
+assert.strictEqual(ability.learned_on, "spaces", "learned_on persisted");
+assert.deepStrictEqual(ability.applied_on, ["spaces"], "applied_on persisted");
+
+// Activity-oriented metadata so the FIRST cross-project hit can match via FTS
+// before any edge exists (the cold-start path).
+assert.ok(/deploy|apk|versioncode/i.test(ability.description), "description is activity-oriented");
+assert.ok(ability.tags.includes("apk"), "tags carry activity terms");
+
+// The project pack was NOT mutated — no [[link]] injected, no provenance fight.
+const spacesBody = Object.values(packs.readPack("spaces").sections).join("\n");
+assert.ok(!/\[\[mobile-app-deploy\]\]/.test(spacesBody), "project pack left untouched (link is metadata-derived)");
+
+if (!graph.available()) { console.log("ability extraction OK (graph asserts skipped — no node:sqlite)"); process.exit(0); }
+
+// ── 2. LINK AFTER FIRST OCCURRENCE: syncFromCorpus derives governed-by from the
+//    ability's own provenance.
+graph.syncFromCorpus(packs, entStub);
+let edges = graph.allEdges();
+assert.ok(
+  edges.some((e) => e.src === "pack:spaces" && e.dst === "pack:mobile-app-deploy" && e.type === "governed-by"),
+  "governed-by edge formed from metadata after the first occurrence"
+);
+
+// ── 3. REUSE ON ORIGIN: working on spaces surfaces the ability.
+const fromSpaces = graph.expand([{ id: "pack:spaces", score: 4 }], {});
+assert.ok(fromSpaces.has("pack:mobile-app-deploy"), "ability surfaces from its origin project");
+
+// Negative control BEFORE reuse: an unrelated project does not pull it in.
+const billingBefore = graph.expand([{ id: "pack:billing", score: 4 }], {});
+assert.ok(!billingBefore.has("pack:mobile-app-deploy"), "unrelated project does not surface the ability");
+
+// ── 4. CROSS-PROJECT TRANSFER: a later turn re-applies the SAME ability on
+//    chat-mobile. The reviewer records it via an update with applied_on (the
+//    inferred-from-content path; the co-use signal is the automatic one).
+const reused = review.applyAction({
+  action: "update",
+  pack: "mobile-app-deploy",
+  applied_on: ["chat-mobile"],
+  journal: "Reused the mobile deploy flow to ship chat-mobile.",
+});
+assert.strictEqual(reused.appliedTo, "chat-mobile", "update records the cross-project reuse");
+assert.deepStrictEqual(packs.readPack("mobile-app-deploy").applied_on, ["spaces", "chat-mobile"], "applied_on grew");
+
+graph.syncFromCorpus(packs, entStub);
+edges = graph.allEdges();
+assert.ok(
+  edges.some((e) => e.src === "pack:chat-mobile" && e.dst === "pack:mobile-app-deploy" && e.type === "governed-by"),
+  "governed-by edge formed for the second project after reuse"
+);
+const fromChat = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});
+assert.ok(fromChat.has("pack:mobile-app-deploy"), "ability now surfaces from the second project too");
+
+// applied_on must NOT leak onto context packs (churn guard): re-applying to a
+// context pack is ignored.
+const ctxUpdate = review.applyAction({ action: "update", pack: "billing", applied_on: ["spaces"], journal: "noted" });
+assert.strictEqual(ctxUpdate.appliedTo, null, "applied_on ignored on context packs");
+assert.strictEqual(packs.readPack("billing").kind, "context", "billing stays context");
+assert.deepStrictEqual(packs.readPack("billing").applied_on, [], "context pack gains no applied_on");
+
+console.log("ability extraction OK — reviewer extracts an ability, link forms after first occurrence, transfers cross-project on reuse");
+console.log("  working on spaces      → graph pulls in:", [...fromSpaces.keys()].join(", ") || "(none)");
+console.log("  working on chat-mobile → graph pulls in:", [...fromChat.keys()].join(", ") || "(none)");
+console.log("  provenance on ability  → learned on", ability.learned_on, "| applied on", packs.readPack("mobile-app-deploy").applied_on.join(", "));