@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/src/summarize.js

@@ -9,6 +9,8 @@ import { createScopeResolver } from "./scope.js";
 // #493 补充 §③：断链与巩固侧同一份实现（src/fence.js）。转录里出现闭合标记时
 // 原先能提前闭合围栏——那是把用户消息升格成指令最短的一条路。
 import { breakFenceMarkers } from "./fence.js";
+// Issue #611：图片块的文本口径（占位，不是空串）。三个 textOf 副本共用这一份。
+import { contentToText, countImages } from "./attachment-text.js";
 // #512：每轮蒸馏一个 run id（归因主体）。store 侧也能铸造，但这里必须知道它——
 // 写记忆时要把它一路带到 saveMemoryProvenance / 落 run 行，拿回来再写就是两次往返。
 import { randomUUID } from "node:crypto";
@@ -292,13 +294,13 @@ const SUBAGENT_MESSAGE_KINDS = new Set(["agent-message", "subagent-settled"]);
 
 // 兼容严格形状 [{type:"text",text}] 与宽松形状 ["字符串", ...]（lib-smoke 用例
 // 直接传字符串数组）。只取公开文本块；reasoning 私有推理块不进蒸馏上下文。
+//
+// Issue #611：图片块曾经在这里一律变空串，于是图-only 消息整条被丢、图+文消息只剩
+// 文字——静默，没有任何计数。现在改由 attachment-text 统一产占位，
+// `[图: 屏幕截图 … 1543x983]`。抽取口径只有一份，三个调用方（本文件 /
+// continuity / hot-memory）共用，避免同一件事写成三份会漂移的实现。
 function textOf(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .map((block) => (typeof block === "string" ? block : (block && block.type === "text" && typeof block.text === "string" ? block.text : "")))
-    .filter((s) => s)
-    .join("\n");
+  return contentToText(content);
 }
 
 /**
@@ -333,6 +335,10 @@ function publicTranscriptParts(event) {
     parts.push({
       role: "agent",
       text,
+      // Issue #611：把产文本的那份 content 一起带出去。判定与文本同源，计量才能
+      // 跟着同一份判定走（见 collectMessages 里的 imageCount）——另写一套「哪些块
+      // 算公开」给计量用，就是第二份实现，迟早与这份漂移。
+      blocks: Array.isArray(message?.content) ? message.content : [],
       // 同一条子会话消息可能同时出现在 user/message 与 agent/inbox/spliced
       // 里（投递路径重叠），按 id（无 id 时按内容）去重，否则转录会重复。
       key: typeof message?.id === "string" && message.id
@@ -346,7 +352,7 @@ function publicTranscriptParts(event) {
       const text = textOf(data?.content);
       if (!text.trim()) break;
       if (SUBAGENT_MESSAGE_KINDS.has(kind)) pushAgentMessage(data);
-      else parts.push({ role: "user", text });
+      else parts.push({ role: "user", text, blocks: Array.isArray(data?.content) ? data.content : [] });
       break;
     }
     case "agent/inbox/spliced": {
@@ -358,7 +364,7 @@ function publicTranscriptParts(event) {
       const blocks = Array.isArray(data?.message?.content) ? data.message.content : [];
       const text = textOf(blocks);
       // 私有推理块（reasoning）刻意不采集：蒸馏记忆不得沉淀模型私有思考链。
-      if (text.trim()) parts.push({ role: "assistant", text });
+      if (text.trim()) parts.push({ role: "assistant", text, blocks });
       break;
     }
     default:
@@ -395,6 +401,10 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
   const events = snapshotSessionEvents(session, afterSeq, throughSeq);
   const lines = [];
   const seenSubagentMessages = new Set();
+  // Issue #611：这一窗里被折成占位的图片张数。占位本身不丢信息，但「折了几张」
+  // 必须是个能读到的数——否则 off 档和旧版静默丢弃在观测上无法区分，下次再有人
+  // 问「图到底进来没有」还是得翻源码。计量只数窗口内事件，不受截断影响。
+  let imageCount = 0;
   const trim = (s, n) => (typeof s === "string" && s.length > n ? `${s.slice(0, n)}…` : s);
   const trimTranscript = (s, n) => {
     if (typeof s !== "string" || s.length <= n) return s;
@@ -421,9 +431,20 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
       if (part.role === "agent") {
         if (part.key && seenSubagentMessages.has(part.key)) continue;
         if (part.key) seenSubagentMessages.add(part.key);
-        lines.push(STR.transcriptAgent[language](part.text));
-      } else if (part.role === "user") {
+      }
+      // Issue #611 计量：数「真正进了转录的图块」，所以按 part 数、并且在去重之后
+      // ——同一条子会话消息会同时出现在 user/message 与 agent/inbox/spliced 里
+      // （投递路径重叠），按事件数会把它算两遍。
+      //
+      // 不按事件数还有个更要紧的理由：被 publicTranscriptParts 挡掉的注入消息
+      // （工具结果、插件注入、陌生 source.kind）里的图根本进不了转录，按事件累加
+      // 会报「这一窗有 2 张图」而转录里一张都没有。part 是渲染与落盘共用的同一份
+      // 判定，计量跟着它走，两处不会再各有一套口径。
+      imageCount += countImages(part.blocks);
+      if (part.role === "user") {
         lines.push(STR.transcriptUser[language](part.text));
+      } else if (part.role === "agent") {
+        lines.push(STR.transcriptAgent[language](part.text));
       } else {
         lines.push(STR.transcriptAssistant[language](part.text));
       }
@@ -485,6 +506,9 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
       : [],
     hasEvents: events.length > 0,
     lastSeq,
+    // Issue #611：这一窗折成占位的图片张数。调用方把它写进审计 metadata，
+    // 让「图进来了几张」成为可对账的事实而不是推断。
+    imageCount,
     // Issue #493：只数**转录正文**的字符数。minWindowChars 闸门与审计里的
     // distillChars 量的都是「这一窗有多少可提炼内容」，不是「我们额外包了多少
     // 提示词」——若把围栏与角色句算进去，一条「短」也会凭空越过任何阈值，
@@ -850,6 +874,7 @@ export function createSummarizer(ctx, service, config, deps = {}, sessionGate =
         0
       );
       const minWindowChars = config.summarizeMinWindowChars ?? 0;
+      const imageCount = collected.imageCount ?? 0;
       if (minWindowChars > 0 && distillChars < minWindowChars) {
         commitCursor(session.id, nextSeq);
         writeAudit({
@@ -857,7 +882,7 @@ export function createSummarizer(ctx, service, config, deps = {}, sessionGate =
           model_id: route ? `${route.provider}:${route.model}` : "unknown",
           status: "skipped",
           error_message: "window-too-small",
-          metadata: { distillChars, minWindowChars }
+          metadata: { distillChars, minWindowChars, ...(imageCount > 0 ? { imageCount } : {}) }
         });
         return;
       }
@@ -1064,6 +1089,7 @@ export function createSummarizer(ctx, service, config, deps = {}, sessionGate =
           audit.errorMessage = failureAudit.errorMessage;
           audit.metadata = {
             distillChars,
+            ...(imageCount > 0 ? { imageCount } : {}),
             ...failureAudit.metadata,
             streak,
             ...(maxParseRetries > 0 ? { maxRetries: maxParseRetries } : {}),
@@ -1203,6 +1229,7 @@ export function createSummarizer(ctx, service, config, deps = {}, sessionGate =
       if (audit) {
         audit.metadata = {
           distillChars,
+          ...(imageCount > 0 ? { imageCount } : {}),
           parsed: parsed.length,
           ...(parsedResult.salvaged ? { json_salvaged: true } : {}),
           ...(capped > 0 ? { capped } : {}),

package/src/tools.js

@@ -9,8 +9,18 @@ import { TOOL_GUIDE, CONTINUITY_TOOL_RULE } from "./guide.js";
 import { injectChildEnabled } from "./config.js";
 import { normalizeScopeStateDimension, normalizeScopeStateValue, normalizeScopeStateState } from "./scope-state.js";
 import { lastUserQuery } from "./inject.js";
+// issue #607：工具报错里的 CLI 命令同样要给绝对路径入口——profile 装的插件没有
+// 全局 shim，光写 `dsh-mneme-choro` 用户照抄只会 command not found。
+import { choroCliCommandFrom } from "./wiki/cli-hint.js";
+// 知识库三工具（契约 §3.4）：定义住在 kb/tools.js，本文件只决定注册不注册。
+import { kbToolDefinitions } from "./kb/tools.js";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
+// 工具报错里的命令串：本文件在 src/ 与 lib/ 同一层（bin/ 的父级），模块加载时推导一次。
+// 推导不出（源码树被裁剪）就返回 null，文案退回通用说法。
+const CHORO_CLI = choroCliCommandFrom(import.meta.url, "<repo>");
+const incompleteChoroSearch = (pages) =>
+  `Search was incomplete because these pages could not be read (${pages.join(", ")}). Check the local checkout and page permissions.`;
 // Per-registry tool-name registry: guards against duplicate registration on
 // live patch reload (DSH Desktop `patchReload: "live"`) where a plugin may be
 // re-applied on the same tools registry without an intervening unregister.
@@ -79,7 +89,8 @@ const MEMORY_PROVENANCE = (m) => {
 // choro（M1）：chorography 只读查询对象（createChoroQueries 产物）。缺省 null =
 // 装配层没接（headless/测试），三个 choro_* 工具走 hiddenTools 闸根本不注册。
 // 它与 service 刻意分开传——chorography 的所有权模型与记忆域相反（spec §3）。
-export function createTools(ctx, service, config, embedder, sessionGate = null, choro = null) {
+// kb：知识库装配对象（createKb 产物）；缺省 null = 宿主没装它，三个 kb 工具不注册。
+export function createTools(ctx, service, config, embedder, sessionGate = null, choro = null, kb = null) {
   const toolsRegistry = ctx.tools;
   let registration = REGISTERED_TOOLS.get(toolsRegistry);
   if (!registration) {
@@ -92,14 +103,17 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
   // flag 关闭时恒返回 null——写入不标注，检索不加权，行为与 A1 前完全一致。
   // logger 透传：registry 反查失败时 warnOnce 才有出口（否则静默降级无观测）。
   const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
-  // choro 工具共用的 repo 解析（M1）：不带 repo 且只有一个登记仓时自动收敛；
-  // 多仓歧义时把可选清单带回给模型（render 层会把它转成人话）。三个 execute 里
-  // 都先走这里，错误形状统一 { error, ... }，output.schema 容忍多余键由
-  // additionalProperties:false + render 兜底——错误分支直接透传给渲染层判。
+  // 宿主在 render 前按成功 schema 校验返回值，仓库解析失败要走工具错误通道。
   const resolveChoroRepo = (ref) => {
-    const row = choro ? choro.resolveRepo(ref) : null;
-    if (!row) return { error: "no-repos", hint: "run `dsh-mneme-choro <repo> --apply` first (registers the repository)" };
-    if (row.ambiguous) return { error: "repo-ambiguous", repos: row.ambiguous, hint: "pass repo id or name" };
+    const row = choro.resolveRepo(ref);
+    if (!row) {
+      const reason = ref ? `Repository ${JSON.stringify(ref)} is not registered.` : "No repository is registered for chorography.";
+      throw new Error(`${reason} ${CHORO_CLI ? `Run \`${CHORO_CLI}\`` : "Run `dsh-mneme-choro <repo> --apply`"} to register a repository.`);
+    }
+    if (row.ambiguous) {
+      const choices = row.ambiguous.map(({ id, name }) => `${id} (${name})`).join(", ");
+      throw new Error(`More than one repository is registered. Pass one of these repository IDs (${choices}).`);
+    }
     return row;
   };
   // #249 能力说明（injectGuidanceEnabled）：开启时给「何时用」最有歧义的两个
@@ -448,7 +462,11 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
       name: "memory_forget",
       description:
         "Stop a memory from being auto-injected and from appearing in searches and lists without deleting it. " +
-        "The entry stays in storage; pass forgotten: false to restore it.",
+        "The entry stays in storage; pass forgotten: false to restore it. " +
+        "#532: suppression is per ROW - facts fused into the same entry leave visibility together. " +
+        "When the request targets one fact among several held by a row, inspect the row first (memory_get), " +
+        "split it with memory_update if needed, or say in your reply what else the suppression took down " +
+        "(docs/FORGET.md records the supersession gap behind this).",
       parameters: {
         id: { type: "string", required: true },
         forgotten: { type: "boolean", description: "Suppress (true, default) or restore (false) the entry's visibility" }
@@ -479,6 +497,110 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
       }
     }),
 
+    // #249 第二批：显式 pin。注入侧原来靠「type 是 constraint/preference 就算
+    // 重要」推断谁该每轮置顶，那是隐含假设——库里 1100+ 条自动成了「每轮必进」
+    // 的候选而预算只有 5，真正该进去的反而排到二十名外。这个工具是那条推断的
+    // 唯一人工替代口：钉住 = 每轮注入块最前面那几条（受 pinnedInjectBudget 约束），
+    // 与类型无关（写得最全的那版常常是 pattern）。
+    //
+    // 三个边界写在这里：
+    // - 它不改记忆内容，也不改任何「记忆行」字段，只动 pinned_memories 这张关系
+    //   表，所以与 memory_forget / memory_archive / set_scope_state 都是**不同的轴**：
+    //   遗忘/归档/暂停作用域仍然优先——被它们处理掉的行就算钉着也不会注入，
+    //   回执里的 injectable 就是如实告诉我们这件事。
+    // - 存在性校验走 visibleForTool：strictScope 下 he scope 的行按「不存在」处理，
+    //   与 memory_delete 同款无存在性泄漏。
+    // - unpin 幂等：本来没钉也返回 pinned:false，不报错。
+    defineTool({
+      name: "memory_pin",
+      description:
+        "Pin a memory so it is injected at the top of the memory block every turn, regardless of its type or how it ranks against other memories. " +
+        "Use this only when the user explicitly says an entry must always be present (a hard rule, a standing preference); it is not a way to mark something as important — importance already affects ranking. " +
+        "Pinned entries still obey forgetting, archiving, the scope gate and the two injection switches: when autoInject is off the host registers no injector at all, and when pinnedInjectBudget is 0 the pin pool is off (its default). In either case a pinned entry is not injected through the pin channel, and the receipt reports injectable: false. The receipt answers \"is the pin channel open right now\", not \"is this memory kept out of every block\": a row reported false can still be picked up by the ordinary candidate path on its own merits. " +
+        "Pass unpin: true to release it. Pin order is first-pinned-first, so the oldest pin holds its slot when the budget is tight.",
+      parameters: {
+        id: { type: "string", required: true, description: "Memory id to pin (or unpin with unpin: true)" },
+        note: { type: "string", description: "Optional short reason to keep with the pin, so a later reader knows why it is pinned" },
+        unpin: { type: "boolean", description: "true releases the pin instead of setting it" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory_id: { type: "string", required: true },
+            pinned: { type: "boolean", required: true },
+            // 如实回显库现值，不是回显入参：重钉一条已有的 pin 不刷新 created_at，
+            // 回显它才看得出「这次其实没改变顺序」。
+            created_at: { type: "string" },
+            note: { type: "string" },
+            // 钉着 ≠ 会注入。遗忘/归档/暂停作用域/autoInject 关/pinnedInjectBudget=0
+            // 都优先于 pin，把这件事放进回执，而不是让用户以为钉完就一定出现在上下文里。
+            // 回执回答的是「pin 这条通道此刻开不开」：报 false 不等于这条记忆一定不在
+            // 上下文里——它仍可能凭自身重要性走常规候选路进块。
+            // autoInject 是这条通道的总闸：关着时宿主根本不注册注入器
+            // （src/index.js:617 的 if (cfg.autoInject)），pin 段自然也不执行。
+            injectable: { type: "boolean", required: true }
+          }
+        },
+        render: (_args, value) => {
+          if (!value.pinned) return TEXT_OUTPUT(`Memory ${value.memory_id} is no longer pinned.`);
+          const when = value.created_at ? ` (pinned at ${value.created_at})` : "";
+          const blocked = value.injectable
+            ? ""
+            : " The pin channel is closed right now (forgotten, archived, inside a paused scope, autoInject off, or pinnedInjectBudget is 0 — the pin pool is off by default), so it is not placed at the top of the block; the ordinary candidate path can still pick it up on its own merits.";
+          return TEXT_OUTPUT(`Memory ${value.memory_id} is pinned${when}.${blocked}`);
+        }
+      },
+      async execute(args) {
+        // 不可见（explicit 他 scope）= 视作不存在，无存在性泄漏。
+        const target = visibleForTool(args.id, arguments[1]);
+        if (target === undefined) throw new Error("memory not found");
+        // 钉着 ≠ 会注入。这里必须跟注入侧用同一个出口判定，否则回执照样会说谎：
+        // 暂停作用域的行在 enforce 档会被 scopeStateGate 剔掉，但 forgotten/archived
+        // 两个标志位对此一无所知——只算这两项，一条被暂停作用域挡住的行就会报
+        // injectable: true 而实际一条都没注入。filterPaused 正是那个出口（开关关、
+        // 或只开观察档时它原样返回，于是此时报 true 是对的：那种状态下本来就不拦）。
+        // #593 遗留缺口：pin 池整体由 pinnedInjectBudget 开关（src/service.js:1885 的
+        // pinnedBudget > 0 才读表选路），而它默认 0 = 关闭。只看遗忘/归档/暂停作用域时，
+        // 预算为 0 的一条回执照样报 injectable: true——钉住的动作确实成功了，但它此刻
+        // 一条都不会被注入，这正是「返回成功不等于生效」。预算 0 必须报 false。
+        //
+        // 同一类谎话的第二处（CodeRabbit 在 #596 指出）：autoInject 才是 pin 通道的总闸
+        // ——关着时 src/index.js:617 根本不注册注入器，pin 段无从执行，而回执仍会报
+        // true。config schema 里它的默认值是 true（src/config.js:10），所以按「只有显式
+        // false 才算关」判：拿不到已填 defaults 的 config（测试直连 createTools）时不会
+        // 被误报成 false。
+        //
+        // 仍然没建模的：候选池侧的 type / importance / codingGate 闸（一条被钉的
+        // document 行同样进不了注入块）。那几道闸随候选池变化，回执不做猜测；
+        // 这里只回答「pin 这条通道此刻开不开」——报 false 也不等于这条记忆一定不在
+        // 上下文里，它仍可能凭自身重要性走常规候选路进块。
+        const pinnedBudget = Math.max(0, Math.min(5, Math.floor(config?.pinnedInjectBudget ?? 0)));
+        const autoInjectOn = config?.autoInject !== false;
+        const injectable =
+          autoInjectOn &&
+          pinnedBudget > 0 &&
+          !target.forgotten &&
+          !target.archived &&
+          service.filterPaused([target]).length > 0;
+        if (args.unpin === true) {
+          service.unpinMemory(target.id);
+          return { memory_id: target.id, pinned: false, injectable };
+        }
+        const row = service.pinMemory(target.id, { note: args.note });
+        if (row === undefined) throw new Error("pin could not be recorded");
+        return {
+          memory_id: row.memory_id,
+          pinned: true,
+          created_at: row.created_at,
+          // 没写过理由时键整个不出现（output schema 是闭合的，留 undefined 等于空壳）。
+          ...(row.note === undefined ? {} : { note: row.note }),
+          injectable
+        };
+      }
+    }),
+
     defineTool({
       name: "memory_archive",
       description:
@@ -1081,7 +1203,6 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
       },
       async execute(args) {
         const repo = resolveChoroRepo(args?.repo);
-        if (repo.error) return repo;
         const { modules, edges } = choro.moduleMap(repo.id);
         return { repo: repo.name, modules, edges };
       }
@@ -1107,10 +1228,16 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
       },
       async execute(args) {
         const repo = resolveChoroRepo(args?.repo);
-        if (repo.error) return repo;
         const page = choro.readPage(repo.id, args?.slug);
-        if (!page) return { error: "page-not-found", slug: String(args?.slug ?? ""), hint: "use choro_module_map to list slugs" };
-        if (page.error) return page;
+        if (!page) {
+          throw new Error(`Page ${JSON.stringify(args?.slug ?? "")} was not found. Use choro_module_map to list page slugs.`);
+        }
+        if (page.error === "page-missing") {
+          throw new Error(`Page ${JSON.stringify(page.slug)} is missing from disk (${page.relPath}). Check the local checkout or run ${CHORO_CLI ? `\`${CHORO_CLI}\`` : "`dsh-mneme-choro <repo> --apply`"} to rebuild it.`);
+        }
+        if (page.error) {
+          throw new Error(`Page ${JSON.stringify(page.slug)} could not be read (${page.relPath}). Check the local file and its permissions.`);
+        }
         return { slug: page.slug, content: page.content };
       }
     }),
@@ -1129,26 +1256,29 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
           type: "object",
           additionalProperties: false,
           properties: {
-            hits: { type: "array", required: true, items: { type: "object", additionalProperties: true } }
+            hits: { type: "array", required: true, items: { type: "object", additionalProperties: true } },
+            unreadablePages: { type: "array", items: { type: "string" }, description: "Page slugs that could not be read during the search" }
           }
         },
         render: (_args, value) => {
-          const hits = value.hits ?? [];
+          const { hits, unreadablePages } = value;
           if (hits.length === 0) return TEXT_OUTPUT("0 hits.");
-          return TEXT_OUTPUT(hits
-            .map((hit) => `${hit.slug} · ${hit.section} · L${hit.line}: ${hit.excerpt}`)
-            .join("\n"));
+          const lines = hits.map((hit) => `${hit.slug} · ${hit.section} · L${hit.line}: ${hit.excerpt}`);
+          if (unreadablePages?.length) lines.push("", incompleteChoroSearch(unreadablePages));
+          return TEXT_OUTPUT(lines.join("\n"));
         }
       },
       async execute(args) {
         const repo = resolveChoroRepo(args?.repo);
-        if (repo.error) return repo;
-        return {
-          hits: choro.search(repo.id, args?.query, {
-            moduleSlug: args?.module ?? null,
-            limit: args?.limit
-          })
-        };
+        const unreadablePages = [];
+        const hits = choro.search(repo.id, args?.query, {
+          moduleSlug: args?.module ?? null,
+          limit: args?.limit,
+          onUnreadablePage: (slug) => unreadablePages.push(slug)
+        });
+        if (unreadablePages.length === 0) return { hits };
+        if (hits.length === 0) throw new Error(incompleteChoroSearch(unreadablePages));
+        return { hits, unreadablePages };
       }
     })
   ];
@@ -1172,6 +1302,24 @@ export function createTools(ctx, service, config, embedder, sessionGate = null,
     hiddenTools.add("choro_read_page");
     hiddenTools.add("choro_search");
   }
+  // 知识库三工具（契约 §3.4）：与 choro 同款反向语义。装配缺件（kb 为 null）与没开
+  // 对模型同样不可见——可区分性归路由层（503 / 409），模型侧不需要看见半个知识库。
+  if (config?.kbEnabled !== true || !kb) {
+    hiddenTools.add("kb_list_collections");
+    hiddenTools.add("kb_search");
+    hiddenTools.add("kb_read_doc");
+  }
+
+  // 知识库工具定义在 kb/tools.js。**必须过 defineTool**：那里返回的是「describe 形状」
+  // （属性上的 required:true、output.schema 用 spec 写法），直接 ctx.tools.register
+  // 会被宿主的 JSON Schema 校验拒（"required is not supported on type string"）——
+  // 这是接线时踩到的真故障，不是可选加工。判定按 parameters.type==="object" 分：
+  // 已经是 JSON Schema 的说明调用方自己包过，再包一次会把 schema 转坏。
+  if (typeof kbToolDefinitions === "function") {
+    for (const def of kbToolDefinitions({ kb, cfg: config })) {
+      tools.push(def?.parameters?.type === "object" ? def : defineTool(def));
+    }
+  }
 
   for (const tool of tools) {
     if (hiddenTools.has(tool.name)) {