@inetafrica/open-claudia 3.1.23 → 3.1.24

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v3.1.24 — Catalog-first recall: the walker sees the whole index, nothing is cut before a model judges it
+
+- **Root cause (proven, `diag-recall-ranking.js`).** Recall misses were 4-layer candidate starvation, not bad judging: (1) lexical pack scores count distinct matched terms, so vocab-dense packs outbid the true pack; (2) the graph fire-threshold scales off the MAX seed score, so junk seeds suppress true edges; (3) per-node top-K fan-out on hub nodes cuts true edges before they transmit; (4) killer — the dream tuned `walkerMaxCandidates` down to 10 on 2026-07-09 while seeds are 6 pack + 4 entity = exactly 10 and assembly orders all seeds before all graph-activated nodes, so **graph-activated packs/entities got zero walker slots on every full-seeded turn since**. The walker judged well; it just never saw the right nodes.
+- **Catalog-first routing.** The walker's SYSTEM prompt now carries the ENTIRE memory index — every pack, entity, and tool as a one-liner (~50KB for 276 nodes, `buildCatalog()`, 60s TTL cache). Set once per warm-walker session (exempt from the warm per-message char budget) and identical on the cold path. Lexical seeds + graph activation are demoted to per-turn RANKING HINTS: the same top-K candidate assembly, but now it only decides which few nodes carry live excerpts — never membership. The walker may keep ANY catalog id, hinted or not; zero-hint turns still walk. Kept catalog picks inject exactly like hinted ones (packs render extractive lines, un-hinted tools resolve through the registry).
+- **Simpler under catalog mode.** The history cascade is bypassed (an auto-drop would cut on history alone — never-cut principle) and tool pack-riding is removed (every tool is already in view). Both return when the `catalog` knob is off — new dream-tunable enum (`RECALL_CATALOG` env pin) that restores the legacy capped-menu contract as a one-flip rollback.
+- **Honest observability.** `recall query` now reports `catalog` counts + `hintedActivated`, and the CLI banner says "N kept of catalog of 276 nodes (K hinted)" with "graph-activated in hints: X of Y" — the old "+N graph-activated" counted raw expansion and overstated what actually survived into the walker's view (measured: it said +9 while 0 survived). Unjudged fail-open output no longer claims catalog scope. Per-turn metrics log catalog counts, never the full id list.
+- **Validated on the two proven misses.** Sim A (update-app button) now keeps the in-app-updater pack at 85 `[via catalog]` — a node the old pipeline structurally could not surface; sim B (group permission system) keeps the governing pack at 88 as the sole result. Corollary: catalog one-liners make pack descriptions load-bearing for recall — the nightly dream already tightens them.
+- New release-chain test `test-recall-catalog.js` pins the contract: full-index build + TTL cache + stub-safe null, catalog in system prompt (never the user prompt), un-hinted pack/entity/tool keeps injecting end-to-end, score-gate on catalog picks, knob-off legacy filtering, and query provenance (`via: "catalog"`).
+
 ## v3.1.23 — Scoped external rules (person / channel / everyone), auto-contacts, meet-greet lane
 
 - **Make-a-rule now offers three scopes.** The owner's guardrail card gained a middle option: alongside "just this person" and "everyone", rules can now bind to **this channel** — stored in `channel-rules.md` keyed generically on `adapterType:channelId`, so every surface (kazee groups, Spaces tasks, telegram chats, future public domains) participates simply by existing. No adapter-specific policy logic anywhere; caps at 20 rules × 300 chars per channel.

package/bin/recall.js

@@ -104,7 +104,15 @@ async function queryCmd(args) {
   }
   if (flags.json) { console.log(JSON.stringify(res, null, 2)); return; }
   const w = res.walker || {};
