@inetafrica/open-claudia 2.6.37 → 2.6.39

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);
@@ -784,7 +794,21 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     resumeSessionId: opts.resumeSessionId || null,
   }, state, getActiveSessionId);
 
-  if (adapter && channelId) adapter.typing(channelId).catch(() => {});
+  // Typing heartbeat: keep the indicator alive continuously from message
+  // receipt through the recall/discoverer phase and into streaming, not just
+  // for the ~5s a single typing action lasts. Stored on state so /stop can
+  // clear it instantly. Cleared on close/error/cancel.
+  const startTyping = () => {
+    if (!adapter || !channelId) return;
+    adapter.typing(channelId).catch(() => {});
+    if (!state.typingHeartbeat) state.typingHeartbeat = setInterval(() => adapter.typing(channelId).catch(() => {}), 4000);
+  };
+  const stopTyping = () => { if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; } };
+  // Pre-spawn window (recall/compaction/auth): /stop has no process to kill, so
+  // it sets state.cancelRequested and we bail at the checkpoint before spawning.
+  state.preparingRun = true;
+  state.cancelRequested = false;
+  startTyping();
   state.statusMessageId = null;
   state.streamBuffer = "";
   let assistantText = "";
@@ -873,7 +897,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
-  const args = await buildClaudeArgs(prompt, opts);
+  let args;
+  try {
+    args = await buildClaudeArgs(prompt, opts);
+  } catch (e) {
+    state.preparingRun = false;
+    stopTyping();
+    throw e;
+  }
   // Recall announcements are now fired at READ time, not injection time:
   // matched packs/entities enter context only as small headlines (see
   // system-prompt.js recallHeadline). The "📖 Recalled my notes on …" line is
@@ -892,6 +923,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       else if (r.gated) send(`🧠 <b>Recall</b> (${esc(r.engine)}): skipped by pre-gate — trivial turn.`).catch(() => {});
     }
   } catch (e) { /* best-effort */ }
+  // /stop landed during the pre-spawn window (recall/compaction): bail before
+  // spawning. The /stop handler already acknowledged in chat, so stay silent.
+  if (state.cancelRequested) {
+    state.cancelRequested = false;
+    state.preparingRun = false;
+    stopTyping();
+    return;
+  }
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
@@ -901,6 +940,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   state.runningProcess = proc;
+  state.preparingRun = false;
   const startTime = Date.now();
   let longRunningNotified = false;
 
@@ -1084,6 +1124,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("close", (code) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval); state.streamInterval = null;
     clearTimeout(processTimeout);
 
