@inetafrica/open-claudia 2.6.36 → 2.6.38

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

package/test-project-transcripts-smoke.js

@@ -0,0 +1,50 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const assert = require("assert");
+const { ProjectTranscripts, normalizeProjectPath, projectHash } = require("./project-transcripts");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-transcripts-"));
+const project = path.join(tmp, "repo");
+fs.mkdirSync(project);
+
+const transcripts = new ProjectTranscripts({
+  configDir: tmp,
+  maxEntryChars: 100,
+  redact: (value) => String(value).replace(/SECRET/g, "[REDACTED]"),
+});
+
+const normalized = normalizeProjectPath(project);
+const hash = projectHash(project);
+assert.strictEqual(hash, projectHash(normalized));
+
+const result = transcripts.append({
+  role: "user",
+  text: "hello SECRET " + "x".repeat(100),
+  userId: "telegram:1",
+  chat: { transport: "telegram", id: "1" },
+  projectName: "repo",
+  projectPath: project,
+  backend: "codex",
+  sessionId: "sess-1",
+});
+
+assert.ok(result.transcriptPath.startsWith(path.join(tmp, "transcripts")));
+assert.ok(fs.existsSync(result.transcriptPath));
+const line = fs.readFileSync(result.transcriptPath, "utf8").trim();
+const entry = JSON.parse(line);
+assert.strictEqual(entry.project.path, normalized);
+// The stored hash is per-user (projectHash seeds with userId), so verify it
+// against the same user the entry was written for — not the path-only hash above.
+assert.strictEqual(entry.project.hash, projectHash(normalized, "telegram:1"));
+assert.strictEqual(entry.backend, "codex");
+assert.ok(entry.truncated);
+assert.ok(!entry.text.includes("SECRET"));
+assert.ok(entry.text.includes("[REDACTED]"));
+
+const note = transcripts.buildPointerNote(project, "repo", "telegram:1");
+assert.ok(note.includes(result.transcriptPath));
+assert.ok(note.includes("Do not read the whole file"));
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log("project-transcripts smoke OK");

package/test-recall-discoverer.js

@@ -59,6 +59,7 @@ const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEnti
   });
   assert.strictEqual(gated.packBlock, "");
   assert.strictEqual(gated.packMatches.length, 0);
+  assert.strictEqual(gated.gated, true, "gated turn flags gated:true");
   assert.strictEqual(builtPacks, null, "gated turn never builds blocks");
 
   // seeded turn: FTS hits kazee-mobile → fail-open keeps it, block rendered
@@ -69,6 +70,8 @@ const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEnti
   assert.strictEqual(out.packBlock, "PACKBLOCK");
   assert.strictEqual(out.packMatches.length, 1);
   assert.strictEqual(out.packMatches[0].dir, "kazee-mobile");
+  assert.strictEqual(out.gated, false, "seeded turn is not gated");
+  assert.strictEqual(typeof out.why, "object", "seeded turn returns a why map");
   assert.ok(builtPacks && builtPacks.some((m) => m.dir === "kazee-mobile"), "seed reached the builder");
 
   // resilient: a throwing matcher must not blow up the engine

package/test-recall-engine.js

@@ -3,18 +3,20 @@ const assert = require("assert");
 const recall = require("./core/recall");
 
 // --- selector ---
-assert.strictEqual(recall.activeEngineName({}), "classic", "default → classic");
-assert.strictEqual(recall.activeEngineName({ recallEngine: "classic" }), "classic");
-assert.strictEqual(recall.activeEngineName({ recallEngine: "nope" }), "classic", "unknown → classic");
+assert.strictEqual(recall.DEFAULT_ENGINE, "discoverer", "discoverer is the product default");
+assert.strictEqual(recall.activeEngineName({}), "discoverer", "no setting → default (discoverer)");
+assert.strictEqual(recall.activeEngineName({ recallEngine: null }), "discoverer", "null setting → default");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "classic" }), "classic", "classic still selectable as opt-out");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "nope" }), "discoverer", "unknown → default");
 assert.strictEqual(recall.activeEngineName({ recallEngine: "CLASSIC" }), "classic", "case-insensitive");
 assert.ok(recall.listEngines().includes("classic"));
 assert.strictEqual(typeof recall.getEngine("classic").run, "function");
-assert.strictEqual(recall.getEngine("bogus").name, "classic", "getEngine falls back to classic");
+assert.strictEqual(recall.getEngine("bogus").name, "classic", "getEngine hard-floor stays classic (crash-proof)");
 
 // env override when no setting
 const prev = process.env.RECALL_ENGINE;
 process.env.RECALL_ENGINE = "classic";
-assert.strictEqual(recall.activeEngineName(null), "classic");
+assert.strictEqual(recall.activeEngineName(null), "classic", "env var overrides the default when no per-channel setting");
 if (prev === undefined) delete process.env.RECALL_ENGINE; else process.env.RECALL_ENGINE = prev;
 
 // --- classic engine orchestration: calls helpers and returns their blocks ---