-  console.log(`Recall query — ${res.results.length} kept of ${res.candidates} candidate(s) (seeds: ${res.seeds.packs} pack, ${res.seeds.entities} entity, ${res.seeds.tools} tool; +${res.activated} graph-activated)`);
+  const cat = res.catalog;
+  // Catalog scope only when a judge actually saw the catalog — an unjudged
+  // fail-open list is hints only and must not claim full-index coverage.
+  const scope = cat && res.judged
+    ? `catalog of ${cat.packs + cat.entities + cat.tools} nodes (${res.candidates} hinted)`
+    : `${res.candidates} candidate(s)`;
+  // hintedActivated counts graph pulls that actually reached the walker —
+  // res.activated is raw expansion size and used to overstate what survived.
+  console.log(`Recall query — ${res.results.length} kept of ${scope} (seeds: ${res.seeds.packs} pack, ${res.seeds.entities} entity, ${res.seeds.tools} tool; graph-activated in hints: ${res.hintedActivated ?? 0} of ${res.activated})`);
   console.log(res.judged
     ? `Walker: ${w.provider || "?"}${w.model ? `/${w.model}` : ""} (${w.source}, ${w.ms}ms)`
     : `Walker: ${w.source === "off" ? "off" : "failed"} — UNJUDGED candidate list (fail-open)`);

package/core/recall/discoverer.js

@@ -232,6 +232,81 @@ function excerptFor(id, packsLib, entitiesLib) {
   } catch (e) { return null; }
 }
 
+// ── Catalog-first routing ────────────────────────────────────────────────────
+// The 2026-07-24 root-cause proof (diag-recall-ranking.js): lexical seeding +
+// the walker candidate cap silently CUT the known-true pack before the model
+// ever saw it — graph-activated nodes got zero candidate slots on full-seeded
+// turns. Catalog mode inverts the contract: the walker's SYSTEM prompt carries
+// the ENTIRE index (every pack/entity/tool as a one-liner, ~50KB for 276
+// nodes), so nothing is ever cut before a model sees it. Lexical seeds + graph
+// activation are demoted to per-turn RANKING HINTS (top-K with live excerpts).
+// The system prompt is set once per warm-walker session and is exempt from the
+// warm MAX_CHARS budget (which counts user-prompt chars only); per-turn hints
+// bridge catalog staleness within a session.
+const CATALOG_DESC_CHARS = 160;
+const CATALOG_TTL_MS = Number(process.env.RECALL_CATALOG_TTL_MS || 60000);
+let _catalog = null; // { at, key, text, ids, counts }
+
+function catalogLine(id, name, description) {
+  const d = String(description || "").replace(/\s+/g, " ").trim();
+  return `- ${id}: ${name}${d ? ` — ${clip(d, CATALOG_DESC_CHARS)}` : ""}`;
+}
+
+// Full-index catalog for the walker system prompt. Returns { text, ids, counts }
+// or null when the corpus libs can't enumerate (stub libs in old tests).
+// Cached ~60s keyed on the packs lib instance; staleness within the TTL (or a
+// warm walker session) is bridged by hints, which always reflect the live corpus.
+function buildCatalog(packsLib, entitiesLib) {
+  if (typeof packsLib.listPacks !== "function" || typeof entitiesLib.listEntities !== "function") return null;
+  const now = Date.now();
+  if (_catalog && _catalog.key === packsLib && now - _catalog.at < CATALOG_TTL_MS) return _catalog;
+  const ids = new Set();
+  const packLines = [];
+  const entLines = [];
+  const toolLines = [];
+  try {
+    for (const p of packsLib.listPacks()) {
+      if (!p || !p.dir || p.archived) continue;
+      ids.add(`pack:${p.dir}`);
+      packLines.push(catalogLine(`pack:${p.dir}`, p.name || p.dir, p.description));
+    }
+    for (const e of entitiesLib.listEntities()) {
+      if (!e || !e.slug) continue;
+      ids.add(`entity:${e.slug}`);
+      entLines.push(catalogLine(`entity:${e.slug}`, e.name || e.slug, e.description));
+    }
+  } catch (e) { return null; }
+  try {
+    for (const t of toolsLib.listTools()) {
+      if (!t || !t.name) continue;
+      ids.add(`tool:${t.name}`);
+      toolLines.push(catalogLine(`tool:${t.name}`, t.name, t.description));
+    }
+  } catch (e) { /* tools are optional in the catalog */ }
+  if (!ids.size) return null;
+  const text = [
+    `Packs (${packLines.length}) — topic knowledge; a kept pack injects its live Stance/State plus the lines matching the message:`,
+    ...packLines,
+    "",
+    `Entities (${entLines.length}) — people, systems, places:`,
+    ...entLines,
+    "",
+    `Tools (${toolLines.length}) — reusable CLIs the assistant can run:`,
+    ...toolLines,
+  ].join("\n");
+  _catalog = { at: now, key: packsLib, text, ids, counts: { packs: packLines.length, entities: entLines.length, tools: toolLines.length } };
+  return _catalog;
+}
+
+const WALKER_CATALOG_ADDENDUM = [
+  "Below is the COMPLETE catalog of the assistant's memory nodes.",
+  "Each message also brings RANKING HINTS: a few catalog nodes pre-ranked by keyword/graph overlap, shown with live excerpts, plus any matching past-conversation episodes.",
+  "Hints are hints, NOT the menu: you may keep ANY catalog node by its exact id, hinted or not. Prefer a directly-governing un-hinted node over a weakly-related hinted one.",
+  "Judge un-hinted nodes by their catalog line; hinted nodes by their excerpt.",
+  "",
+  "## Memory catalog",
+].join("\n");
+
 const WALKER_SYSTEM = [
   "You are the recall ROUTER for an assistant's long-term memory.",
   "You are given the user's message, recent conversation, and candidate memory nodes (some matched by keyword, some pulled in by graph links).",
@@ -263,11 +338,12 @@ async function runWalker(prompt, options = {}) {
     modelEnvPrefix: "RECALL_DISCOVERER_MODEL",
     legacyClaudeModelEnv: "RECALL_DISCOVERER_MODEL",
   });