@@ -1145,10 +1187,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]);
@@ -1156,6 +1204,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()) {
@@ -1208,6 +1272,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("error", (err) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval);
     clearTimeout(processTimeout);
     await send(`Error: ${err.message}`);

package/core/state.js

@@ -59,6 +59,9 @@ function createUserState(userId) {
     channelId: currentChannelId(),
     currentSession: saved.currentSession || null,
     runningProcess: null,
+    preparingRun: false,
+    cancelRequested: false,
+    typingHeartbeat: null,
     statusMessageId: null,
     streamBuffer: "",
     streamInterval: null,

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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.37",
+  "version": "2.6.39",
   "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(", "));

package/test-ability-merge-guard.js

@@ -0,0 +1,42 @@
+// PROOF (dream merge safety): the dream must never merge across the
+// ability/context boundary — that would either lose a reusable how-to or
+// pollute it with one project's specifics. Abilities merge only into abilities.
+// Exercises the real applyDream merge path.
+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-merge-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+const backup = path.join(tmp, "backup");
+
+const packs = require("./core/packs");
+const dream = require("./core/dream");
+
+// reach 1 + not-skill so the deterministic tier pass leaves them alone.
+packs.createPack({ dir: "deploy-flow", name: "Deploy Flow", description: "reusable deploy", kind: "ability", applied_on: ["x"] });
+packs.createPack({ dir: "spaces", name: "Spaces", description: "the spaces project" });
+
+// ── Cross-boundary merge (ability → context) must be REFUSED.
+let decision = dream.parseDream(JSON.stringify({ merges: [{ into: "spaces", from: ["deploy-flow"], journal: "merge" }] }));
+let lines = dream.applyDream(decision, backup);
+assert.ok(packs.readPack("deploy-flow"), "ability was NOT removed by a cross-boundary merge");
+assert.strictEqual(packs.readPack("deploy-flow").kind, "ability", "ability stays an ability");
+assert.strictEqual(packs.readPack("spaces").kind, "context", "project pack stays context");
+assert.ok(lines.some((l) => /Skipped merge into spaces/.test(l)), "cross-boundary merge announced as skipped");
+
+// ── Context → ability is equally refused.
+decision = dream.parseDream(JSON.stringify({ merges: [{ into: "deploy-flow", from: ["spaces"], journal: "merge" }] }));
+lines = dream.applyDream(decision, backup);
+assert.ok(packs.readPack("spaces"), "context pack was NOT absorbed into an ability");
+
+// ── Ability → ability IS allowed (the merged result stays an ability).
+packs.createPack({ dir: "deploy-old", name: "Deploy Old", description: "older deploy notes", kind: "ability", applied_on: ["y"] });
+decision = dream.parseDream(JSON.stringify({ merges: [{ into: "deploy-flow", from: ["deploy-old"], journal: "consolidated deploy notes" }] }));
+lines = dream.applyDream(decision, backup);
+assert.ok(!packs.readPack("deploy-old"), "duplicate ability was absorbed");
+assert.strictEqual(packs.readPack("deploy-flow").kind, "ability", "merged result stays an ability");
+assert.ok(lines.some((l) => /Merged deploy-old into deploy-flow/.test(l)), "ability→ability merge applied");
+
+console.log("ability merge guard OK — abilities never merge with project packs; ability→ability merges still work");

package/test-ability-tiers.js

@@ -0,0 +1,57 @@
+// PROOF (dream tier management): the nightly dream PROMOTES an ability that has
+// transferred across enough projects to the always-on skill index, and eases a
+// cold, never-spread always-on ability back to the match-gated pool — both
+// deterministic from reuse breadth, both reversible. Uses the real packs store.
+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-tiers-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+// Make "cold" instant so the demote path is exercisable without backdating files.
+process.env.DREAM_ARCHIVE_IDLE_DAYS = "0";
+
+const packs = require("./core/packs");
+const dream = require("./core/dream");
+assert.strictEqual(dream.PROMOTE_MIN_PROJECTS, 3, "default promote threshold is 3 projects");
+
+// Broadly-reused ability (3 projects) — should PROMOTE to always-on.
+packs.createPack({
+  dir: "broad-ability", name: "Broad Ability", description: "transfers everywhere",
+  kind: "ability", learned_on: "a", applied_on: ["a", "b", "c"],
+});
+// Narrowly-used ability (2 projects) — stays match-gated, no promotion yet.
+packs.createPack({
+  dir: "narrow-ability", name: "Narrow Ability", description: "two projects so far",
+  kind: "ability", learned_on: "a", applied_on: ["a", "b"],
+});
+// A once-promoted always-on ability that never spread (reach 0) and is cold —
+// should DEMOTE back to match-gated (still an ability).
+packs.createPack({ dir: "cold-skill", name: "Cold Skill", description: "no longer earning its slot", kind: "ability" });
+packs.setSkill("cold-skill", true);
+assert.strictEqual(packs.readPack("cold-skill").skill, true, "cold-skill starts always-on");
+
+const lines = dream.manageAbilityTiers();
+
+// Promotion happened.
+assert.strictEqual(packs.readPack("broad-ability").skill, true, "broad ability promoted to always-on");
+assert.strictEqual(packs.readPack("broad-ability").kind, "ability", "promotion keeps it an ability");
+assert.ok(lines.some((l) => /Promoted .*Broad Ability/.test(l)), "promotion announced");
+
+// No premature promotion.
+assert.strictEqual(packs.readPack("narrow-ability").skill, false, "narrow ability NOT promoted (only 2 projects)");
+
+// Demotion happened, but it stays an ability (match-gated), not archived.
+assert.strictEqual(packs.readPack("cold-skill").skill, false, "cold skill eased out of always-on");
+assert.strictEqual(packs.readPack("cold-skill").kind, "ability", "demotion keeps it an ability (still findable)");
+assert.ok(packs.listAbilities().some((a) => a.dir === "cold-skill"), "demoted ability remains in the ability pool");
+assert.ok(lines.some((l) => /Eased .*Cold Skill/.test(l)), "demotion announced");
+
+// Idempotent: a second pass makes no further changes (broad now skill+reach3 so
+// not eligible for demote; cold now not-skill so not eligible for either).
+const second = dream.manageAbilityTiers();
+assert.strictEqual(second.length, 0, "second pass is a no-op");
+
+console.log("ability tiers OK — broad reuse promotes to always-on; cold/never-spread eases out; both reversible, idempotent");
+console.log("  " + lines.join("\n  "));