@inetafrica/open-claudia 2.6.37 → 2.6.38

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.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(", "));

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  "));

package/test-ability-transfer.js

@@ -0,0 +1,70 @@
+// PROOF: an ability learned while working on one project surfaces when working
+// on a DIFFERENT project — the cross-session / cross-project reuse the learning
+// system is built on. Runs against the REAL recall graph (temp db, stub corpus),
+// using the real default tunables. No reimplementation, no rigged thresholds.
+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-transfer-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+
+const graph = require("./core/recall/graph");
+if (!graph.available()) { console.log("ability transfer OK (skipped — no node:sqlite)"); process.exit(0); }
+
+// Corpus:
+//  - chat-mobile, spaces : two projects that both ship a mobile app.
+//  - billing             : a project that does NOT (negative control).
+//  - mobile-app-deploy   : a reusable ABILITY (kind:"ability") extracted from
+//                          the first deploy; records where it was learned.
+// Projects point at the ability via [[mobile-app-deploy]] in their body.
+const ABILITY_STANCE =
+  "Reusable how-to. Ship a mobile app: bump versionCode, build the APK, push the in-app updater. learned_on: chat-mobile (2026-06).";
+const packsStub = {
+  listPacks: () => [
+    { dir: "chat-mobile", name: "Chat Mobile", tags: [], parent: null,
+      sections: { Stance: "Spaces chat client. Ship via [[mobile-app-deploy]].", Procedure: "", State: "", Journal: "" } },
+    { dir: "spaces", name: "Spaces", tags: [], parent: null,
+      sections: { Stance: "Spaces app. Releases follow [[mobile-app-deploy]].", Procedure: "", State: "", Journal: "" } },
+    { dir: "billing", name: "Billing", tags: [], parent: null,
+      sections: { Stance: "Invoices and payments. No mobile build.", Procedure: "", State: "", Journal: "" } },
+    { dir: "mobile-app-deploy", name: "Mobile App Deploy", tags: [], parent: null, kind: "ability",
+      sections: { Stance: ABILITY_STANCE, Procedure: "1. bump versionCode 2. build APK 3. in-app updater", State: "", Journal: "" } },
+  ],
+};
+const entStub = { listEntities: () => [] };
+
+// Structural sync derives governed-by edges from [[links]] → shared concern.
+graph.syncFromCorpus(packsStub, 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"),
+  "chat-mobile is governed-by the ability");
+assert.ok(edges.some((e) => e.src === "pack:spaces" && e.dst === "pack:mobile-app-deploy" && e.type === "governed-by"),
+  "spaces is governed-by the ability");
+
+// THE PROOF: working on `spaces` — a project the ability was NOT learned on —
+// surfaces the ability via spreading activation (default tunables, no rigging).
+const fromSpaces = graph.expand([{ id: "pack:spaces", score: 4 }], {});
+assert.ok(fromSpaces.has("pack:mobile-app-deploy"),
+  "ability surfaces when working on spaces (cross-project reuse)");
+
+// It also surfaces from its origin project, and even for a weak seed.
+const fromChat = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});
+assert.ok(fromChat.has("pack:mobile-app-deploy"), "ability surfaces from its origin project");
+const weakSeed = graph.expand([{ id: "pack:spaces", score: 1 }], {});
+assert.ok(weakSeed.has("pack:mobile-app-deploy"), "surfaces even for a weak seed (threshold scales with seed)");
+
+// Negative control: an unrelated project does NOT pull the ability in.
+const fromBilling = graph.expand([{ id: "pack:billing", score: 4 }], {});
+assert.ok(!fromBilling.has("pack:mobile-app-deploy"),
+  "unlinked project does NOT surface the ability (it's the link doing the work, not noise)");
+
+// Provenance lives on the ability node itself, ready to show the user.
+assert.ok(/learned_on:\s*chat-mobile/.test(ABILITY_STANCE), "ability records where it was learned");
+
+console.log("ability transfer OK — a learned-once pattern surfaces across projects");
+console.log("  working on spaces  → graph pulls in:", [...fromSpaces.keys()].join(", ") || "(none)");
+console.log("  working on chat     → graph pulls in:", [...fromChat.keys()].join(", ") || "(none)");
+console.log("  working on billing  → graph pulls in:", [...fromBilling.keys()].join(", ") || "(none)");
+console.log("  provenance on ability:", ABILITY_STANCE.match(/learned_on:[^.]*/)[0]);

package/test-learning-e2e.js