+  const systemPrompt = options.systemPrompt || WALKER_SYSTEM;
   const opts = {
     provider: selection.provider,
     model: selection.model,
     tier: "low",
-    systemPrompt: WALKER_SYSTEM,
+    systemPrompt,
     timeoutMs: WALKER_TIMEOUT_MS,
   };
   if (warm.isEnabled(selection.provider)) {
@@ -296,7 +372,7 @@ async function runWalker(prompt, options = {}) {
     model: selection.model,
     modelEnvPrefix: "RECALL_DISCOVERER_MODEL",
     legacyClaudeModelEnv: "RECALL_DISCOVERER_MODEL",
-    systemPrompt: WALKER_SYSTEM,
+    systemPrompt,
     readOnly: true,
     timeoutMs: WALKER_TIMEOUT_MS,
     cwd: options.cwd || process.cwd(),
@@ -349,32 +425,45 @@ function cokeptPairs(keptIds, scoreById, groundedIds, { minScore = 60, maxPairs
 // kept is id→why(string); scores is the parallel id→0-100 relevance from the
 // router, consumed by the injection score-gate and asymmetric warming.
 async function walk(userText, contextText, candidates, options = {}) {
-  if (!WALKER_ENABLED || candidates.length === 0) {
+  const catalog = options.catalog || null;
+  if (!WALKER_ENABLED || (candidates.length === 0 && !catalog)) {
     return { kept: null, scores: null, costUsd: null, source: "off", walkerMs: 0, provider: options.provider || null, model: null };
   }
   const lines = candidates.map((c) => {
     const tag = c.activated ? ` [linked via ${c.via || "graph"}]` : "";
     return `- ${c.id}: ${c.name}${tag}${c.description ? `\n    ${c.description}` : ""}${c.excerpt ? `\n    excerpt: ${c.excerpt.replace(/\n/g, " ")}` : ""}`;
   });
+  const header = catalog
+    ? (lines.length
+      ? "Ranking hints — pre-ranked candidates with live excerpts (the full catalog in your instructions stays fully eligible):"
+      : "No pre-ranked hints this turn — route from the catalog in your instructions.")
+    : "Candidate memory nodes:";
+  const exampleId = candidates.length ? candidates[0].id : "pack:example";
   const prompt = [
     "User message:",
     "<<<", clip(String(userText || ""), 1500), ">>>",
     ...(contextText ? ["", "Recent conversation:", "<<<", clip(String(contextText), CONTEXT_CLIP), ">>>"] : []),
     "",
-    "Candidate memory nodes:",
+    header,
     ...lines,
     "",
-    'Reply ONLY with the JSON array of kept nodes, each with id, why, and score (0–100), e.g. [{"id":"' + candidates[0].id + '","why":"...","score":80}].',
+    'Reply ONLY with the JSON array of kept nodes, each with id, why, and score (0–100), e.g. [{"id":"' + exampleId + '","why":"...","score":80}].',
   ].join("\n");
+  // Catalog rides in the SYSTEM prompt: set once per warm session (exempt from
+  // the warm walker's per-message char budget) and identical on the cold path.
+  const walkOptions = catalog
+    ? { ...options, systemPrompt: `${WALKER_SYSTEM}\n${WALKER_CATALOG_ADDENDUM}\n${catalog.text}` }
+    : options;
   const t0 = Date.now();
   try {
-    const { text, costUsd, source, provider, model } = await runWalker(prompt, options);
+    const { text, costUsd, source, provider, model } = await runWalker(prompt, walkOptions);
     const walkerMs = Date.now() - t0;
     const match = String(text || "").match(/\[[\s\S]*\]/);
     if (!match) return { kept: null, scores: null, costUsd, source, walkerMs, provider, model };
     const arr = JSON.parse(match[0]);
     if (!Array.isArray(arr)) return { kept: null, scores: null, costUsd, source, walkerMs, provider, model };
     const known = new Set(candidates.map((c) => c.id));
+    if (catalog && catalog.ids) for (const id of catalog.ids) known.add(id);
     const out = new Map();
     const scores = new Map();
     for (const item of arr) {
@@ -447,10 +536,19 @@ async function run(ctx) {
   }
   const expandMs = Date.now() - expandStarted;
 
+  // Catalog-first (full tier): the walker's system prompt carries the ENTIRE
+  // index, so membership is never decided by lexical scoring or the candidate
+  // cap — those now only rank which few nodes get live excerpts as hints.
+  let catalog = null;
+  if (tier === "full" && tuning.get("catalog") !== "off") {
+    try { catalog = buildCatalog(packsLib, entitiesLib); } catch (e) { catalog = null; }
+  }
+
   // 4: assemble candidates (seeds + activated) in priority order — user seeds
   // by score, then context seeds, then graph-activated by activation — capped
   // at MAX_WALKER_CANDIDATES so the walker prompt stays small and fast. Only
   // the full tier pays for excerpts; the seeds tier never reads them.
+  // Under catalog mode these are ranking hints; without it they are the menu.
   const seedRank = new Map();
   for (const m of packSeeds) seedRank.set(`pack:${m.dir}`, { score: m.score || 2, origin: m.origin });
   for (const m of entSeeds) seedRank.set(`entity:${m.slug}`, { score: m.score || 2, origin: m.origin });
@@ -473,16 +571,16 @@ async function run(ctx) {
   }
   const candIds = new Set(tier === "full" ? candidates.map((c) => c.id) : seedIds);
 
-  // Tool candidates = direct tool seeds + tools that belong to any candidate
-  // pack (declared via the tool's `pack:` header, or used-in-topic per the
-  // tool-graph). This is the tool "activation": tools ride on whatever packs the
-  // FTS+graph already surfaced, so a pack seed pulls in its tools the user never
-  // named — then the walker decides which actually help. via != null => activated.
+  // Tool candidates = direct tool seeds + (catalog off only) tools that belong
+  // to any candidate pack (declared via the tool's `pack:` header, or used-in-
+  // topic per the tool-graph). Under catalog mode every tool is already in the
+  // walker's view as a catalog line, so pack-riding is redundant — direct seeds
+  // still join as hints because they carry usage/shape excerpts.
   const candPackDirs = new Set();
   for (const id of candIds) if (id.startsWith("pack:")) candPackDirs.add(id.slice(5));
   const toolCand = new Map();
   for (const [name, t] of toolSeedByName) toolCand.set(name, { name, description: t.description, via: null });
-  if (tier === "full" && candPackDirs.size) {
+  if (tier === "full" && !catalog && candPackDirs.size) {
     try {
       const byPack = new Map();
       for (const t of toolsLib.listTools()) {
@@ -547,7 +645,10 @@ async function run(ctx) {
   // continuously audited against the model it replaces; on shadowed candidates
   // the judge's verdict wins. Top-3 ranked candidates and episodes (no stable
   // history) always go to the judge.
-  const cascadeOn = tier === "full" && tuning.get("cascade") !== "off";
+  // Catalog mode bypasses the cascade: an auto-drop would strip a hint's
+  // excerpt on history alone, and history auto-keeps are the sticky-pack leak
+  // the score gate exists to stop. Never-cut principle: the judge sees it all.
+  const cascadeOn = tier === "full" && !catalog && tuning.get("cascade") !== "off";
   // Score-gate config (WS4). When a relevance floor is set, the walker's real
   // per-turn score decides injection — so the cascade must NOT auto-KEEP from
   // history: a sticky pack's history score is always high and would re-leak the
@@ -577,7 +678,7 @@ async function run(ctx) {
     }
   }
 
-  const walkRes = await walk(userText, contextText || fullContext, judgeCands, { provider: provider || null, ...(ctx.walkerOptions || {}) });
+  const walkRes = await walk(userText, contextText || fullContext, judgeCands, { provider: provider || null, catalog, ...(ctx.walkerOptions || {}) });
   const whyById = walkRes.kept;
   const scoreById = walkRes.scores; // parallel id→0-100 router relevance (null on fail-open)
 
@@ -686,6 +787,14 @@ async function run(ctx) {
       toolMatches.push({ name: c.name, description: c.description, why: whyMap ? whyMap.get(`tool:${c.name}`) || "" : "" });
     }
   }
+  // Catalog picks: a kept tool the hint set never carried still renders.
+  for (const id of keptIds) {
+    if (!id.startsWith("tool:") || toolCand.has(id.slice(5))) continue;
+    try {
+      const t = toolsLib.findTool(id.slice(5));
+      if (t) toolMatches.push({ name: t.name, description: t.description, why: whyMap ? whyMap.get(id) || "" : "" });
+    } catch (e) {}
+  }
   let toolBlock = "";
   if (toolMatches.length) {
     // Tiered injection (Phase 2): a 2-line headline per tool — identity line
@@ -755,6 +864,7 @@ async function run(ctx) {
     seeds: seedNodes,
     activated: [...activated.entries()].map(([id, a]) => ({ id, activation: a.activation, hop: a.hop })),
     cand: candidates.map((c) => ({ id: c.id, act: !!c.activated })),
+    catalog: catalog ? catalog.counts : undefined,
     kept: [...keptIds].map((id) => ({ id, why: whyMap ? whyMap.get(id) : "", score: scoreById && scoreById.has(id) ? scoreById.get(id) : null })),
     auto: (autoKept.size || autoDropped.length || shadowChecks)
       ? { kept: [...autoKept.keys()], dropped: autoDropped, shadow: { checks: shadowChecks, agree: shadowAgree } }
@@ -778,4 +888,4 @@ async function run(ctx) {
   };
 }
 
-module.exports = { name: "discoverer", run, runWalker, needsRecall, recallTier, walk, excerptFor, cascadeVerdict, cokeptPairs, scoutToolGaps, renderToolGaps, episodesAllowedForSpeaker };
+module.exports = { name: "discoverer", run, runWalker, needsRecall, recallTier, walk, excerptFor, buildCatalog, cascadeVerdict, cokeptPairs, scoutToolGaps, renderToolGaps, episodesAllowedForSpeaker };

package/core/recall/query.js

@@ -90,6 +90,14 @@ async function query(question, opts = {}) {
     try { activated = graph.expand(seedNodes, {}); } catch (e) {}
   }
 
+  // Catalog-first: same contract as the per-turn engine — the walker sees the
+  // whole index in its system prompt; seeds/activation below only rank which
+  // hints carry excerpts. Null when the corpus libs can't enumerate (stubs).
+  let catalog = null;
+  if (tuning.get("catalog") !== "off") {
+    try { catalog = discoverer.buildCatalog(packsLib, entitiesLib); } catch (e) { catalog = null; }
+  }
+
   // Candidates: question seeds by score, context seeds, then graph-activated.
   const seedRank = new Map();
   for (const m of packSeeds) seedRank.set(`pack:${m.dir}`, { score: m.score || 2, origin: m.origin });
@@ -151,18 +159,32 @@ async function query(question, opts = {}) {
     } catch (e) { /* episodic recall is best-effort */ }
   }
 
+  const hintedCount = candidates.length;
+  const hintedActivated = candidates.filter((c) => c.activated && (c.id.startsWith("pack:") || c.id.startsWith("entity:"))).length;
+
   // Walker judgement (cold spawn only). opts.walker === false skips the spawn.
   let walkRes = { kept: null, scores: null, source: "off", walkerMs: 0, provider: null, model: null, costUsd: null };
-  if (opts.walker !== false && candidates.length) {
+  if (opts.walker !== false && (candidates.length || catalog)) {
     walkRes = await discoverer.walk(q, context, candidates, {
       warmWalker: COLD_ONLY_WARM,
       cwd: opts.cwd,
+      catalog,
       ...(opts.walkerOptions || {}),
     });
   }
   const whyMap = walkRes.kept;
   const scores = walkRes.scores;
 
+  // Catalog picks outside the hint set still return — excerpt them on demand.
+  if (whyMap) {
+    const candIds = new Set(candidates.map((c) => c.id));
+    for (const id of whyMap.keys()) {
+      if (candIds.has(id)) continue;
+      const base = discoverer.excerptFor(id, packsLib, entitiesLib);
+      if (base) candidates.push({ ...base, activated: true, via: "catalog" });
+    }
+  }
+
   const results = [];
   for (const c of candidates) {
     if (whyMap && !whyMap.has(c.id)) continue;
@@ -205,7 +227,9 @@ async function query(question, opts = {}) {
     hasContext: !!context,
     seeds: { packs: packSeeds.length, entities: entSeeds.length, tools: toolSeeds.size },
     activated: activated.size,
-    candidates: candidates.length,
+    hintedActivated,
+    candidates: hintedCount,
+    catalog: catalog ? catalog.counts : null,
     judged: !!whyMap,
     walker: {
       source: walkRes.source,
@@ -227,6 +251,7 @@ async function query(question, opts = {}) {
       seeds: seedNodes,
       activated: [...activated.entries()].map(([id, a]) => ({ id, activation: a.activation, hop: a.hop })),
       cand: candidates.map((c) => ({ id: c.id, act: !!c.activated })),
+      catalog: catalog ? catalog.counts : undefined,
       kept: results.map((r) => ({ id: r.id, why: r.why, score: r.score })),
       gated: false,
       latencyMs: out.latencyMs,

package/core/recall/tuning.js

@@ -18,6 +18,11 @@ const KNOBS = {
   seedsTierMaxWords: { def: 4, min: 2, max: 6, env: "RECALL_SEEDS_TIER_MAX_WORDS" },
   decayHalfLifeDays: { def: 60, min: 10, max: 90, env: "RECALL_DECAY_HALF_LIFE_DAYS" },
   cascade: { def: "on", values: ["on", "off"], env: "RECALL_CASCADE" },
+  // Catalog-first routing: the walker's system prompt carries the ENTIRE
+  // pack/entity/tool index; lexical seeds + graph activation become ranking
+  // hints (top-K excerpts), never a membership cut. "off" restores the legacy
+  // capped-candidate menu (and re-enables cascade + tool pack-riding).
+  catalog: { def: "on", values: ["on", "off"], env: "RECALL_CATALOG" },
   // Extractive on-open injection: surface Stance verbatim + the actual lines
   // that matched this message (from anywhere in the pack), not just a headline.
   extractive: { def: "on", values: ["on", "off"], env: "RECALL_EXTRACTIVE" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.23",
+  "version": "3.1.24",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-provider-language.js

@@ -288,7 +288,21 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // owner) without explicit coverage while disclosure, commitments, and actions
 // stay held for escalation; approval cards say where the message came from
 // via the optional adapter channelLabel (kazee chat name, spaces task title).
-assert.strictEqual(pkg.version, "3.1.23", "release version must remain unchanged without explicit approval");
+// 3.1.24 approved by Sumeet 2026-07-24 ("Okay, I think that makes sense, so go
+// ahead and implement that and then push it out"): catalog-first recall — the
+// proven 4-layer candidate-starvation (diag-recall-ranking.js: lexical seed
+// scoring, junk-seed fire threshold, hub fan-out topK, and a dream-tuned
+// walker cap of 10 vs exactly 10 seeds leaving graph-activated nodes ZERO
+// slots since 2026-07-09) is fixed by inverting the contract: the walker's
+// SYSTEM prompt now carries the ENTIRE pack/entity/tool index (one-liners,
+// warm-session cached, exempt from the warm per-message char budget) so
+// nothing is ever cut before a model sees it; lexical seeds + graph
+// activation demote to per-turn ranking HINTS (top-K excerpts); the walker
+// may keep ANY catalog id; cascade + tool pack-riding bypass under catalog
+// mode; recall query mirrors it and the CLI banner reports honest
+// hint-survival instead of raw expansion counts; catalog knob (dream-tunable,
+// RECALL_CATALOG pin) restores the legacy menu.
+assert.strictEqual(pkg.version, "3.1.24", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }