@inetafrica/open-claudia 2.6.32 → 2.6.34

package/core/system-prompt.js

@@ -304,6 +304,17 @@ function packMatchLimit() {
   return intSetting("PACK_MATCH_LIMIT", packProgressive() ? 6 : 3);
 }
 
+// Pull model: when on, a matched pack/entity is injected as a *headline*
+// (description + Stance for packs, description for entities) plus a pointer.
+// The heavier sections (State/Procedure/Journal, entity Notes/Log) are NOT
+// pushed — the agent decides which packs are worth a real read and pulls them
+// on demand via `open-claudia pack show <dir>` / `entity show <slug>`. This is
+// what makes the "📖 Recalled my notes on …" banner mean "what I actually
+// read" (fired at read time in the runner) instead of "what got pushed at me".
+function recallHeadline() {
+  return String(config.RECALL_HEADLINE ?? process.env.RECALL_HEADLINE ?? "on").toLowerCase() === "on";
+}
+
 function intSetting(key, fallback) {
   const raw = config[key] ?? process.env[key];
   if (raw === undefined || raw === null || raw === "") return fallback;
@@ -346,6 +357,7 @@ function consumeLastInjected() {
 }
 
 function formatPackForContext(pack, packsLib, opts = {}) {
+  const headline = !!opts.headline;
   const progressive = !!opts.progressive;
   const clip = (s, n) => (s.length > n ? s.slice(0, n) + "\n…[truncated — read the full pack file]" : s);
   const parts = [`### Pack: ${pack.name} (${pack.dir})`];
@@ -362,12 +374,22 @@ function formatPackForContext(pack, packsLib, opts = {}) {
   // Progressive mode injects only the live sections (Stance = how to think,
   // State = where we are) plus a pointer; full mode also inlines Procedure
   // and the recent Journal.
-  const sections = progressive ? ["Stance", "State"] : ["Stance", "Procedure", "State"];
+  // Headline = description + Stance only (Stance carries hard rules/prefs that
+  // must always apply when the topic comes up). Everything else is pulled on
+  // demand. Progressive = Stance + State. Full = Stance + Procedure + State.
+  const sections = headline
+    ? ["Stance"]
+    : progressive
+    ? ["Stance", "State"]
+    : ["Stance", "Procedure", "State"];
   for (const section of sections) {
     const body = (pack.sections[section] || "").trim();
     if (body) parts.push(`#### ${section}\n${body}`);
   }
-  if (progressive) {
+  if (headline) {
+    const hidden = ["State", "Procedure", "Journal"].filter((s) => (pack.sections[s] || "").trim());
+    if (hidden.length) parts.push(`#### More\n${hidden.join(" + ")} not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
+  } else if (progressive) {
     const hasMore = (pack.sections.Procedure || "").trim() || (pack.sections.Journal || "").trim();
     if (hasMore) parts.push(`#### More\nProcedure + Journal not shown — run \`open-claudia pack show ${pack.dir}\` to read them.`);
   } else {
@@ -386,6 +408,7 @@ function buildPackBlock(matches, budget) {
     const channelId = currentChannelId();
     const sess = state.lastSessionId || "new";
     const progressive = packProgressive();
+    const headline = recallHeadline();
     const blocks = [];
     const used = [];
     for (const m of matches) {
@@ -400,7 +423,7 @@ function buildPackBlock(matches, budget) {
       // as the task tree), so the pack survives compaction without paying
       // to re-stamp an anchor on every intervening turn.
       if (packsInjectedFor.get(key) === stamp) continue;
-      const block = formatPackForContext(pack, packsLib, { progressive });
+      const block = formatPackForContext(pack, packsLib, { progressive, headline });
       if (!tryUseRecallBudget(budget, block)) continue;
       packsInjectedFor.set(key, stamp);
       lastInjected.packs.push(pack.name || m.dir);
@@ -408,7 +431,10 @@ function buildPackBlock(matches, budget) {
     }
     if (used.length > 0) setImmediate(() => { try { packsLib.touchUsed(used); } catch (e) {} });
     if (blocks.length === 0) return "";
-    return `\n\n## Active Open Claudia skills / context packs\nLong-term topic context auto-matched to this message. If the user asked for a skill by name, treat the matching pack's Procedure section as that Open Claudia skill. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.\n\n${blocks.join("\n\n---\n\n")}`;
+    const intro = headline
+      ? `Long-term topic context auto-matched to this message — these are *headlines* (description + Stance only), not full packs. Decide which are actually relevant and pull the full State/Procedure/Journal on demand with \`open-claudia pack show <dir>\`. If the user asked for a skill by name, \`pack show\` the matching pack to load its Procedure. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.`
+      : `Long-term topic context auto-matched to this message. If the user asked for a skill by name, treat the matching pack's Procedure section as that Open Claudia skill. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.`;
+    return `\n\n## Active Open Claudia skills / context packs\n${intro}\n\n${blocks.join("\n\n---\n\n")}`;
   } catch (e) {
     return "";
   }
@@ -420,14 +446,23 @@ function buildPackBlock(matches, budget) {
 const entitiesInjectedFor = new Map(); // `${adapterId}:${channelId}:${slug}` -> `${sessionId}:${updated}`
 const ENTITY_INJECT_MAX_CHARS = 1200;
 
-function formatEntityForContext(ent) {
+function formatEntityForContext(ent, opts = {}) {
+  const headline = !!opts.headline;
+  const slug = opts.slug || ent.slug;
   const clip = (s, n) => (s.length > n ? s.slice(0, n) + "\n…[truncated — read the full entity file]" : s);
   const head = `### ${ent.name} (${ent.type}${ent.aliases.length ? `, aka ${ent.aliases.join(", ")}` : ""})`;
   const parts = [head];
   if (ent.description) parts.push(ent.description);
-  if (ent.sections.Notes) parts.push(ent.sections.Notes);
-  const log = ent.sections.Log.split("\n").filter(Boolean).slice(-4).join("\n");
-  if (log) parts.push(`Recent:\n${log}`);
+  if (headline) {
+    const hidden = [];
+    if ((ent.sections.Notes || "").trim()) hidden.push("Notes");
+    if ((ent.sections.Log || "").trim()) hidden.push("Log");
+    if (hidden.length) parts.push(`${hidden.join(" + ")} not shown — run \`open-claudia entity show ${slug}\` to read them.`);
+  } else {
+    if (ent.sections.Notes) parts.push(ent.sections.Notes);
+    const log = ent.sections.Log.split("\n").filter(Boolean).slice(-4).join("\n");
+    if (log) parts.push(`Recent:\n${log}`);
+  }
   return clip(parts.join("\n\n"), ENTITY_INJECT_MAX_CHARS);
 }
 
@@ -448,7 +483,7 @@ function buildEntityBlock(matches, budget) {
       const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.slug}`;
       const stamp = `${sess}:${ent.updated}`;
       if (entitiesInjectedFor.get(key) === stamp) continue;
-      const block = formatEntityForContext(ent);
+      const block = formatEntityForContext(ent, { headline: recallHeadline(), slug: m.slug });
       if (!tryUseRecallBudget(budget, block)) continue;
       entitiesInjectedFor.set(key, stamp);
       lastInjected.entities.push(ent.name || m.slug);
@@ -456,7 +491,10 @@ function buildEntityBlock(matches, budget) {
     }
     if (seen.length > 0) setImmediate(() => { try { entitiesLib.touchSeen(seen); } catch (e) {} });
     if (blocks.length === 0) return "";
-    return `\n\n## Known entities\nMemory notes on people/places/projects auto-matched to this message. Source files live under ${entitiesLib.ENTITIES_DIR}/<slug>.md — read or edit them directly to correct or deepen.\n\n${blocks.join("\n\n---\n\n")}`;
+    const intro = recallHeadline()
+      ? `Memory notes on people/places/projects auto-matched to this message — headlines only (description + a pointer). Pull a full note's Notes/Log on demand with \`open-claudia entity show <slug>\`. Source files live under ${entitiesLib.ENTITIES_DIR}/<slug>.md — read or edit them directly to correct or deepen.`
+      : `Memory notes on people/places/projects auto-matched to this message. Source files live under ${entitiesLib.ENTITIES_DIR}/<slug>.md — read or edit them directly to correct or deepen.`;
+    return `\n\n## Known entities\n${intro}\n\n${blocks.join("\n\n---\n\n")}`;
   } catch (e) {
     return "";
   }
@@ -585,32 +623,19 @@ async function promptWithDynamicContext(prompt, opts = {}) {
     const fullContext = [contextText, historyText].filter(Boolean).join("\n\n");
     const packsLib = require("./packs");
     const entitiesLib = require("./entities");
-    let packMatches = [];
-    let entityMatches = [];
     const packLimit = packMatchLimit();
-    try {
-      packMatches = mergeMatches(
-        packsLib.matchPacks(userText, { limit: packLimit }),
-        fullContext ? packsLib.matchPacks(fullContext, { limit: packLimit }) : [],
-        (m) => m.dir,
-      );
-    } catch (e) {}
-    try {
-      entityMatches = mergeMatches(
-        entitiesLib.matchEntities(userText, { limit: 4 }),
-        fullContext ? entitiesLib.matchEntities(fullContext, { limit: 4 }) : [],
-        (m) => m.slug,
-      );
-    } catch (e) {}
-    const candPacks = packMatches;
-    const candEntities = entityMatches;
-    ({ packMatches, entityMatches } = await filterMatches(userText, fullContext, packMatches, entityMatches));
-    packMatches = packMatches.slice(0, packLimit);
-    entityMatches = entityMatches.slice(0, 4);
-    logRecall(userText, candPacks, candEntities, packMatches, entityMatches);
     const budget = memoryRecallBudget();
-    const packBlock = buildPackBlock(packMatches, budget);
-    const entityBlock = buildEntityBlock(entityMatches, budget);
+    let settings = {};
+    try { settings = currentState().settings || {}; } catch (e) {}
+    const recall = require("./recall");
+    const engine = recall.getEngine(recall.activeEngineName(settings));
+    const helpers = {
+      packsLib, entitiesLib, mergeMatches, filterMatches, logRecall,
+      buildPackBlock, buildEntityBlock,
+    };
+    const { packBlock, entityBlock } = await engine.run({
+      userText, contextText, fullContext, packLimit, budget, helpers,
+    });
     const budgetNote = budget.omitted > 0
       ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
       : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.32",
+  "version": "2.6.34",
   "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"
+    "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"
   },
   "files": [
     "bot.js",
@@ -30,7 +30,10 @@
     ".env.example",
     "README.md",
     "CHANGELOG.md",
-    "test-usage-accounting.js"
+    "test-usage-accounting.js",
+    "test-recall-engine.js",
+    "test-recall-graph.js",
+    "test-recall-discoverer.js"
   ],
   "keywords": [
     "claude",

package/test-recall-discoverer.js

@@ -0,0 +1,83 @@
+// Discoverer engine: pre-gate, seed → (graph) → fail-open injection. The LLM
+// walker is disabled here (RECALL_DISCOVERER_WALKER=off) so the engine takes
+// its deterministic fail-open path: keep user-origin seeds, drop guesses.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-disc-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+process.env.RECALL_DISCOVERER_WALKER = "off";
+process.env.RECALL_METRICS = "off";
+
+const disc = require("./core/recall/discoverer");
+
+// --- pre-gate ---
+assert.strictEqual(disc.needsRecall("", 0), false, "empty → no recall");
+assert.strictEqual(disc.needsRecall("thanks", 0), false, "pleasantry → no recall");
+assert.strictEqual(disc.needsRecall("ok", 0), false, "terse ack → no recall");
+assert.strictEqual(disc.needsRecall("yo", 0), false, "two words, no seeds → no recall");
+assert.strictEqual(disc.needsRecall("how do I deploy the mobile app", 0), true, "substantive → recall");
+assert.strictEqual(disc.needsRecall("k", 5), true, "seeds present always recall");
+
+// --- shared stub corpus + helpers ---
+const packs = {
+  "kazee-mobile": { dir: "kazee-mobile", name: "Kazee Mobile", description: "the app",
+    parent: "kazee", tags: [], sections: { Stance: "lime", Procedure: "", State: "", Journal: "" } },
+  "kazee-theme": { dir: "kazee-theme", name: "Kazee Theme", description: "palette",
+    parent: null, tags: ["shared"], sections: { Stance: "lime palette", Procedure: "", State: "", Journal: "" } },
+};
+const packsLib = {
+  matchPacks: (text) => /mobile/.test(text) ? [{ dir: "kazee-mobile", name: "Kazee Mobile", score: 4 }] : [],
+  readPack: (dir) => packs[dir] || null,
+  listPacks: () => Object.values(packs),
+  PACKS_DIR: tmp,
+};
+const entitiesLib = {
+  matchEntities: () => [],
+  readEntity: () => null,
+  listEntities: () => [],
+  ENTITIES_DIR: tmp,
+};
+const mergeMatches = (primary, secondary, keyOf) => {
+  const out = primary.map((m) => ({ ...m, origin: "user" }));
+  const seen = new Set(primary.map(keyOf));
+  for (const m of secondary) if (!seen.has(keyOf(m))) out.push({ ...m, origin: "context" });
+  return out;
+};
+let builtPacks = null;
+const buildPackBlock = (matches) => { builtPacks = matches; return matches.length ? "PACKBLOCK" : ""; };
+const buildEntityBlock = (matches) => (matches.length ? "ENTITYBLOCK" : "");
+const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEntityBlock };
+
+(async () => {
+  // gated turn: trivial text, no seeds → empty result, builders not called
+  builtPacks = null;
+  const gated = await disc.run({
+    userText: "ok", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(gated.packBlock, "");
+  assert.strictEqual(gated.packMatches.length, 0);
+  assert.strictEqual(builtPacks, null, "gated turn never builds blocks");
+
+  // seeded turn: FTS hits kazee-mobile → fail-open keeps it, block rendered
+  const out = await disc.run({
+    userText: "help with the mobile app", contextText: "", fullContext: "help with the mobile app",
+    packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(out.packBlock, "PACKBLOCK");
+  assert.strictEqual(out.packMatches.length, 1);
+  assert.strictEqual(out.packMatches[0].dir, "kazee-mobile");
+  assert.ok(builtPacks && builtPacks.some((m) => m.dir === "kazee-mobile"), "seed reached the builder");
+
+  // resilient: a throwing matcher must not blow up the engine
+  const out2 = await disc.run({
+    userText: "deploy something substantive please", contextText: "", fullContext: "",
+    packLimit: 6, budget: {},
+    helpers: { ...helpers, packsLib: { ...packsLib, matchPacks: () => { throw new Error("boom"); } } },
+  });
+  assert.strictEqual(typeof out2.packBlock, "string");
+
+  console.log("recall discoverer OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-recall-engine.js

@@ -0,0 +1,54 @@
+// Recall engine selector + classic-engine smoke tests.
+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.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");
+
+// env override when no setting
+const prev = process.env.RECALL_ENGINE;
+process.env.RECALL_ENGINE = "classic";
+assert.strictEqual(recall.activeEngineName(null), "classic");
+if (prev === undefined) delete process.env.RECALL_ENGINE; else process.env.RECALL_ENGINE = prev;
+
+// --- classic engine orchestration: calls helpers and returns their blocks ---
+(async () => {
+  const calls = [];
+  const helpers = {
+    packsLib: { matchPacks: () => [{ dir: "p1", name: "P1" }] },
+    entitiesLib: { matchEntities: () => [{ slug: "e1", name: "E1" }] },
+    mergeMatches: (a, b) => { calls.push("merge"); return a.map((m) => ({ ...m, origin: "user" })); },
+    filterMatches: async (u, c, pm, em) => { calls.push("filter"); return { packMatches: pm, entityMatches: em }; },
+    logRecall: () => { calls.push("log"); },
+    buildPackBlock: (m) => { calls.push("buildPack"); return m.length ? "PACKBLOCK" : ""; },
+    buildEntityBlock: (m) => { calls.push("buildEntity"); return m.length ? "ENTITYBLOCK" : ""; },
+  };
+  const out = await recall.getEngine("classic").run({
+    userText: "hello", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(out.packBlock, "PACKBLOCK");
+  assert.strictEqual(out.entityBlock, "ENTITYBLOCK");
+  assert.strictEqual(out.packMatches.length, 1);
+  assert.strictEqual(out.entityMatches.length, 1);
+  assert.ok(calls.includes("filter") && calls.includes("log") && calls.includes("buildPack"));
+
+  // resilient: a throwing matcher must not blow up the engine
+  const out2 = await recall.getEngine("classic").run({
+    userText: "x", contextText: "", fullContext: "",
+    packLimit: 6, budget: {},
+    helpers: {
+      ...helpers,
+      packsLib: { matchPacks: () => { throw new Error("boom"); } },
+      entitiesLib: { matchEntities: () => { throw new Error("boom"); } },
+    },
+  });
+  assert.strictEqual(typeof out2.packBlock, "string");
+
+  console.log("recall engine OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-recall-graph.js

@@ -0,0 +1,94 @@
+// Recall graph: edges, Hebbian reinforce, decay, spreading activation,
+// structural sync, orphan prune. Uses a throwaway sqlite db under a temp dir.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-graph-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+
+const graph = require("./core/recall/graph");
+
+if (!graph.available()) { console.log("recall graph OK (skipped — no node:sqlite)"); process.exit(0); }
+
+// --- edges + neighbours ---
+graph.addEdge("pack:a", "pack:b", "related");
+graph.addEdge("pack:b", "pack:c", "related");
+graph.addEdge("pack:a", "pack:theme", "governed-by");
+const nb = graph.neighbors("pack:a").map((x) => x.node).sort();
+assert.deepStrictEqual(nb, ["pack:b", "pack:theme"], "undirected neighbours of a");
+assert.strictEqual(graph.allEdges().length, 3);
+
+// addEdge keeps the max weight (structural re-derive never lowers reinforcement)
+graph.addEdge("pack:a", "pack:b", "related", { weight: 99 });
+let ab = graph.allEdges().find((e) => e.src === "pack:a" && e.dst === "pack:b");
+assert.strictEqual(ab.weight, 99, "weight raised to max");
+graph.addEdge("pack:a", "pack:b", "related", { weight: 1 });
+ab = graph.allEdges().find((e) => e.src === "pack:a" && e.dst === "pack:b");
+assert.strictEqual(ab.weight, 99, "weight not lowered by smaller structural weight");
+
+// --- Hebbian reinforce (both directions) ---
+graph.reinforce("pack:x", "pack:y", 2);
+const xy = graph.allEdges().find((e) => e.src === "pack:x" && e.dst === "pack:y");
+const yx = graph.allEdges().find((e) => e.src === "pack:y" && e.dst === "pack:x");
+assert.ok(xy && yx, "reinforce creates both directions");
+assert.ok(xy.last_reinforced, "reinforce stamps last_reinforced");
+graph.reinforce("pack:x", "pack:y", 2);
+const xy2 = graph.allEdges().find((e) => e.src === "pack:x" && e.dst === "pack:y");
+assert.ok(xy2.weight > xy.weight, "repeat reinforce bumps weight");
+
+graph.reinforceSet(["pack:a", "pack:b", "pack:c"]);
+assert.ok(graph.neighbors("pack:a").some((n) => n.node === "pack:c"), "reinforceSet links all pairs");
+
+// --- spreading activation ---
+// strong chain a→b→c; seed a, expect b (1 hop) and possibly c (2 hops).
+const act = graph.expand([{ id: "pack:a", score: 4 }], { hops: 2, threshold: 0.1 });
+assert.ok(act.has("pack:b"), "1-hop neighbour activates");
+assert.ok(!act.has("pack:a"), "seed excluded from activation result");
+for (const [, v] of act) assert.ok(v.activation > 0 && v.hop >= 1, "activation has metadata");
+
+// seeds with no edges produce nothing
+assert.strictEqual(graph.expand([{ id: "pack:orphanseed", score: 5 }]).size, 0);
+
+// --- decay (never below structural floor) ---
+graph.addEdge("pack:d", "pack:e", "parent"); // base weight 3, no last_reinforced → untouched
+graph.reinforce("pack:d", "pack:f", 10);
+// backdate the reinforced edge well past the half-life
+const db = graph.openDb();
+const old = new Date(Date.now() - 400 * 86400000).toISOString();
+db.prepare("UPDATE edges SET last_reinforced=? WHERE src=? AND dst=?").run(old, "pack:d", "pack:f");
+graph.decay({ halfLifeDays: 30 });
+const df = graph.allEdges().find((e) => e.src === "pack:d" && e.dst === "pack:f");
+assert.ok(df.weight < 11 && df.weight >= 1, "reinforced edge decayed toward floor");
+const de = graph.allEdges().find((e) => e.src === "pack:d" && e.dst === "pack:e");
+assert.strictEqual(de.weight, 3, "structural edge with no reinforcement untouched by decay");
+
+// --- structural sync from a stubbed corpus ---
+const packsStub = {
+  listPacks: () => [
+    { dir: "kazee-mobile", name: "Kazee Mobile", tags: [], parent: "kazee",
+      sections: { Stance: "uses [[kazee-theme]]", Procedure: "", State: "", Journal: "" } },
+    { dir: "kazee", name: "Kazee", tags: [], parent: null,
+      sections: { Stance: "", Procedure: "", State: "", Journal: "" } },
+    { dir: "kazee-theme", name: "Kazee Theme", tags: ["shared"], parent: null,
+      sections: { Stance: "lime palette", Procedure: "", State: "", Journal: "" } },
+  ],
+};
+const entStub = { listEntities: () => [] };
+const r = graph.syncFromCorpus(packsStub, entStub);
+assert.ok(r.edges >= 2, "sync derived parent + link edges");
+const edges = graph.allEdges();
+assert.ok(edges.some((e) => e.src === "pack:kazee-mobile" && e.dst === "pack:kazee" && e.type === "parent"), "parent edge from frontmatter");
+assert.ok(edges.some((e) => e.src === "pack:kazee-mobile" && e.dst === "pack:kazee-theme" && e.type === "governed-by"), "shared-concern link → governed-by");
+
+// --- orphan prune ---
+graph.addEdge("pack:ghost", "pack:kazee", "related");
+const pruned = graph.pruneOrphans(packsStub, entStub);
+assert.ok(pruned >= 1, "orphan edge pruned");
+assert.ok(!graph.allEdges().some((e) => e.src === "pack:ghost"), "ghost edge gone");
+
+// parseLinks
+assert.deepStrictEqual(graph.parseLinks("see [[Foo-Bar]] and [[baz]]"), ["foo-bar", "baz"]);
+
+console.log("recall graph OK");