@inetafrica/open-claudia 2.6.51 → 2.6.53

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.53
+- **Pack↔tool contextual edges — surface how a tool is used in a topic.** Completes the v2.6.49 tool story. The directed tool-graph answers "what runs *next*"; this adds the orthogonal question "how is a tool *used in this context*". A new `pack_tool_edges` table (`core/tool-graph.js`, sharing the existing SQLite store, decay and pruning) records, for each turn, the reusable tools that ran while a context pack was open — keyed by `(pack, tool, command-shape)` so distinct invocations of the same tool coexist and the strongest surface. Capture is automatic and deterministic (no hand-authoring): `runner.js` already tracks the tools run and the packs opened each turn, so at end-of-turn it records a pack↔tool edge per (opened-pack × run-tool), Hebbian-reinforced. Commands are stored as **shapes, not literals** — a new `shapeCommand()` strips ids, paths, numbers and quoted text to placeholders (`spaces docs --task-id <id> <path>`) so the memory is a reusable pattern, not a stale one-off; `parseToolRuns()` extracts `{name, shape}` from a shell command (split across chained invocations) and feeds both graphs. Surfacing: when a pack is injected into context, `formatPackForContext` appends a **"Tools used in this pack"** block with the 1–2 strongest invocations, so the agent sees the concrete command instead of re-deriving it; `tool show` gains the inverse "Used in packs" view; an optional `intent` column lets a one-line *why* be enriched later without a migration. The nightly dream tends these edges alongside the follows-edges (decay + prune orphaned tools/packs). Degrades to a graceful no-op where `node:sqlite` is unavailable, exactly like the existing tool-graph. Extends `test-tool-graph.js`.
+
 ## v2.6.49
 - **Reusable tools + a directed tool-usage graph.** Two linked features. First, **reusable tools** (`core/tools.js`, `bin/tool.js`): the executable sibling of context packs — when the agent works out an operational procedure (hit an API, drive an interface, transform a file) it crystallises the script into a re-runnable command instead of a throwaway heredoc. Tools are one executable file with a parseable comment header, run pre-authed (the operational keyring is merged into their env so they reference `$NAME` and never hardcode a secret), can link to an owning skill pack, and are surfaced every turn as an always-on index (full docs/source on demand via `open-claudia tool show <name>`). Full CLI: `open-claudia tool list|show|add|run|remove`; `/learn` now crystallises the executable part too. Second, a **directed tool-graph** (`core/tool-graph.js`): a "tool B follows tool A" graph kept deliberately separate from the recall graph — for tools the useful signal is the *order* a chain runs in (auth → list → download), so edges are stored and traversed directionally. Each run-sequence reinforces consecutive pairs (Hebbian, decayed nightly, no structural floor so unused chains prune away). `tool show` and the system-prompt index surface "usually followed by …"; `pack show` gains the reverse view (a pack's linked tools); the nightly dream tends the graph (decay + orphan prune) and flags tools whose `--pack` link dangles. Adds `test-tools.js` + `test-tool-graph.js`.
 

package/bin/tool.js

@@ -77,6 +77,14 @@ function run(args) {
         const before = graph.predecessors(t.name);
         if (after.length) console.log(`Often followed by: ${fmt(after)}`);
         if (before.length) console.log(`Often preceded by: ${fmt(before)}`);
+        // Pack↔tool: contexts this tool has been used in, with the shape used.
+        const inPacks = graph.toolPacks(t.name, 5);
+        if (inPacks.length) {
+          console.log("Used in packs:");
+          for (const u of inPacks) {
+            console.log(`  • ${u.pack}: open-claudia tool run ${u.command || t.name}${u.intent ? `  — ${u.intent}` : ""}`);
+          }
+        }
       } catch (e) { /* graph optional (old node) */ }
       console.log(`\n----- source -----\n${t.content}`);
       break;

package/core/dream.js

@@ -833,7 +833,7 @@ async function runDream({ trigger = "manual" } = {}) {
     let toolNote = "";
     try {
       const toolsLib = require("./tools");
-      const tg = require("./tool-graph").tend(toolsLib);
+      const tg = require("./tool-graph").tend(toolsLib, { packsLib: packs });
       const bits = [];
       if (tg.edges || tg.decayed || tg.pruned) {
         bits.push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (decayed ${tg.decayed}, pruned ${tg.pruned}).`);

package/core/runner.js

@@ -939,10 +939,11 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // Nodes the agent actually OPENED this turn (📖). This is the co-use signal
   // the recall graph reinforces on — actually-read, not merely surfaced.
   const openedThisTurn = new Set();
-  // Reusable tools the agent RAN this turn, in order. Feeds the directed
-  // tool-graph (core/tool-graph.js): consecutive runs become follows-edges so
-  // "you ran X — you usually run Y next" can be surfaced. Order matters here
-  // (unlike openedThisTurn, a Set), because a tool chain is a pipeline.
+  // Reusable tools the agent RAN this turn, in order, as { name, shape }. Feeds
+  // two graphs (core/tool-graph.js): names → directed follows-edges ("you ran X
+  // — you usually run Y next"); shapes → pack↔tool edges ("in this topic, tool X
+  // is used as `…`"). Order matters here (unlike openedThisTurn, a Set), because
+  // a tool chain is a pipeline.
   const toolRunsThisTurn = [];
   const noteRecallFromShell = (command) => {
     try {
@@ -965,11 +966,13 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         openedThisTurn.add(`entity:${slug}`);
         notifySkill(`recall:entity:${slug}`, `📖 Recalled my notes on: ${name}`);
       }
-      // `open-claudia tool run|exec <name>` — record the run for the directed
-      // tool-graph. Only the name is captured (args are noise for "what runs
-      // next"); the end-of-turn block reinforces consecutive pairs.
-      const toolRe = /\btool\s+(?:run|exec)\s+["']?([a-z0-9][\w.-]*)/gi;
-      while ((m = toolRe.exec(cmd))) toolRunsThisTurn.push(m[1]);
+      // `open-claudia tool run|exec <name> <args>` — record each run as
+      // { name, shape }. The name feeds the directed follows-graph (what runs
+      // next); the sanitized command shape feeds pack↔tool capture (how a tool
+      // is used in a topic). Parsing lives in tool-graph so it stays testable.
+      try {
+        for (const run of require("./tool-graph").parseToolRuns(cmd)) toolRunsThisTurn.push(run);
+      } catch (e) { /* graph optional (old node) */ }
     } catch (e) { /* announcements are best-effort */ }
   };
 
@@ -1362,10 +1365,26 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     // so it never bleeds into recall's spreading activation. Reinforce only on a
     // successful turn, and only when ≥2 ran (a single run has no succession).
     if (turnSucceeded && toolRunsThisTurn.length > 1) {
-      try { require("./tool-graph").reinforceSequence(toolRunsThisTurn); }
+      try { require("./tool-graph").reinforceSequence(toolRunsThisTurn.map((t) => t.name)); }
       catch (e) { /* best-effort */ }
     }
 
+    // Pack↔tool contextual edges: a reusable tool run while a context pack was
+    // open this turn records "this tool was used in this topic, as `<shape>`",
+    // so next time the pack is active the discoverer can surface the concrete
+    // invocation instead of leaving the agent to re-derive it. Fires even for a
+    // single run (one tool-in-a-pack is still a usage) — unlike the follows-graph
+    // above which needs a succession. Best-effort; never blocks the turn.
+    if (turnSucceeded && toolRunsThisTurn.length && openedThisTurn.size) {
+      try {
+        const tg = require("./tool-graph");
+        const packDirs = [...openedThisTurn].filter((n) => n.startsWith("pack:")).map((n) => n.slice(5));
+        for (const dir of packDirs) {
+          for (const run of toolRunsThisTurn) tg.recordPackTool(dir, run.name, { command: run.shape, bump: 1 });
+        }
+      } 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

package/core/system-prompt.js

@@ -483,6 +483,20 @@ function formatPackForContext(pack, packsLib, opts = {}) {
     const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
     if (journal) parts.push(`#### Journal (recent)\n${journal}`);
   }
+  // Pack↔tool usages: concrete reusable-tool invocations recorded while this
+  // pack was active, so the agent sees HOW a tool was used in this topic (not
+  // just that it exists). Strongest 2; best-effort + optional (absent on old
+  // node without node:sqlite). Compact enough to show in every mode.
+  try {
+    const usages = require("./tool-graph").packTools(pack.dir, 2);
+    if (usages && usages.length) {
+      const lines = usages.map((u) => {
+        const cmd = u.command ? `\`open-claudia tool run ${u.command}\`` : `\`open-claudia tool run ${u.tool}\``;
+        return `- ${cmd}${u.intent ? ` — ${u.intent}` : ""}`;
+      }).join("\n");
+      parts.push(`#### Tools used in this pack\n${lines}`);
+    }
+  } catch (e) { /* tool-graph optional */ }
   return clip(parts.join("\n\n"), PACK_INJECT_MAX_CHARS);
 }
 
@@ -699,6 +713,29 @@ function bumpFtsMissCounter(n) {
   } catch (e) {}
 }
 
+// Spoken-reply shaping. Injected into the USER prompt (not the cached system
+// prompt) ONLY on voice-input turns of the voice channel — i.e. exactly when the
+// reply will be read aloud by TTS (same gate as the streaming/auto-speak path in
+// the runner). Text channels (Telegram/Kazee) and typed turns never see it.
+const VOICE_REPLY_GUIDANCE = [
+  "",
+  "",
+  "## Voice reply mode",
+  "This reply will be spoken aloud to the user by a text-to-speech voice. Write it to be HEARD, not read:",
+  "- Talk naturally and conversationally, like a person speaking. Keep it short — a couple of clear sentences beat a long structured answer.",
+  "- Do NOT read out code, file paths, command syntax, IDs, URLs, or variable/function names. Describe them in plain words, summarise, or skip them (e.g. say \"the recall file\" instead of spelling a path).",
+  "- No markdown or formatting — no bullets, headings, backticks, or asterisks; they are noise when spoken.",
+  "- If the answer genuinely needs code or exact detail, say so briefly and offer to send it as text rather than reading it aloud.",
+].join("\n");
+
+function voiceReplyGuidance() {
+  try {
+    const { currentTransport } = require("./context");
+    if (currentTransport() === "voice" && currentState().lastInputWasVoice) return VOICE_REPLY_GUIDANCE;
+  } catch (e) {}
+  return "";
+}
+
 async function promptWithDynamicContext(prompt, opts = {}) {
   lastInjected = { packs: [], entities: [], recall: null };
   try {
@@ -735,7 +772,7 @@ async function promptWithDynamicContext(prompt, opts = {}) {
       ? `\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.`
       : "";
     const transcriptPointer = opts.includeTranscriptPointer ? `${transcriptPointerNote(state)}\n\n` : "";
-    return `${transcriptPointer}${buildDynamicContextBlock()}${packBlock}${entityBlock}${budgetNote}\n\nCurrent user request:\n${prompt}`;
+    return `${transcriptPointer}${buildDynamicContextBlock()}${packBlock}${entityBlock}${budgetNote}${voiceReplyGuidance()}\n\nCurrent user request:\n${prompt}`;
   } catch (e) {
     return prompt;
   }

package/core/tool-graph.js

@@ -55,6 +55,24 @@ function openDb() {
     )`);
     db.exec("CREATE INDEX IF NOT EXISTS tool_edges_src ON tool_edges (src)");
     db.exec("CREATE INDEX IF NOT EXISTS tool_edges_dst ON tool_edges (dst)");
+    // Pack↔tool contextual edges: "while pack P was open, tool T was run as
+    // <command shape>". A different physics from the tool→tool follows-edges
+    // above (this is "how a tool is used in a topic", not "what runs next"), but
+    // it shares the same DB, decay and pruning machinery. One row per distinct
+    // (pack, tool, command-shape) so several ways of using a tool in a topic can
+    // coexist and the strongest surface.
+    db.exec(`CREATE TABLE IF NOT EXISTS pack_tool_edges (
+      pack TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      command TEXT NOT NULL DEFAULT '',
+      intent TEXT NOT NULL DEFAULT '',
+      weight REAL NOT NULL DEFAULT 1,
+      last_reinforced TEXT,
+      created TEXT,
+      PRIMARY KEY (pack, tool, command)
+    )`);
+    db.exec("CREATE INDEX IF NOT EXISTS pack_tool_edges_pack ON pack_tool_edges (pack)");
+    db.exec("CREATE INDEX IF NOT EXISTS pack_tool_edges_tool ON pack_tool_edges (tool)");
     _db = db;
     return db;
   } catch (e) {
@@ -142,21 +160,136 @@ function predecessors(name, limit = 5) {
   } catch (e) { return []; }
 }
 
+// ── Pack↔tool contextual edges ──────────────────────────────────────────────
+// "While context pack P was open, reusable tool T was run as `<command shape>`."
+// Captured automatically at end of turn (see runner.js) so the discoverer can
+// later surface the concrete invocation for a pack — the agent sees HOW a tool
+// is used in a topic, not merely that the tool exists. Reinforced Hebbian-style
+// and decayed/pruned by tend() exactly like the follows-edges.
+
+// Reduce a literal invocation to a reusable SHAPE: strip ids, paths, numbers and
+// quoted text to placeholders so the stored command is a pattern, not a one-off
+// with stale literals. Keeps subcommands and flag names — the structure worth
+// remembering. Input may include a leading `[open-claudia ]tool run|exec`
+// wrapper, which is dropped so the shape starts at the tool name.
+function shapeCommand(raw) {
+  let s = String(raw || "").trim();
+  if (!s) return "";
+  s = s.replace(/^\s*(?:open-claudia\s+)?tool\s+(?:run|exec)\s+/i, "");
+  s = s.replace(/(["']).*?\1/g, "<text>");                   // quoted strings
+  const toks = s.split(/\s+/).filter(Boolean).map((t) => {
+    if (/^--?[a-z][\w-]*$/i.test(t)) return t;               // keep flag names
+    if (/^[0-9a-f]{12,}$/i.test(t)) return "<id>";           // long hex ids
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(t)) return "<id>"; // uuid
+    if (t.includes("/") || t.includes("\\")) return "<path>";
+    if (/^\d[\d.,:t-]*$/i.test(t)) return "<n>";             // numbers / dates
+    if (t.length >= 24) return "<arg>";                      // long opaque token
+    return t;
+  });
+  return toks.join(" ").slice(0, 80).trim();
+}
+
+// Parse `tool run|exec <name> <args...>` invocations out of a shell command,
+// returning [{ name, shape }] in order. Splits on shell separators so one
+// invocation's args don't bleed into the next. Feeds both the follows-graph
+// (names) and pack↔tool capture (shapes).
+function parseToolRuns(command) {
+  const out = [];
+  const cmd = String(command || "");
+  if (!/tool\s+(?:run|exec)\s+/i.test(cmd)) return out;
+  for (const seg of cmd.split(/&&|\|\||[;\n]/)) {
+    const m = seg.match(/\btool\s+(?:run|exec)\s+["']?([a-z0-9][\w.-]*)["']?\s*(.*)$/i);
+    if (!m) continue;
+    out.push({ name: m[1], shape: shapeCommand(`${m[1]} ${m[2] || ""}`) });
+  }
+  return out;
+}
+
+// Upsert/reinforce a pack↔tool contextual usage. `command` is the (shaped)
+// invocation, `intent` an optional one-line why. `bump` adds Hebbian weight;
+// absent it just ensures the edge exists. A later non-empty intent overwrites an
+// earlier blank one so the reviewer can enrich a deterministically-captured edge.
+function recordPackTool(pack, tool, opts = {}) {
+  const db = openDb();
+  if (!db || !pack || !tool) return false;
+  const command = String(opts.command || "").slice(0, 120);
+  const bump = Number.isFinite(opts.bump) ? opts.bump : 0;
+  const weight = Number.isFinite(opts.weight) ? opts.weight : 1;
+  try {
+    const row = db.prepare("SELECT weight, intent, last_reinforced FROM pack_tool_edges WHERE pack=? AND tool=? AND command=?").get(pack, tool, command);
+    if (row) {
+      const next = bump ? row.weight + bump : Math.max(row.weight, weight);
+      const intent = (opts.intent != null && opts.intent !== "") ? String(opts.intent).slice(0, 200) : row.intent;
+      db.prepare("UPDATE pack_tool_edges SET weight=?, intent=?, last_reinforced=? WHERE pack=? AND tool=? AND command=?")
+        .run(next, intent, bump ? now() : row.last_reinforced, pack, tool, command);
+    } else {
+      const initial = bump ? bump : weight;
+      db.prepare("INSERT INTO pack_tool_edges (pack, tool, command, intent, weight, last_reinforced, created) VALUES (?,?,?,?,?,?,?)")
+        .run(pack, tool, command, String(opts.intent || "").slice(0, 200), initial, bump ? now() : null, now());
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Strongest contextual tool usages recorded under a pack, for surfacing in that
+// pack's injected context. Ordered by reinforced weight, newest first as a
+// tiebreak. One row per distinct command shape.
+function packTools(pack, limit = 2) {
+  const db = openDb();
+  if (!db || !pack) return [];
+  try {
+    return db.prepare(
+      "SELECT tool, command, intent, weight FROM pack_tool_edges WHERE pack=? ORDER BY weight DESC, last_reinforced DESC LIMIT ?"
+    ).all(pack, limit);
+  } catch (e) { return []; }
+}
+
+// Inverse view: which packs a tool has been used under (for `tool show`).
+function toolPacks(tool, limit = 5) {
+  const db = openDb();
+  if (!db || !tool) return [];
+  try {
+    return db.prepare(
+      "SELECT pack, command, intent, weight FROM pack_tool_edges WHERE tool=? ORDER BY weight DESC, last_reinforced DESC LIMIT ?"
+    ).all(tool, limit);
+  } catch (e) { return []; }
+}
+
+function removePackTool(pack, tool, command) {
+  const db = openDb();
+  if (!db) return false;
+  try { db.prepare("DELETE FROM pack_tool_edges WHERE pack=? AND tool=? AND command=?").run(pack, tool, command || ""); return true; }
+  catch (e) { return false; }
+}
+
+function allPackToolEdges() {
+  const db = openDb();
+  if (!db) return [];
+  try { return db.prepare("SELECT pack, tool, command, intent, weight, last_reinforced FROM pack_tool_edges").all(); }
+  catch (e) { return []; }
+}
+
 // Exponential time decay. Tools have no structural floor, so edges decay toward
 // zero and are pruned once under `pruneBelow` — a chain that fell out of use
-// disappears instead of lingering as stale advice.
+// disappears instead of lingering as stale advice. Applies to both the tool→tool
+// follows-edges and the pack↔tool contextual edges (same physics).
 function decay({ halfLifeDays = DEFAULTS.halfLifeDays, pruneBelow = DEFAULTS.pruneBelow } = {}) {
   const db = openDb();
   if (!db) return { decayed: 0, pruned: 0 };
-  const rows = allEdges();
   const nowMs = Date.now();
   const ln2 = Math.log(2);
   let decayed = 0, pruned = 0;
-  for (const e of rows) {
-    if (!e.last_reinforced) continue;
-    const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
-    if (!(ageDays > 0)) continue;
-    const factor = Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
+  const decayFactor = (lastReinforced) => {
+    if (!lastReinforced) return null;
+    const ageDays = (nowMs - Date.parse(lastReinforced)) / 86400000;
+    if (!(ageDays > 0)) return null;
+    return Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
+  };
+  for (const e of allEdges()) {
+    const factor = decayFactor(e.last_reinforced);
+    if (factor === null) continue;
     const next = e.weight * factor;
     if (next < pruneBelow) {
       if (removeEdge(e.src, e.dst)) pruned++;
@@ -169,32 +302,62 @@ function decay({ halfLifeDays = DEFAULTS.halfLifeDays, pruneBelow = DEFAULTS.pru
       } catch (e2) {}
     }
   }
+  for (const e of allPackToolEdges()) {
+    const factor = decayFactor(e.last_reinforced);
+    if (factor === null) continue;
+    const next = e.weight * factor;
+    if (next < pruneBelow) {
+      if (removePackTool(e.pack, e.tool, e.command)) pruned++;
+      continue;
+    }
+    if (Math.abs(next - e.weight) > 1e-6) {
+      try {
+        db.prepare("UPDATE pack_tool_edges SET weight=? WHERE pack=? AND tool=? AND command=?").run(next, e.pack, e.tool, e.command);
+        decayed++;
+      } catch (e2) {}
+    }
+  }
   return { decayed, pruned };
 }
 
 // Drop edges whose endpoints are no longer registered tools (a tool was removed
-// or renamed). Keeps the graph from pointing at things that can't be run.
-function pruneOrphans(toolsLib) {
+// or renamed). Keeps the graph from pointing at things that can't be run. Also
+// drops pack↔tool edges whose tool is gone, and — when a packs lib is supplied —
+// whose pack is gone, so a removed pack doesn't leave dangling usages.
+function pruneOrphans(toolsLib, packsLib) {
   const db = openDb();
   if (!db) return 0;
-  let live;
-  try { live = new Set(toolsLib.listTools().map((t) => t.name)); }
+  let liveTools;
+  try { liveTools = new Set(toolsLib.listTools().map((t) => t.name)); }
   catch (e) { return 0; }
-  if (!live.size) return 0;
+  if (!liveTools.size) return 0;
   let removed = 0;
   for (const e of allEdges()) {
-    if (!live.has(e.src) || !live.has(e.dst)) {
+    if (!liveTools.has(e.src) || !liveTools.has(e.dst)) {
       if (removeEdge(e.src, e.dst)) removed++;
     }
   }
+  let livePacks = null;
+  if (packsLib) {
+    try { livePacks = new Set(packsLib.listPacks().map((p) => p.dir)); }
+    catch (e) { livePacks = null; }
+  }
+  for (const e of allPackToolEdges()) {
+    const toolGone = !liveTools.has(e.tool);
+    const packGone = livePacks ? !livePacks.has(e.pack) : false;
+    if (toolGone || packGone) {
+      if (removePackTool(e.pack, e.tool, e.command)) removed++;
+    }
+  }
   return removed;
 }
 
 // Nightly maintenance (called by the dream): decay reinforced weights and drop
-// orphaned/faded edges. Deterministic + safe — no model needed.
+// orphaned/faded edges. Deterministic + safe — no model needed. Pass
+// { packsLib } to also prune pack↔tool edges whose pack was removed.
 function tend(toolsLib, opts = {}) {
   const { decayed, pruned } = decay(opts);
-  const orphaned = toolsLib ? pruneOrphans(toolsLib) : 0;
+  const orphaned = toolsLib ? pruneOrphans(toolsLib, opts.packsLib) : 0;
   return { decayed, pruned: pruned + orphaned, ...stats() };
 }
 
@@ -202,7 +365,7 @@ function stats() {
   const rows = allEdges();
   const nodes = new Set();
   for (const e of rows) { nodes.add(e.src); nodes.add(e.dst); }
-  return { edges: rows.length, nodes: nodes.size };
+  return { edges: rows.length, nodes: nodes.size, packToolEdges: allPackToolEdges().length };
 }
 
 // Test seam.
@@ -213,5 +376,7 @@ module.exports = {
   available, openDb,
   addFollow, reinforceSequence, removeEdge, allEdges,
   followers, predecessors, decay, pruneOrphans, tend, stats,
+  shapeCommand, parseToolRuns, recordPackTool, packTools, toolPacks,
+  removePackTool, allPackToolEdges,
   _resetForTest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.51",
+  "version": "2.6.53",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {

package/test-tool-graph.js

@@ -93,5 +93,64 @@ assert.ok(typeof t.pruned === "number" && typeof t.decayed === "number", "tend r
 const s = graph.stats();
 assert.strictEqual(s.edges, graph.allEdges().length, "stats edge count matches allEdges");
 
+// ══ Pack↔tool contextual edges ══════════════════════════════════════════════
+
+// ── shapeCommand: strips literals to placeholders, keeps subcommands + flags ──
+assert.strictEqual(
+  graph.shapeCommand("open-claudia tool run spaces docs --task-id 69abf1e25f50dd1fb617d6d0 /tmp/out"),
+  "spaces docs --task-id <id> <path>", "id + path reduced to shapes, wrapper stripped");
+assert.strictEqual(
+  graph.shapeCommand('spaces comment --task-id 69abf1e25f50dd1fb617d6d0 "draft 1"'),
+  "spaces comment --task-id <id> <text>", "quoted text reduced, flag kept");
+assert.ok(graph.shapeCommand("foo 12345").includes("<n>"), "bare number reduced to <n>");
+
+// ── parseToolRuns: extracts {name, shape}, splits chained invocations ──
+const runs = graph.parseToolRuns("open-claudia tool run spaces docs --task-id abcdef123456 /tmp/x && open-claudia tool run other list");
+assert.strictEqual(runs.length, 2, "two chained tool runs parsed");
+assert.strictEqual(runs[0].name, "spaces", "first run is spaces");
+assert.strictEqual(runs[0].shape, "spaces docs --task-id <id> <path>", "first run shaped");
+assert.strictEqual(runs[1].name, "other", "second run is other (args did not bleed across &&)");
+assert.strictEqual(graph.parseToolRuns("ls -la").length, 0, "non-tool command yields no runs");
+
+// ── recordPackTool: insert, then bump accumulates; packTools surfaces strongest ──
+graph.recordPackTool("san-marco-agreements", "spaces", { command: "spaces docs --task-id <id> <path>", bump: 1 });
+graph.recordPackTool("san-marco-agreements", "spaces", { command: "spaces docs --task-id <id> <path>", bump: 1 });
+graph.recordPackTool("san-marco-agreements", "spaces", { command: "spaces upload --task-id <id> --comment <text> <path>", bump: 1 });
+const pt = graph.packTools("san-marco-agreements", 2);
+assert.strictEqual(pt.length, 2, "two distinct command shapes recorded");
+assert.strictEqual(pt[0].command, "spaces docs --task-id <id> <path>", "most-reinforced shape surfaces first");
+assert.strictEqual(pt[0].weight, 2, "two bumps accumulate to weight 2");
+
+// ── intent enrichment: a later non-empty intent fills a blank one ──
+graph.recordPackTool("san-marco-agreements", "spaces", { command: "spaces docs --task-id <id> <path>", intent: "pull contract drafts" });
+assert.strictEqual(graph.packTools("san-marco-agreements", 1)[0].intent, "pull contract drafts", "blank intent enriched later");
+
+// ── toolPacks: inverse view (which packs use this tool) ──
+assert.ok(graph.toolPacks("spaces").some((u) => u.pack === "san-marco-agreements"), "toolPacks lists the pack");
+
+// ── stats counts pack↔tool edges ──
+assert.strictEqual(graph.stats().packToolEdges, graph.allPackToolEdges().length, "stats packToolEdges matches allPackToolEdges");
+assert.ok(graph.stats().packToolEdges >= 2, "at least two pack↔tool edges present");
+
+// ── decay: a year-old pack↔tool edge under the floor is pruned ──
+const ptDb = graph.openDb();
+ptDb.prepare("UPDATE pack_tool_edges SET last_reinforced=? WHERE pack=? AND tool=?")
+  .run(new Date(Date.now() - 365 * 86400000).toISOString(), "san-marco-agreements", "spaces");
+const decayRes = graph.decay({ halfLifeDays: 1, pruneBelow: 0.15 });
+assert.ok(decayRes.pruned >= 1, "stale pack↔tool edge pruned by decay");
+assert.strictEqual(graph.packTools("san-marco-agreements").length, 0, "pruned pack↔tool edges gone");
+
+// ── pruneOrphans: drops edges for a removed tool and (with packsLib) a removed pack ──
+graph.recordPackTool("live-pack", "live-tool", { command: "live-tool go", bump: 1 });
+graph.recordPackTool("live-pack", "ghost-tool", { command: "ghost-tool go", bump: 1 });
+graph.recordPackTool("ghost-pack", "live-tool", { command: "live-tool go", bump: 1 });
+const toolsLib = { listTools: () => [{ name: "live-tool" }] };
+const packsLib = { listPacks: () => [{ dir: "live-pack" }] };
+const orphans = graph.pruneOrphans(toolsLib, packsLib);
+assert.ok(orphans >= 2, "edges for a missing tool and a missing pack are pruned");
+assert.ok(graph.packTools("live-pack").some((u) => u.tool === "live-tool"), "live pack + live tool edge survives");
+assert.ok(!graph.packTools("live-pack").some((u) => u.tool === "ghost-tool"), "missing-tool edge gone");
+assert.strictEqual(graph.packTools("ghost-pack").length, 0, "missing-pack edge gone");
+
 graph._resetForTest();
 console.log("tool-graph OK");