@capybara-hq/kernel 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/tools/registry.d.ts

@@ -1,4 +1,4 @@
-import type { Connector, InputRequired, ToolAnnotations, ToolCallContext, ToolResult, ToolSpec } from "@capybara-hq/plugin-sdk";
+import type { Connector, HookParentScope, InputRequired, ToolAnnotations, ToolCallContext, ToolResult, ToolSpec } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../agents/definition.js";
 import type { ToolView } from "../conversations/events.js";
 import { ExtensionHost } from "../extensions/host.js";
@@ -6,14 +6,10 @@ import { ExtensionRegistry } from "../extensions/registry.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import type { OrgRole } from "../orgs/roles.js";
+import type { ConversationKindForHooks } from "../runtime/hook-calls.js";
 import { BuiltinTools } from "./builtins/builtin-tools.js";
+export { BUILTIN_TOOL_NAMES } from "./builtin-names.js";
 export { canonicalJson } from "./canonical-json.js";
-/**
- * 内核内置工具的名字（Task 10 / Task 19 实现；M5 T8 加沙箱工具）。保存 agent 时内置工具引用按这份清单校验，
- * 不依赖当前是否已注册，避免实现落地顺序影响已保存的定义；运行时未注册的照常报不可用。
- * `skill_write`（M5 T15）由 agent 定义显式引用才可用（负责人决定 agent 能否改自己的技能）。
- */
-export declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "read_tool_output", "tool_search", "skill_load", "skill_write", "sandbox_bash", "sandbox_read", "sandbox_write", "sandbox_edit", "sandbox_glob", "sandbox_grep", "sandbox_deliver", "agent"];
 /** 保存 agent 时引用校验的问题（`path` 为 `tools.<i>`）。 */
 export interface ToolRefIssue {
     path: string;
@@ -21,7 +17,7 @@ export interface ToolRefIssue {
 }
 /**
  * 内置工具处理函数的上下文：在 SDK 的 `ToolCallContext` 之上，管线额外传入本步解析出的工具
- * （`tool_search` 据此搜索）。插件处理函数收到的仍是 `ToolCallContext`。
+ * （`ToolSearch` 据此搜索）。插件处理函数收到的仍是 `ToolCallContext`。
  */
 export interface BuiltinCallContext extends ToolCallContext {
     tools?: readonly ResolvedTool[];
@@ -37,9 +33,21 @@ export interface BuiltinCallContext extends ToolCallContext {
      * for a sub-agent's call, the conversation itself otherwise (the default when absent).
      */
     sandboxConversationId?: string;
+    /** The parent run of a sub-agent's run (absent for a top-level run). */
+    parentRunId?: string;
+    /**
+     * The rest of the run's hook scope, for a builtin that makes a model call of its own (the
+     * `WebFetch` extraction fires `model.request` / `model.response`): the step of the call, the
+     * agent version of the run, the conversation kind (hooks fire for `chat` and `subagent` only)
+     * and, for a sub-agent, where it was dispatched from.
+     */
+    step?: number;
+    agentVersion?: number;
+    conversationKind?: ConversationKindForHooks;
+    parent?: HookParentScope;
 }
 /**
- * 内置工具的结果：`ToolResult` 之外可带 `loadedTools`（`tool_search` 加载的工具 key，
+ * 内置工具的结果：`ToolResult` 之外可带 `loadedTools`（`ToolSearch` 加载的工具 key，
  * 管线写进 `tool_result.loadedTools`）。
  */
 export type BuiltinResult = (ToolResult & {
@@ -52,7 +60,7 @@ export type BuiltinResult = (ToolResult & {
 }) | InputRequired;
 /** 内置工具的处理函数（插件的 `ToolHandler` 可直接赋给它）。 */
 export type BuiltinHandler = (input: unknown, ctx: BuiltinCallContext) => Promise<BuiltinResult>;
-/** 内核内置工具（`ask_user` 等，Task 10 实现具体工具）；key 就是 `spec.name`。 */
+/** 内核内置工具（`AskUserQuestion` 等，Task 10 实现具体工具）；key 就是 `spec.name`。 */
 export interface BuiltinTool {
     spec: ToolSpec;
     defaultPolicy: "allow" | "ask";
@@ -63,8 +71,14 @@ export interface BuiltinTool {
     timeoutMs?: (input: unknown) => number;
     /** 结果转存阈值（字符）：与 `tools.outputSpillChars` 取小者。缺省只用配置。 */
     spillChars?: number;
-    /** 本部署当前不可用时返回事实原因（英文、可执行，进「工具不可用」提醒）；可用返回 null。 */
-    unavailable?: () => string | null;
+    /**
+     * The factual reason this tool is unavailable for the org right now (English, actionable; it goes
+     * into the "tool unavailable" reminder), or null when it is available. May be async (e.g. a
+     * per-org extension-point default).
+     */
+    unavailable?: (ctx: {
+        orgId: string;
+    }) => Promise<string | null> | string | null;
 }
 /**
  * agent 定义里对工具的引用（Task 6 在 `AgentDefinitionSchema` 中落地同形的 zod schema）。
@@ -116,7 +130,7 @@ export interface ResolvedTool {
      */
     requiredRole?: OrgRole;
 }
-/** 不可用的引用：`ref` 尽量写成模型认识的工具 key（`docs__search`、`docs__*`），否则 `app:<id>`。 */
+/** 不可用的引用：`ref` 尽量写成模型认识的工具 key（`mcp__docs__search`、`mcp__docs__*`），否则 `app:<id>`。 */
 export interface UnavailableTool {
     ref: string;
     reason: string;
@@ -148,7 +162,7 @@ export interface AgentTools {
      */
     hidden?: UnavailableTool[];
     /**
-     * 本步是否启用 `tool_search`（spec 5.5）：启用时 `tools` 末尾含 `tool_search`，构建请求时只放内置工具
+     * 本步是否启用 `ToolSearch`（spec 5.5）：启用时 `tools` 末尾含 `ToolSearch`，构建请求时只放内置工具
      * 与已加载工具的完整定义，其余进目录。缺省视为未启用。
      */
     toolSearch?: boolean;
@@ -178,7 +192,7 @@ export declare class ToolRegistry {
     private readonly extensions;
     private readonly builtinTools;
     /**
-     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `tool_search` is never
+     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `ToolSearch` is never
      * offered and the sub-agent limits are the schema defaults.
      */
     private readonly config?;
@@ -188,11 +202,11 @@ export declare class ToolRegistry {
     /** The installed connectors (`connector@1`, from the extension registry). */
     extensions: Pick<ExtensionRegistry, "list">, builtinTools: Pick<BuiltinTools, "list">, 
     /**
-     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `tool_search` is never
+     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `ToolSearch` is never
      * offered and the sub-agent limits are the schema defaults.
      */
     config?: Pick<KernelConfigService, "get"> | undefined);
-    /** The kernel's builtin tools (`tool_search` is added by {@link forAgent}, not by definitions). */
+    /** The kernel's builtin tools (`ToolSearch` is added by {@link forAgent}, not by definitions). */
     private get builtins();
     /** `host.list("connector")` 中 `kind` 匹配的第一个实现；未安装返回 undefined。 */
     findConnector(kind: string): Connector | undefined;
@@ -228,23 +242,23 @@ export declare class ToolRegistry {
         issues: ToolRefIssue[];
     }>;
     /**
-     * 解析 agent 引用的工具（见类注释），再判定是否启用 `tool_search`：组织设置 `toolSearch === "on"`，且
+     * 解析 agent 引用的工具（见类注释），再判定是否启用 `ToolSearch`：组织设置 `toolSearch === "on"`，且
      * 可用工具数 > `tools.searchThresholdTools` 或其定义的估算 token > `tools.searchThresholdTokens`。
-     * 启用时把内置 `tool_search` 追加到末尾。定义里显式引用的 `tool_search` 忽略（由这里按设置管理）。
-     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `skill_load`（始终完整加载）；
-     * 定义里显式引用的 `skill_load` 同样忽略。
+     * 启用时把内置 `ToolSearch` 追加到末尾。定义里显式引用的 `ToolSearch` 忽略（由这里按设置管理）。
+     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `Skill`（始终完整加载）；
+     * 定义里显式引用的 `Skill` 同样忽略。
      */
     forAgent(orgId: string, def: {
         tools: readonly AgentToolRef[];
         skillLoad?: boolean;
-        /** The definition's sub-agent roster source: the `agent` tool's description lists it. */
+        /** The definition's sub-agent roster source: the `Agent` tool's description lists it. */
         subagents?: AgentDefinition["subagents"];
     }): Promise<AgentTools>;
-    /** 是否启用 `tool_search`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
+    /** 是否启用 `ToolSearch`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
     private searchActive;
     private resolve;
     /**
-     * `subagents.maxConcurrentPerRun` with the organization's override, for the `agent` tool's
+     * `subagents.maxConcurrentPerRun` with the organization's override, for the `Agent` tool's
      * description (§4.3). A change of the limit changes the tool's spec hash; replays read the
      * definition logged by hash, so no drift reason is involved. Without config (some tests): the
      * schema default.

package/dist/tools/registry.js

@@ -8,6 +8,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { createHash } from "node:crypto";
+import { connectorToolKey, extensionToolKey } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { ExtensionHost } from "../extensions/host.js";
 import { ExtensionRegistry } from "../extensions/registry.js";
@@ -17,27 +18,14 @@ import { readOrgSettings } from "../orgs/settings.service.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { SUBAGENT_LIMIT_DEFAULTS, subagentLimits } from "../runtime/subagents/limits.js";
 import { resolveRoster } from "../runtime/subagents/roster.js";
-import { AGENT_TOOL, agentToolSpec } from "./builtins/agent.js";
+import { AGENT_TOOL, BASH_COMPANION_TOOLS, BUILTIN, BUILTIN_TOOL_NAMES, SKILL_LOAD, TOOL_SEARCH, } from "./builtin-names.js";
+import { agentToolSpec } from "./builtins/agent.js";
 import { BuiltinTools } from "./builtins/builtin-tools.js";
-import { SANDBOX_TOOL_NAMES } from "./builtins/sandbox/names.js";
 import { canonicalJson } from "./canonical-json.js";
-import { toolKey, toolKeyIssue } from "./naming.js";
+import { legacyKeySaveText } from "./legacy-keys.js";
+import { toolKeyIssue } from "./naming.js";
+export { BUILTIN_TOOL_NAMES } from "./builtin-names.js";
 export { canonicalJson } from "./canonical-json.js";
-/**
- * 内核内置工具的名字（Task 10 / Task 19 实现；M5 T8 加沙箱工具）。保存 agent 时内置工具引用按这份清单校验，
- * 不依赖当前是否已注册，避免实现落地顺序影响已保存的定义；运行时未注册的照常报不可用。
- * `skill_write`（M5 T15）由 agent 定义显式引用才可用（负责人决定 agent 能否改自己的技能）。
- */
-export const BUILTIN_TOOL_NAMES = [
-    "ask_user",
-    "read_tool_output",
-    "tool_search",
-    "skill_load",
-    "skill_write",
-    ...SANDBOX_TOOL_NAMES,
-    // phase C: dispatches sub-agents; its description is built per agent from the roster
-    "agent",
-];
 /** The first 16 hex digits of sha256(canonicalJson(v)): a fingerprint independent of key order. */
 export function contentHash(v) {
     return createHash("sha256").update(canonicalJson(v)).digest("hex").slice(0, 16);
@@ -68,10 +56,8 @@ export function specHash(spec) {
 export function policyFromAnnotations(a) {
     return a?.readOnlyHint === true ? "allow" : "ask";
 }
-/** 内置 `tool_search` 的名字（由注册表按组织设置与阈值自动加入，不进 agent 定义）。 */
-const TOOL_SEARCH = "tool_search";
-/** 内置 `skill_load` 的名字（对话日志里有技能目录快照时由注册表自动加入，不进 agent 定义）。 */
-const SKILL_LOAD = "skill_load";
+// `ToolSearch` is added by the registry by org setting and threshold, `Skill` when the log has a
+// skills catalog snapshot; neither comes from agent definitions (`./builtin-names.ts`).
 /** 工具定义（模型可见三项）的估算 token 数（与请求估算同一口径）。 */
 function estimateToolTokens(tools) {
     return estimateTokens([], [], tools.map((t) => ({
@@ -85,6 +71,16 @@ const sourceId = (s) => s.kind === "builtin"
     : s.kind === "plugin"
         ? `plugin:${s.plugin}:${s.name}`
         : `connector:${s.connectorId}:${s.name}`;
+/** A builtin as a resolved tool (with `spec`, which `Agent` builds per definition). */
+const builtinTool = (b, spec) => ({
+    key: b.spec.name,
+    source: { kind: "builtin", name: b.spec.name },
+    spec,
+    specHash: specHash(spec),
+    defaultPolicy: b.defaultPolicy,
+    ...(b.timeoutMs !== undefined && { timeoutMs: b.timeoutMs }),
+    ...(b.spillChars !== undefined && { spillChars: b.spillChars }),
+});
 /**
  * Tool registry: resolves the references in an agent definition into the tools available for this
  * run. Not cached (reads PG and the host live every time), so changes take effect right away across
@@ -114,7 +110,7 @@ let ToolRegistry = class ToolRegistry {
     /** The installed connectors (`connector@1`, from the extension registry). */
     extensions, builtinTools, 
     /**
-     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `tool_search` is never
+     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `ToolSearch` is never
      * offered and the sub-agent limits are the schema defaults.
      */
     config) {
@@ -124,7 +120,7 @@ let ToolRegistry = class ToolRegistry {
         this.builtinTools = builtinTools;
         this.config = config;
     }
-    /** The kernel's builtin tools (`tool_search` is added by {@link forAgent}, not by definitions). */
+    /** The kernel's builtin tools (`ToolSearch` is added by {@link forAgent}, not by definitions). */
     get builtins() {
         return this.builtinTools.list();
     }
@@ -205,13 +201,24 @@ let ToolRegistry = class ToolRegistry {
             const path = `tools.${i}`;
             if (ref.kind === "builtin") {
                 if (!BUILTIN_TOOL_NAMES.includes(ref.name)) {
-                    issues.push({ path, message: `Built-in tool "${ref.name}" does not exist` });
+                    const renamed = legacyKeySaveText(ref.name);
+                    issues.push({
+                        path,
+                        message: renamed === null
+                            ? `Built-in tool "${ref.name}" does not exist`
+                            : `Built-in tool ${renamed}`,
+                    });
                     return;
                 }
                 claim(path, ref.name, `builtin:${ref.name}`);
+                // offered with Bash (see resolve), so their policies validate too
+                if (ref.name === BUILTIN.Bash) {
+                    for (const c of BASH_COMPANION_TOOLS)
+                        claim(path, c, `builtin:${c}`);
+                }
             }
             else if (ref.kind === "plugin") {
-                const key = toolKey(ref.plugin, ref.name);
+                const key = extensionToolKey(ref.plugin, ref.name);
                 if (!pluginTools.some((x) => x.plugin === ref.plugin && x.spec.name === ref.name)) {
                     issues.push({ path, message: `Plugin tool "${key}" does not exist` });
                     return;
@@ -238,18 +245,18 @@ let ToolRegistry = class ToolRegistry {
                         });
                         continue;
                     }
-                    claim(path, toolKey(app.slug, name), `connector:${app.id}:${name}`);
+                    claim(path, connectorToolKey(app.slug, name), `connector:${app.id}:${name}`);
                 }
             }
         });
         return { keys: new Set(owner.keys()), issues };
     }
     /**
-     * 解析 agent 引用的工具（见类注释），再判定是否启用 `tool_search`：组织设置 `toolSearch === "on"`，且
+     * 解析 agent 引用的工具（见类注释），再判定是否启用 `ToolSearch`：组织设置 `toolSearch === "on"`，且
      * 可用工具数 > `tools.searchThresholdTools` 或其定义的估算 token > `tools.searchThresholdTokens`。
-     * 启用时把内置 `tool_search` 追加到末尾。定义里显式引用的 `tool_search` 忽略（由这里按设置管理）。
-     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `skill_load`（始终完整加载）；
-     * 定义里显式引用的 `skill_load` 同样忽略。
+     * 启用时把内置 `ToolSearch` 追加到末尾。定义里显式引用的 `ToolSearch` 忽略（由这里按设置管理）。
+     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `Skill`（始终完整加载）；
+     * 定义里显式引用的 `Skill` 同样忽略。
      */
     async forAgent(orgId, def) {
         const { tools, unavailable, hidden } = await this.resolve(orgId, def);
@@ -277,7 +284,7 @@ let ToolRegistry = class ToolRegistry {
         }
         return { tools, unavailable, hidden, toolSearch };
     }
-    /** 是否启用 `tool_search`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
+    /** 是否启用 `ToolSearch`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
     async searchActive(orgId, tools) {
         const cfg = this.config?.get().tools;
         if (!cfg || !this.builtins.some((b) => b.spec.name === TOOL_SEARCH))
@@ -324,12 +331,12 @@ let ToolRegistry = class ToolRegistry {
                     unavailable.push({ ref: ref.name, reason: "Built-in tool does not exist" });
                     continue;
                 }
-                const why = b.unavailable?.() ?? null;
+                const why = (await b.unavailable?.({ orgId })) ?? null;
                 if (why !== null) {
                     unavailable.push({ ref: ref.name, reason: why });
                     continue;
                 }
-                // `agent`: the description lists this definition's roster (sub-agents spec §4.3); with an
+                // `Agent`: the description lists this definition's roster (sub-agents spec §4.3); with an
                 // empty roster there is nothing to dispatch, so the tool is not offered at all
                 let spec = b.spec;
                 if (b.spec.name === AGENT_TOOL) {
@@ -338,18 +345,18 @@ let ToolRegistry = class ToolRegistry {
                         continue;
                     spec = agentToolSpec(roster, await this.maxConcurrentSubagents(orgId));
                 }
-                add({
-                    key: b.spec.name,
-                    source: { kind: "builtin", name: b.spec.name },
-                    spec,
-                    specHash: specHash(spec),
-                    defaultPolicy: b.defaultPolicy,
-                    ...(b.timeoutMs !== undefined && { timeoutMs: b.timeoutMs }),
-                    ...(b.spillChars !== undefined && { spillChars: b.spillChars }),
-                });
+                add(builtinTool(b, spec));
+                // `TaskOutput` and `TaskStop` come with an available `Bash` (background Bash spec §2)
+                if (b.spec.name === BUILTIN.Bash) {
+                    for (const name of BASH_COMPANION_TOOLS) {
+                        const c = this.builtins.find((x) => x.spec.name === name);
+                        if (c && ((await c.unavailable?.({ orgId })) ?? null) === null)
+                            add(builtinTool(c, c.spec));
+                    }
+                }
             }
             else if (ref.kind === "plugin") {
-                const key = toolKey(ref.plugin, ref.name);
+                const key = extensionToolKey(ref.plugin, ref.name);
                 const t = pluginTools.find((x) => x.plugin === ref.plugin && x.spec.name === ref.name);
                 if (!t) {
                     unavailable.push({ ref: key, reason: "Plugin tool does not exist" });
@@ -381,7 +388,7 @@ let ToolRegistry = class ToolRegistry {
                     unavailable.push({ ref: `app:${ref.connectorId}`, reason: "App does not exist" });
                     continue;
                 }
-                const all = toolKey(app.slug, "*");
+                const all = connectorToolKey(app.slug, "*");
                 if (app.deleted) {
                     unavailable.push({ ref: all, reason: `App ${app.slug} was deleted` });
                     continue;
@@ -403,7 +410,7 @@ let ToolRegistry = class ToolRegistry {
                 // 「all」里未启用的工具不算 agent 点名要的，不进 unavailable（不提醒），只记进 hidden 备查
                 const notEnabled = ref.tools === "all" ? hidden : unavailable;
                 for (const t of wanted) {
-                    const key = toolKey(app.slug, t.name);
+                    const key = connectorToolKey(app.slug, t.name);
                     // 远端已不再提供（漂移检测置停用并标记，见 drift.ts）：与「没有这一行」同一个事实
                     if ("missing" in t || t.gone) {
                         notEnabled.push({ ref: key, reason: `Tool no longer exists in app ${app.slug}` });
@@ -440,7 +447,7 @@ let ToolRegistry = class ToolRegistry {
         return { tools, unavailable, hidden };
     }
     /**
-     * `subagents.maxConcurrentPerRun` with the organization's override, for the `agent` tool's
+     * `subagents.maxConcurrentPerRun` with the organization's override, for the `Agent` tool's
      * description (§4.3). A change of the limit changes the tool's spec hash; replays read the
      * definition logged by hash, so no drift reason is involved. Without config (some tests): the
      * schema default.

package/dist/tools/resources.d.ts

@@ -1,6 +1,6 @@
 import { type ConnectorSession, type ToolResult, type ToolSpec } from "@capybara-hq/plugin-sdk";
 /**
- * 连接器 resources 的两个内核工具（brief：`<connectorSlug>__list_resources`、`<connectorSlug>__read_resource {uri}`）。
+ * 连接器 resources 的两个内核工具（brief：`mcp__<slug>__list_resources`、`mcp__<slug>__read_resource {uri}`）。
  *
  * 设计：安装 / 刷新连接器时，连接器会话带 `listResources` 方法即视为支持 resources（不额外调用，免得多一次外连
  * 和多一种失败），内核把这两个工具作为 `source = 'resources'` 的行写进 `connector_tools`（迁移 0013）。这样它们和

package/dist/tools/resources.js

@@ -1,6 +1,6 @@
 import { ToolError, } from "@capybara-hq/plugin-sdk";
 /**
- * 连接器 resources 的两个内核工具（brief：`<connectorSlug>__list_resources`、`<connectorSlug>__read_resource {uri}`）。
+ * 连接器 resources 的两个内核工具（brief：`mcp__<slug>__list_resources`、`mcp__<slug>__read_resource {uri}`）。
  *
  * 设计：安装 / 刷新连接器时，连接器会话带 `listResources` 方法即视为支持 resources（不额外调用，免得多一次外连
  * 和多一种失败），内核把这两个工具作为 `source = 'resources'` 的行写进 `connector_tools`（迁移 0013）。这样它们和

package/dist/tools/tools.module.js

@@ -5,20 +5,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Module } from "@nestjs/common";
+import { BackgroundModule } from "../background/background.module.js";
 import { ConversationAccessModule } from "../conversations/access.js";
 import { AttachmentsModule } from "../conversations/attachments.module.js";
 import { EventLogModule } from "../conversations/event-log.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { QueueModule } from "../infra/queue/queue.module.js";
+import { ModelsModule } from "../models/models.module.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
 import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
+import { StepLogModule } from "../runtime/step-log.js";
 import { SubagentsModule } from "../runtime/subagents/subagents.service.js";
+import { UsageReportModule } from "../runtime/usage-report.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { StorageModule } from "../storage/storage.module.js";
 import { ApprovalsService } from "./approvals.service.js";
 import { Breaker } from "./breaker.js";
 import { BuiltinTools } from "./builtins/builtin-tools.js";
+import { WebPages } from "./builtins/web/page-cache.js";
 import { ConnectorContent } from "./connector-content.js";
 import { ConnectorsService } from "./connectors.service.js";
 import { Credentials } from "./credentials.js";
@@ -48,18 +53,25 @@ ToolsModule = __decorate([
             StorageModule,
             SkillsModule,
             OrgLockModule,
-            // the `agent` tool's dispatch
+            // the `Agent` tool's dispatch
             SubagentsModule,
             // the builtin sandbox and skill tools run in the conversation's sandbox
             SandboxModule,
+            // `Bash` with run_in_background records its task; TaskOutput / TaskStop finish and stop it
+            BackgroundModule,
             // the conversation page's tool metadata reads only what the viewer may see
             ConversationAccessModule,
+            // the WebFetch extraction call: its purpose, usage report and step writes
+            ModelsModule,
+            UsageReportModule,
+            StepLogModule,
             QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
         ],
         providers: [
             Credentials,
             ToolOutputs,
             BuiltinTools,
+            WebPages,
             ToolRegistry,
             ApprovalsService,
             QuestionsService,

package/dist/tools/validate.js

@@ -1,5 +1,5 @@
 import { Ajv2020 } from "ajv/dist/2020.js";
-import { canonicalJson } from "./registry.js";
+import { canonicalJson } from "./canonical-json.js";
 /**
  * 编译结果缓存的上限：超过后整体丢弃（工具定义每步从库里重新读出，缓存不能无限增长）。
  * 缓存的是由定义推导出的只读数据，不是跨进程状态。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capybara-hq/kernel",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.4",
   "description": "Capybara kernel: config, database, plugin host and HTTP API of the Capybara agent platform",
   "license": "Apache-2.0",
   "repository": {
@@ -64,14 +64,14 @@
     "yaml": "^2.9.1",
     "yauzl": "3.4.0",
     "zod": "^4.6.7",
-    "@capybara-hq/plugin-sdk": "^0.1.0-rc.0"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.2"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",
     "@types/pg": "^8.23.1",
     "@types/semver": "^7.8.0",
     "@types/yauzl": "3.4.0",
-    "@capybara-hq/testing": "0.1.0-rc.3"
+    "@capybara-hq/testing": "0.1.0-rc.4"
   },
   "scripts": {
     "build": "tsc -b"