@@ -0,0 +1,98 @@
+// CAPSTONE PROOF of the goal: "feel like it remembers and reuses ideas/patterns/
+// abilities across sessions and projects, like it is learning and improving."
+// One narrative walks the WHOLE lifecycle against real code — reviewer extraction,
+// FTS router, recall graph, the co-use loop, and the dream — no reimplementation.
+//
+//   Stage 1  capture      — a reusable how-to done on project A is extracted into an ability
+//   Stage 2  recall@home  — the ability is linked to A and surfaces while working on A
+//   Stage 3  cold-start   — on a BRAND-NEW project B it surfaces by ACTIVITY (FTS), no edge yet
+//   Stage 4  transfer     — using it on B records reuse, the edge forms, B now surfaces it via the graph
+//   Stage 5  graduation   — once reused widely, the dream promotes it to always-on
+//   Stage 6  provenance   — it can always say where it was learned and where it has been applied
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "learning-e2e-"));
+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 dream = require("./core/dream");
+const entStub = { listEntities: () => [] };
+const haveGraph = graph.available();
+
+// Three real projects exist as context packs over time.
+packs.createPack({ dir: "spaces", name: "Spaces", description: "the Spaces web+mobile app" });
+packs.createPack({ dir: "chat-mobile", name: "Chat Mobile", description: "the Spaces chat client" });
+packs.createPack({ dir: "field-app", name: "Field App", description: "the field-ops companion app" });
+
+// reindex() returns false when node:sqlite is unavailable — use it as the FTS gate.
+const haveFts = packs.reindex();
+
+// ── Stage 1: CAPTURE. A turn ships a mobile build on `spaces`; the reviewer
+//    extracts the reusable how-to as an ability with activity-oriented metadata.
+const cap = 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.",
+});
+assert.ok(cap.ability && cap.learned_on === "spaces", "Stage 1: ability captured, learned on spaces");
+
+if (haveFts) packs.reindex();
+if (haveGraph) graph.syncFromCorpus(packs, entStub);
+
+// ── Stage 2: RECALL AT HOME. Link formed; working on spaces surfaces it.
+if (haveGraph) {
+  const fromSpaces = graph.expand([{ id: "pack:spaces", score: 4 }], {});
+  assert.ok(fromSpaces.has("pack:mobile-app-deploy"), "Stage 2: ability surfaces on its origin project");
+}
+
+// ── Stage 3: COLD-START on a NEW project. No graph edge to chat-mobile yet, but
+//    the ability is discoverable by the WORK being done (activity-term FTS) — the
+//    crucial "I've done something like this before" moment in a new context.
+if (haveGraph) {
+  const fromChatNoEdge = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});
+  assert.ok(!fromChatNoEdge.has("pack:mobile-app-deploy"), "Stage 3: no graph edge to the new project yet");
+}
+if (haveFts) {
+  const hits = packs.matchPacks("ship the chat mobile app: bump versionCode and build the apk", { limit: 5 });
+  assert.ok(hits.some((h) => h.dir === "mobile-app-deploy"),
+    "Stage 3: ability surfaces in a brand-new project via activity match, before any edge");
+}
+
+// ── Stage 4: TRANSFER ON USE. The agent opens the ability + chat-mobile together
+//    (the co-use signal). recordCoUse grows applied_on, the edge forms on sync,
+//    and chat-mobile now surfaces it through the graph too.
+const transferred = packs.recordCoUse(["pack:mobile-app-deploy", "pack:chat-mobile"]);
+assert.deepStrictEqual(transferred.map((t) => t.project), ["chat-mobile"], "Stage 4: reuse recorded from real use");
+assert.deepStrictEqual(packs.readPack("mobile-app-deploy").applied_on, ["spaces", "chat-mobile"], "Stage 4: applied_on grew");
+if (haveGraph) {
+  graph.syncFromCorpus(packs, entStub);
+  const fromChat = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});
+  assert.ok(fromChat.has("pack:mobile-app-deploy"), "Stage 4: new project now surfaces it via the graph");
+}
+
+// ── Stage 5: GRADUATION. Reused on a third project, the dream promotes it to the
+//    always-on tier so it is offered everywhere, not just on matched projects.
+packs.recordCoUse(["pack:mobile-app-deploy", "pack:field-app"]);
+assert.strictEqual(packs.readPack("mobile-app-deploy").applied_on.length, 3, "Stage 5: applied across three projects");
+const tierLines = dream.manageAbilityTiers();
+assert.strictEqual(packs.readPack("mobile-app-deploy").skill, true, "Stage 5: dream promoted it to always-on");
+assert.ok(tierLines.some((l) => /Promoted .*Mobile App Deploy/.test(l)), "Stage 5: promotion announced");
+assert.ok(packs.listSkillPacks().some((p) => p.dir === "mobile-app-deploy"), "Stage 5: now in the always-on skill index");
+
+// ── Stage 6: PROVENANCE. It can always say where it was learned and applied.
+const ab = packs.readPack("mobile-app-deploy");
+assert.strictEqual(ab.learned_on, "spaces", "Stage 6: remembers where it was learned");
+assert.deepStrictEqual(ab.applied_on, ["spaces", "chat-mobile", "field-app"], "Stage 6: remembers everywhere it transferred");
+
+const skips = [!haveGraph && "graph", !haveFts && "fts"].filter(Boolean);
+console.log(`learning E2E OK — capture → recall → cold-start → transfer → graduation → provenance${skips.length ? `  (skipped: ${skips.join(", ")} — no node:sqlite)` : ""}`);
+console.log("  learned on:", ab.learned_on, "| applied on:", ab.applied_on.join(", "), "| always-on:", ab.skill);