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

package/dist/orgs/settings.service.d.ts

@@ -8,10 +8,11 @@ import { OrgLock } from "./org-lock.js";
 /**
  * 组织设置（`capybara.orgs.settings` jsonb）。读取宽松：缺失或非法的字段按默认值，未知键保留不动
  * （更新时与存量合并），新版本加字段不需要迁移。
- * - `toolSearch`：工具超过阈值时是否改用目录 + `tool_search`（D11，默认 on）。
+ * - `toolSearch`：工具超过阈值时是否改用目录 + `ToolSearch`（D11，默认 on）。
  * - `locale`：组织默认语言（`zh` / `en`，默认 en），机器人在 IM 里说的固定话术按它选择。
  * - `sandboxToolPolicy`：沙箱工具的默认策略（M5 T8，默认 allow）。为 `ask` 时除只读的
- *   `sandbox_read` / `sandbox_glob` / `sandbox_grep` 外都需要审批（执行时实时读取）。
+ *   `Read` / `Glob` / `Grep` 外都需要审批（执行时实时读取）。
+ * - `wakeOnBackgroundTask`：组织对 `runtime.wakeOnBackgroundTask` 的覆盖（缺省跟随部署），见 {@link effectiveWakeOnBackgroundTask}。
  * - `sandboxEgress`：组织的沙箱出站（Ruling M19 / D6），缺省跟随部署的 `sandbox.limits.egress` + `allowHosts`。
  *   见 {@link effectiveSandboxEgress}。存量值非法时按 `none` 读（宁可断网，不悄悄放宽到部署默认）。
  */
@@ -49,6 +50,7 @@ export declare const OrgSettingsSchema: z.ZodObject<{
         }>;
         allowHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
+    wakeOnBackgroundTask: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
 export type OrgSettings = z.infer<typeof OrgSettingsSchema>;
 /** PATCH 体：只改给出的字段；未知字段 → 400。 */
@@ -65,6 +67,7 @@ export declare const OrgSettingsPatchSchema: z.ZodObject<{
         allow: "allow";
         ask: "ask";
     }>>;
+    wakeOnBackgroundTask: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     sandboxEgress: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         mode: z.ZodEnum<{
             allowlist: "allowlist";
@@ -81,6 +84,8 @@ export type DeploymentEgress = Pick<SandboxLimits, "egress" | "allowHosts">;
  * （省略时用部署的），但部署是 `none` 时仍为 `none`（组织永远不比部署放得更开，部署改成 none 后存量设置也随之收紧）。
  */
 export declare function effectiveSandboxEgress(deployment: DeploymentEgress, org: SandboxEgressSetting | undefined): DeploymentEgress;
+/** Whether a finished background task wakes an idle conversation: the org's setting, else the deployment's. */
+export declare function effectiveWakeOnBackgroundTask(deployment: boolean, org: OrgSettings["wakeOnBackgroundTask"]): boolean;
 /**
  * 组织实际生效的沙箱限额（C19 / Ruling M16）：企业管理员的覆盖（部署设置 `sandboxLimitOverrides[orgId]`）
  * 给出的 cpu / memoryMb 替换部署默认，未给的项、disk 与出站沿用 `deployment`。只在创建沙箱时读取。

package/dist/orgs/settings.service.js

@@ -21,10 +21,11 @@ import { OrgLock } from "./org-lock.js";
 /**
  * 组织设置（`capybara.orgs.settings` jsonb）。读取宽松：缺失或非法的字段按默认值，未知键保留不动
  * （更新时与存量合并），新版本加字段不需要迁移。
- * - `toolSearch`：工具超过阈值时是否改用目录 + `tool_search`（D11，默认 on）。
+ * - `toolSearch`：工具超过阈值时是否改用目录 + `ToolSearch`（D11，默认 on）。
  * - `locale`：组织默认语言（`zh` / `en`，默认 en），机器人在 IM 里说的固定话术按它选择。
  * - `sandboxToolPolicy`：沙箱工具的默认策略（M5 T8，默认 allow）。为 `ask` 时除只读的
- *   `sandbox_read` / `sandbox_glob` / `sandbox_grep` 外都需要审批（执行时实时读取）。
+ *   `Read` / `Glob` / `Grep` 外都需要审批（执行时实时读取）。
+ * - `wakeOnBackgroundTask`：组织对 `runtime.wakeOnBackgroundTask` 的覆盖（缺省跟随部署），见 {@link effectiveWakeOnBackgroundTask}。
  * - `sandboxEgress`：组织的沙箱出站（Ruling M19 / D6），缺省跟随部署的 `sandbox.limits.egress` + `allowHosts`。
  *   见 {@link effectiveSandboxEgress}。存量值非法时按 `none` 读（宁可断网，不悄悄放宽到部署默认）。
  */
@@ -58,6 +59,8 @@ export const OrgSettingsSchema = z.object({
     locale: z.enum(["zh", "en"]).default("en").catch("en"),
     sandboxToolPolicy: z.enum(["allow", "ask"]).default("allow").catch("allow"),
     sandboxEgress: SandboxEgressSettingSchema.optional().catch({ mode: "none" }),
+    /** Overrides `runtime.wakeOnBackgroundTask`; absent follows the deployment. */
+    wakeOnBackgroundTask: z.boolean().optional().catch(undefined),
 });
 /** PATCH 体：只改给出的字段；未知字段 → 400。 */
 export const OrgSettingsPatchSchema = z
@@ -65,6 +68,8 @@ export const OrgSettingsPatchSchema = z
     toolSearch: z.enum(["on", "off"]).optional(),
     locale: z.enum(["zh", "en"]).optional(),
     sandboxToolPolicy: z.enum(["allow", "ask"]).optional(),
+    /** null clears (follow the deployment again). */
+    wakeOnBackgroundTask: z.boolean().nullable().optional(),
     /** null 清除（恢复跟随部署默认）。 */
     sandboxEgress: SandboxEgressSettingSchema.nullable().optional(),
 })
@@ -80,6 +85,10 @@ export function effectiveSandboxEgress(deployment, org) {
         return { egress: "none", allowHosts: [] };
     return { egress: "allowlist", allowHosts: [...(org.allowHosts ?? deployment.allowHosts)] };
 }
+/** Whether a finished background task wakes an idle conversation: the org's setting, else the deployment's. */
+export function effectiveWakeOnBackgroundTask(deployment, org) {
+    return org ?? deployment;
+}
 /**
  * 组织实际生效的沙箱限额（C19 / Ruling M16）：企业管理员的覆盖（部署设置 `sandboxLimitOverrides[orgId]`）
  * 给出的 cpu / memoryMb 替换部署默认，未给的项、disk 与出站沿用 `deployment`。只在创建沙箱时读取。
@@ -169,15 +178,17 @@ let OrgSettingsService = class OrgSettingsService {
         const before = parseOrgSettings(stored);
         const changes = Object.fromEntries(Object.entries(patch)
             .filter(([, v]) => v !== undefined)
-            // null 清除 sandboxEgress：恢复跟随部署默认
+            // null clears sandboxEgress / wakeOnBackgroundTask: follow the deployment default again
             .map(([k, v]) => [k, v === null ? undefined : v]));
         const after = { ...before, ...changes };
         if (after.sandboxEgress === undefined)
             delete after.sandboxEgress;
+        if (after.wakeOnBackgroundTask === undefined)
+            delete after.wakeOnBackgroundTask;
         if (sameSettings(before, after))
             return before;
         // 与存量合并：保留本版本不认识的键（清除的 sandboxEgress 不留在存量里）
-        const { sandboxEgress: _old, ...rest } = stored;
+        const { sandboxEgress: _old, wakeOnBackgroundTask: _oldWake, ...rest } = stored;
         await this.db
             .updateTable("orgs")
             .set({ settings: JSON.stringify({ ...rest, ...after }) })

package/dist/roles/worker.module.js

@@ -6,12 +6,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var WorkerModule_1;
 import { Module } from "@nestjs/common";
+import { BackgroundModule } from "../background/background.module.js";
+import { BackgroundTaskPollJob } from "../background/poll.job.js";
 import { CatalogModule } from "../catalog/catalog.module.js";
 import { CatalogJobs } from "../catalog/jobs.js";
 import { ChannelsModule, ChannelWorkersModule } from "../channels/channels.module.js";
 import { GatewayCheckJob } from "../channels/supervisor.js";
 import { AttachmentsModule } from "../conversations/attachments.module.js";
 import { AttachmentCleanupJob } from "../conversations/attachments.service.js";
+import { EventLogModule } from "../conversations/event-log.js";
 import { TitlesModule } from "../conversations/titles.js";
 import { EvalWorkersModule } from "../evals/evals.module.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
@@ -59,6 +62,8 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 AttachmentsModule,
                 StorageModule,
                 SandboxModule,
+                BackgroundModule,
+                EventLogModule,
                 ToolsModule,
                 CatalogModule,
                 OrgsModule,
@@ -71,6 +76,7 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 AttachmentCleanupJob,
                 StoragePurgeJob,
                 SandboxSweepJobs,
+                BackgroundTaskPollJob,
                 ToolJobs,
                 CatalogJobs,
                 DirectoryScanJob,

package/dist/runtime/context/build.d.ts

@@ -1,6 +1,6 @@
 import { type ContentBlock, type ModelInfo, type ModelRequest, type ParamValue } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../../agents/definition.js";
-import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
+import { type ConversationEvent, type EventPayload } from "../../conversations/events.js";
 import type { ResolvedTool } from "../../tools/registry.js";
 /**
  * 平台行为规范（模型可见，英文）。短而通用（spec 6 原则 5）；不放时间戳、会话 ID 等会变化的内容，
@@ -25,13 +25,13 @@ export interface ModelCallMeta {
     params: Record<string, ParamValue>;
     /**
      * 请求带的工具（按发送顺序）及定义指纹；定义本身按指纹存在 `capybara.tool_specs`。
-     * 未启用 tool_search 时按 key 排序；启用时见 {@link BuildModelRequestInput.toolSearch}。
+     * 未启用 ToolSearch 时按 key 排序；启用时见 {@link BuildModelRequestInput.toolSearch}。
      */
     tools: {
         key: string;
         specHash: string;
     }[];
-    /** 启用 tool_search 时 system 第二块目录里的工具（按 key 排序）及定义指纹；未启用没有该字段。 */
+    /** 启用 ToolSearch 时 system 第二块目录里的工具（按 key 排序）及定义指纹；未启用没有该字段。 */
     catalog?: {
         key: string;
         specHash: string;
@@ -54,13 +54,14 @@ export interface BuildModelRequestInput {
     model: ModelInfo;
     step: number;
     /**
-     * loop 已吸收到的 user_message seq（R31）。提供时：
-     * - seq 大于它的 user_message 不进请求（运行中途到达、尚未被吸收的插话，由后续步骤吸收或触发下一轮）；
-     * - 每条 user_message 放在**吸收它的那次模型调用**的位置：日志里第一个 `request.absorbedUpToSeq`
+     * loop 已吸收到的位置（R31）：the largest seq of the absorbable events (`user_message` and
+     * `background_task_finished`, {@link isAbsorbable}) the loop took. 提供时：
+     * - seq 大于它的可吸收事件不进请求（运行中途到达、尚未被吸收的插话或后台任务结束，由后续步骤吸收或触发下一轮）；
+     * - 每个可吸收事件放在**吸收它的那次模型调用**的位置：日志里第一个 `request.absorbedUpToSeq`
      *   不小于它的 `model_call` 之前（没有该字段的旧 model_call 视为吸收了它之前的全部消息），
      *   本次请求吸收的放在末尾。于是模型看到的历史只追加（插话不会插到已发送的回复之前），
      *   且请求可由日志 + `model_call` 精确还原。
-     * 不提供时按 seq 原样回放全部 user_message。
+     * 不提供时按 seq 原样回放全部可吸收事件。
      */
     absorbedUpToSeq?: number;
     /**
@@ -75,8 +76,8 @@ export interface BuildModelRequestInput {
      */
     tools?: RequestTool[];
     /**
-     * 启用 tool_search（spec 5.5，由 `ToolRegistry.forAgent` 判定）。启用且有工具时：
-     * - `tools` 只放内置工具（含 `tool_search`，按 key 排序）与**已加载**工具的完整定义；
+     * 启用 ToolSearch（spec 5.5，由 `ToolRegistry.forAgent` 判定）。启用且有工具时：
+     * - `tools` 只放内置工具（含 `ToolSearch`，按 key 排序）与**已加载**工具的完整定义；
      *   已加载 = 日志中全部 `tool_result.loadedTools` 的并集（含摘要之前的；不在本步可用工具中的忽略），
      *   按首次加载顺序追加在内置工具之后——新加载只在末尾追加，已发送的工具顺序不变；
      * - 其余工具（不论是否已加载）以目录形式放进 system 第二个块（按 key 排序，打缓存断点），
@@ -224,17 +225,18 @@ export declare function summaryText(summary: string): string;
  * 由会话事件日志 + agent 定义构建模型请求（纯函数，不做 I/O）。
  * - system：`BEHAVIOR_RULES + "\n\n" + agent.instructions` 一个块，打缓存断点（a sub-agent's log:
  *   `BEHAVIOR_RULES`, its preamble and its instructions, all from its `subagent_started`）；日志里第一份 `skills_catalog`
- *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 tool_search 时
+ *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 ToolSearch 时
  *   第二个块是工具目录（见 {@link BuildModelRequestInput.toolSearch}）；
  * - 之后的 `skills_catalog` 在所在位置渲染为 system 变更提醒；被压缩摘要覆盖的，若摘要时生效的目录与 system 里的
  *   不同，紧随摘要补一条完整的当前目录；
  * - messages：最近一条摘要（若有）作为首条 user 消息，其后按 seq 回放 `coversUpToSeq` 之后的
  *   `user_message` / `assistant_message`（content 原样，含 opaque；aborted 的也回放；媒体引用按
  *   {@link resolveMedia} 换成 base64 或文字占位）/ `reminder`
- *   （`role: "system"`，放在它所在的位置）；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
+ *   （`role: "system"`，放在它所在的位置）/ `background_task_finished`（`role: "system"`, the text of
+ *   {@link renderBackgroundFinished}, placed like a user_message）；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
  *   （同一步的多个结果合并，按该 assistant 消息里 tool_call 的顺序；找不到对应调用的结果不进请求）。
  *   其他事件不进请求。提供 `absorbedUpToSeq` 时，
- *   尚未被吸收的 user_message 不进请求，运行中途到达的插话放在吸收它的调用处（见 BuildModelRequestInput）。
+ *   尚未被吸收的可吸收事件不进请求，运行中途到达的放在吸收它的调用处（见 BuildModelRequestInput）。
  * 只追加：新事件只会在 messages 末尾追加；唯一的前缀变化来自新的压缩摘要。
  * `step` 与 `agentVersion` 不进请求内容（保证缓存前缀稳定），由调用方写入 `model_call` 事件。
  */
@@ -245,7 +247,7 @@ export declare function buildModelRequest(input: BuildModelRequestInput): {
     mediaTokens: number;
 };
 /**
- * 日志里 `tool_search` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
+ * 日志里 `ToolSearch` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
  * 不看压缩摘要的边界：加载过的工具在摘要之后仍保持加载（模型可能凭摘要继续使用它们，且已发送的工具列表只追加）。
  */
 export declare function loadedToolKeys(events: readonly ConversationEvent[]): string[];

package/dist/runtime/context/build.js

@@ -1,7 +1,10 @@
 import { createHash } from "node:crypto";
 import { MEDIA_LIMITS, } from "@capybara-hq/plugin-sdk";
+import { renderBackgroundFinished } from "../../background/render.js";
+import { isAbsorbable, } from "../../conversations/events.js";
 import { catalogText, isAlwaysLoaded } from "../../tools/builtins/tool-search.js";
-import { invokedSkillNames, invokedSkillsText, skillsCatalogEvents, snapshotChangeText, snapshotCurrentText, snapshotSystemText, systemSkillsCatalog, } from "./skills.js";
+import { LEGACY_CATALOG_HEADER, LEGACY_SKILL_TEXTS, usesLegacyToolNames } from "./legacy-text.js";
+import { invokedSkillNames, invokedSkillsText, SKILL_TEXTS, skillsCatalogEvents, snapshotChangeText, snapshotCurrentText, snapshotSystemText, systemSkillsCatalog, } from "./skills.js";
 /**
  * 平台行为规范（模型可见，英文）。短而通用（spec 6 原则 5）；不放时间戳、会话 ID 等会变化的内容，
  * 保证同一 agent 版本在所有会话中 system 前缀一致、可命中提示词缓存。改动它会让所有缓存失效。
@@ -322,17 +325,18 @@ export function summaryText(summary) {
  * 由会话事件日志 + agent 定义构建模型请求（纯函数，不做 I/O）。
  * - system：`BEHAVIOR_RULES + "\n\n" + agent.instructions` 一个块，打缓存断点（a sub-agent's log:
  *   `BEHAVIOR_RULES`, its preamble and its instructions, all from its `subagent_started`）；日志里第一份 `skills_catalog`
- *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 tool_search 时
+ *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 ToolSearch 时
  *   第二个块是工具目录（见 {@link BuildModelRequestInput.toolSearch}）；
  * - 之后的 `skills_catalog` 在所在位置渲染为 system 变更提醒；被压缩摘要覆盖的，若摘要时生效的目录与 system 里的
  *   不同，紧随摘要补一条完整的当前目录；
  * - messages：最近一条摘要（若有）作为首条 user 消息，其后按 seq 回放 `coversUpToSeq` 之后的
  *   `user_message` / `assistant_message`（content 原样，含 opaque；aborted 的也回放；媒体引用按
  *   {@link resolveMedia} 换成 base64 或文字占位）/ `reminder`
- *   （`role: "system"`，放在它所在的位置）；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
+ *   （`role: "system"`，放在它所在的位置）/ `background_task_finished`（`role: "system"`, the text of
+ *   {@link renderBackgroundFinished}, placed like a user_message）；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
  *   （同一步的多个结果合并，按该 assistant 消息里 tool_call 的顺序；找不到对应调用的结果不进请求）。
  *   其他事件不进请求。提供 `absorbedUpToSeq` 时，
- *   尚未被吸收的 user_message 不进请求，运行中途到达的插话放在吸收它的调用处（见 BuildModelRequestInput）。
+ *   尚未被吸收的可吸收事件不进请求，运行中途到达的放在吸收它的调用处（见 BuildModelRequestInput）。
  * 只追加：新事件只会在 messages 末尾追加；唯一的前缀变化来自新的压缩摘要。
  * `step` 与 `agentVersion` 不进请求内容（保证缓存前缀稳定），由调用方写入 `model_call` 事件。
  */
@@ -377,7 +381,7 @@ export function buildModelRequest(input) {
             lastCall = absorbedBy(e);
     }
     /**
-     * 第 i 个事件（user_message）的放置方式：
+     * 第 i 个事件（可吸收事件：user_message / background_task_finished）的放置方式：
      * - `inline`：在吸收它的调用（之后第一个 `absorbedBy ≥ seq` 的 model_call，或本次请求）之前，
      *   没有「由未吸收它的调用生成的回复」→ 按 seq 原位回放（常规情况，与不提供 absorbedUpToSeq 时一致）；
      * - `deferred`：它之后有非空 assistant_message 是由一次没有吸收它的 model_call 生成的（它在那一步
@@ -461,8 +465,12 @@ export function buildModelRequest(input) {
         const blocks = blocksOf(u.payload.content);
         return report === undefined ? blocks : [...blocks, { type: "text", text: report }];
     };
-    /** 被某次模型调用跳过（运行中途到达）、尚未被吸收的 user_message，按 seq 升序。 */
+    /** 被某次模型调用跳过（运行中途到达）、尚未被吸收的可吸收事件，按 seq 升序。 */
     let deferred = [];
+    /** An absorbable event as a request message: a user turn, or a finished task's system text. */
+    const absorbableMessage = (e) => e.type === "user_message"
+        ? { role: "user", content: userBlocks(e) }
+        : { role: "system", content: renderBackgroundFinished(e.payload) };
     /**
      * 把已被吸收（seq ≤ upTo）的延后消息按 seq 顺序放进 messages，插在末尾连续的 system 提醒之前
      * （若有）。这样某一步自己写在 model_call 之前的提醒（含收尾提醒）仍排在它所跟随的用户消息之后，
@@ -476,7 +484,7 @@ export function buildModelRequest(input) {
         let at = messages.length;
         while (at > 0 && messages[at - 1]?.role === "system")
             at--;
-        messages.splice(at, 0, ...ready.map((u) => ({ role: "user", content: userBlocks(u) })));
+        messages.splice(at, 0, ...ready.map(absorbableMessage));
     };
     /** (runId, callId) → 该调用的 tool_result 事件（同一调用只取第一个）。 */
     const results = new Map();
@@ -488,6 +496,10 @@ export function buildModelRequest(input) {
         if (!results.has(k))
             results.set(k, e.payload);
     }
+    // System texts naming a builtin: a request whose tools were recorded before the tool rename
+    // renders the frozen pre-rename wording, so it rebuilds exactly (tool naming spec §10)
+    const legacyNames = usesLegacyToolNames(input.tools ?? []);
+    const skillTexts = legacyNames ? LEGACY_SKILL_TEXTS : SKILL_TEXTS;
     // 技能目录（Ruling M17）：第一份快照进 system；之后的每份在所在位置追加变更提醒（相对上一份快照）。
     const skillSnaps = skillsCatalogEvents(events);
     const systemSkills = systemSkillsCatalog(events);
@@ -504,33 +516,34 @@ export function buildModelRequest(input) {
         const covered = skillSnaps.filter((e) => e.seq <= after).at(-1);
         // (phase B: plus the current pinned skills and tool-name map when they differ from system's)
         if (covered && covered !== systemSkills) {
-            const text = snapshotCurrentText(systemSkills?.payload, covered.payload);
+            const text = snapshotCurrentText(systemSkills?.payload, covered.payload, skillTexts);
             if (text !== "")
                 messages.push({ role: "system", content: text });
         }
         // phase D: the skills a person invoked in the summarised range, by name (from the log only)
-        const invoked = invokedSkillsText(invokedSkillNames(events, after));
+        const invoked = invokedSkillsText(invokedSkillNames(events, after), skillTexts);
         if (invoked !== "")
             messages.push({ role: "system", content: invoked });
     }
     for (const [i, e] of events.entries()) {
         if (e.seq <= after)
             continue;
+        if (isAbsorbable(e)) {
+            switch (absorbed === undefined ? "inline" : placement(i, e.seq)) {
+                case "inline":
+                    // seq 更小的延后事件被同一次或更早的调用吸收：先放它们，保持发送顺序。
+                    flush(e.seq - 1);
+                    messages.push(absorbableMessage(e));
+                    break;
+                case "deferred":
+                    deferred.push(e);
+                    break;
+                default:
+                    break;
+            }
+            continue;
+        }
         switch (e.type) {
-            case "user_message":
-                switch (absorbed === undefined ? "inline" : placement(i, e.seq)) {
-                    case "inline":
-                        // seq 更小的延后消息被同一次或更早的调用吸收：先放它们，保持用户消息的发送顺序。
-                        flush(e.seq - 1);
-                        messages.push({ role: "user", content: userBlocks(e) });
-                        break;
-                    case "deferred":
-                        deferred.push(e);
-                        break;
-                    default:
-                        break;
-                }
-                break;
             case "model_call":
                 emitRaced(e.payload.request.toSeq);
                 if (absorbed !== undefined)
@@ -588,7 +601,7 @@ export function buildModelRequest(input) {
                 break;
             case "skills_catalog":
                 if (e !== systemSkills) {
-                    const text = snapshotChangeText(prevSnapshot.get(e.seq), e.payload);
+                    const text = snapshotChangeText(prevSnapshot.get(e.seq), e.payload, skillTexts);
                     if (text !== "")
                         messages.push({ role: "system", content: text });
                 }
@@ -608,7 +621,9 @@ export function buildModelRequest(input) {
         : `${BEHAVIOR_RULES}\n\n${agent.instructions}`;
     const system = [
         {
-            text: systemSkills ? `${base}\n\n${snapshotSystemText(systemSkills.payload)}` : base,
+            text: systemSkills
+                ? `${base}\n\n${snapshotSystemText(systemSkills.payload, skillTexts)}`
+                : base,
             cache: true,
         },
     ];
@@ -622,7 +637,10 @@ export function buildModelRequest(input) {
         tools = [...sorted.filter((t) => isAlwaysLoaded(t.key)), ...loaded];
         if (deferred.length > 0) {
             catalog = deferred;
-            system.push({ text: catalogText(deferred), cache: true });
+            system.push({
+                text: catalogText(deferred, legacyNames ? LEGACY_CATALOG_HEADER : undefined),
+                cache: true,
+            });
         }
     }
     const request = {
@@ -664,7 +682,7 @@ export function buildModelRequest(input) {
     return { request, meta, mediaTokens };
 }
 /**
- * 日志里 `tool_search` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
+ * 日志里 `ToolSearch` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
  * 不看压缩摘要的边界：加载过的工具在摘要之后仍保持加载（模型可能凭摘要继续使用它们，且已发送的工具列表只追加）。
  */
 export function loadedToolKeys(events) {

package/dist/runtime/context/claude-tools.d.ts

@@ -6,6 +6,8 @@
  * English, fixed (Decision 15: not tailored to the agent's tools; it says "when it is in your
  * tools" instead). Changing it only affects snapshots written afterwards: a conversation's next
  * run writes a new snapshot announcing the new map, and old snapshots keep their text (phase C
- * changed the Task / Agent line, sub-agents spec §16.5).
+ * changed the Task / Agent line, sub-agents spec §16.5; the tool-naming change shortened it to the
+ * Claude Code names, spec 2026-10-29 §6; background Bash made TaskOutput and TaskStop available,
+ * spec 2026-11-05 §4.4; WebFetch and WebSearch joined the same-name list with the web tools).
  */
 export declare const CLAUDE_CODE_TOOL_MAP: string;

package/dist/runtime/context/claude-tools.js

@@ -6,19 +6,19 @@
  * English, fixed (Decision 15: not tailored to the agent's tools; it says "when it is in your
  * tools" instead). Changing it only affects snapshots written afterwards: a conversation's next
  * run writes a new snapshot announcing the new map, and old snapshots keep their text (phase C
- * changed the Task / Agent line, sub-agents spec §16.5).
+ * changed the Task / Agent line, sub-agents spec §16.5; the tool-naming change shortened it to the
+ * Claude Code names, spec 2026-10-29 §6; background Bash made TaskOutput and TaskStop available,
+ * spec 2026-11-05 §4.4; WebFetch and WebSearch joined the same-name list with the web tools).
  */
 export const CLAUDE_CODE_TOOL_MAP = [
-    "Some skills in this conversation were written for Claude Code and name its tools. Use these tools instead:",
-    "- Bash -> sandbox_bash",
-    "- Read -> sandbox_read; Write -> sandbox_write; Edit and MultiEdit -> sandbox_edit; Glob -> sandbox_glob; Grep -> sandbox_grep",
-    '- Skill -> skill_load (a name such as "superpowers:brainstorming" also works)',
-    "- TodoWrite -> todo__write when it is in your tools; otherwise keep the task list in your replies",
-    "- AskUserQuestion -> ask_user",
-    "- ToolSearch -> tool_search when it is in your tools",
-    "- Task and Agent (sub-agents) -> agent when it is in your tools (subagent_type names one of the types its description lists; model names haiku / sonnet / opus -> fast / standard / capable; SendMessage to a sub-agent -> agent with resume); otherwise not available: do the steps yourself, in order",
-    "- TaskOutput, TaskStop -> not available",
-    "- Any other tool a skill names (for example WebFetch, WebSearch, NotebookEdit, EnterWorktree) -> not available unless one of your tools does the same job",
+    "Some skills in this conversation were written for Claude Code. Its tools Bash, Read, Write, Edit,",
+    "Glob, Grep, Skill, AskUserQuestion, ToolSearch, Agent, WebFetch and WebSearch have the same names here, when they are",
+    "in your tools. For the others:",
+    "- MultiEdit -> several Edit calls",
+    "- TodoWrite -> plugin__todo__write when it is in your tools; otherwise keep the task list in your replies",
+    "- Task -> Agent; SendMessage to a sub-agent -> Agent with resume; model names haiku / sonnet / opus -> fast / standard / capable",
+    "- TaskOutput -> TaskOutput, TaskStop -> TaskStop",
+    "- Any other tool a skill names (for example NotebookEdit, EnterWorktree) -> not available unless one of your tools does the same job",
     // biome-ignore lint/suspicious/noTemplateCurlyInString: the literal Claude Code variable the model reads
-    "The sandbox tools exist only when this agent has a sandbox; without them a skill's scripts cannot run. A path such as ${CLAUDE_PLUGIN_ROOT}/skills/<name>/... means /skills/<name>/... after skill_load has copied that skill into the sandbox.",
+    "The sandbox tools exist only when this agent has a sandbox; without them a skill's scripts cannot run. A path such as ${CLAUDE_PLUGIN_ROOT}/skills/<name>/... means /skills/<name>/... after Skill has copied that skill into the sandbox.",
 ].join("\n");

package/dist/runtime/context/compaction.js

@@ -1,3 +1,4 @@
+import { renderBackgroundFinished } from "../../background/render.js";
 import { latestSummary } from "./build.js";
 /** 压缩请求的标记：放在 system 中，便于识别（model-fake 据此返回摘要）。 */
 export const COMPACTION_MARKER = "CAPYBARA_COMPACTION";
@@ -111,6 +112,9 @@ function transcriptLine(e) {
         }
         case "reminder":
             return `System reminder: ${e.payload.text}`;
+        // a finished background task is a system message of the request (build.ts)
+        case "background_task_finished":
+            return `System reminder: ${renderBackgroundFinished(e.payload)}`;
         // phase D: a forked skill's report is user content of the request (build.ts)
         case "skill_fork_result":
             return `User: ${e.payload.text}`;

package/dist/runtime/context/legacy-text.d.ts

@@ -0,0 +1,22 @@
+import type { SkillTexts } from "./skills.js";
+/**
+ * The system texts of a request as the release candidates rendered them, naming the old builtins
+ * (`skill_load`, `tool_search`). FROZEN: verbatim copies from `main` at 02b9634b
+ * (`runtime/context/skills.ts`, `tools/builtins/tool-search.ts`); never edit them. A request whose
+ * tools hold an old builtin key (a recording made before the rename) is rebuilt with these, so it
+ * reconstructs with no `system_hash` drift (tool naming spec §10). `check:terms` exempts this file.
+ *
+ * The skills texts (`skills.ts`) naming `skill_load`.
+ */
+export declare const LEGACY_SKILL_TEXTS: SkillTexts;
+/** The tool catalog header (`tools/builtins/tool-search.ts` `CATALOG_HEADER`) naming `tool_search`. */
+export declare const LEGACY_CATALOG_HEADER: string;
+/**
+ * Was this request's tool list recorded before the rename? True when one of its tool keys is a
+ * release-candidate builtin name (the run's tools, as the request carries them). Every request
+ * that renders one of these texts offers the tool it names (`skill_load` whenever the log has a
+ * skills catalog or an invocation, `tool_search` with a tool catalog), so the tools decide it.
+ */
+export declare function usesLegacyToolNames(tools: readonly {
+    key: string;
+}[]): boolean;

package/dist/runtime/context/legacy-text.js

@@ -0,0 +1,37 @@
+import { isLegacyBuiltinKey } from "../../tools/legacy-keys.js";
+/**
+ * The system texts of a request as the release candidates rendered them, naming the old builtins
+ * (`skill_load`, `tool_search`). FROZEN: verbatim copies from `main` at 02b9634b
+ * (`runtime/context/skills.ts`, `tools/builtins/tool-search.ts`); never edit them. A request whose
+ * tools hold an old builtin key (a recording made before the rename) is rebuilt with these, so it
+ * reconstructs with no `system_hash` drift (tool naming spec §10). `check:terms` exempts this file.
+ *
+ * The skills texts (`skills.ts`) naming `skill_load`.
+ */
+export const LEGACY_SKILL_TEXTS = Object.freeze({
+    skillsCatalogHeader: "Skills are available in this conversation. A skill is a set of instructions, sometimes with " +
+        "scripts or other files, for a specific kind of task. When a task matches a skill's description, " +
+        "call skill_load with the skill's name to read its instructions before you start; do not guess " +
+        "what a skill says. Available skills:",
+    newSkills: "New skills (call skill_load with the name to use one):",
+    updatedSkills: "Updated skills (call skill_load again before relying on earlier instructions):",
+    currentSkills: "Skills available in this conversation now (this replaces any earlier list of skills; call " +
+        "skill_load with a name to read a skill's instructions):",
+    invokedSkills: (names) => `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call skill_load with a name to read its instructions again.`,
+    pinnedSkillsHeader: "Pinned skills: the owner of this agent pinned these skills, so their instructions apply " +
+        "throughout this conversation. Follow them without calling skill_load; call skill_load " +
+        "only to copy a pinned skill's files into the sandbox.",
+});
+/** The tool catalog header (`tools/builtins/tool-search.ts` `CATALOG_HEADER`) naming `tool_search`. */
+export const LEGACY_CATALOG_HEADER = "More tools are available but not loaded. To use one, first call tool_search with keywords; " +
+    "it returns the full definitions and loads the matching tools for your next step. " +
+    "Calling a tool that is not loaded returns an error. Tool catalog:";
+/**
+ * Was this request's tool list recorded before the rename? True when one of its tool keys is a
+ * release-candidate builtin name (the run's tools, as the request carries them). Every request
+ * that renders one of these texts offers the tool it names (`skill_load` whenever the log has a
+ * skills catalog or an invocation, `tool_search` with a tool catalog), so the tools decide it.
+ */
+export function usesLegacyToolNames(tools) {
+    return tools.some((t) => isLegacyBuiltinKey(t.key));
+}

package/dist/runtime/context/skills.d.ts

@@ -13,14 +13,32 @@ export type PinnedSkill = NonNullable<SkillsSnapshot["pinned"]>[number];
 export type SkillsCatalogEvent = Extract<ConversationEvent, {
     type: "skills_catalog";
 }>;
-/** 加载技能的内置工具名。 */
-export declare const SKILL_LOAD = "skill_load";
+/**
+ * The model-visible skills texts that name the skill-loading builtin. A request recorded before the
+ * tool rename renders {@link LEGACY_SKILL_TEXTS} instead (`./legacy-text.ts`, chosen from the
+ * request's tools by `usesLegacyToolNames`), so its system text stays as it was sent.
+ */
+export interface SkillTexts {
+    /** The header of the first catalog (in the system cache segment). */
+    skillsCatalogHeader: string;
+    /** The heading of the added skills in a change notice. */
+    newSkills: string;
+    /** The heading of the updated skills in a change notice. */
+    updatedSkills: string;
+    /** The heading of the current catalog after a compaction summary. */
+    currentSkills: string;
+    /** The line restored after a compaction summary for the invoked skills (`names` non-empty). */
+    invokedSkills: (names: readonly string[]) => string;
+    /** The header of the pinned skills in the system cache segment. */
+    pinnedSkillsHeader: string;
+}
+export declare const SKILL_TEXTS: SkillTexts;
 /** 目录开头的说明（system 缓存段里的第一份目录）。 */
 export declare const SKILLS_CATALOG_HEADER: string;
-/** 目录里每个技能描述最多的码点数（超出确定地截断；`skill_load` 仍返回完整正文）。 */
+/** 目录里每个技能描述最多的码点数（超出确定地截断；`Skill` 仍返回完整正文）。 */
 export declare const CATALOG_DESCRIPTION_MAX_CHARS = 300;
 /** 第一份目录（进 system 缓存段），按名字排序。 */
-export declare function skillsCatalogText(skills: readonly CatalogSkill[]): string;
+export declare function skillsCatalogText(skills: readonly CatalogSkill[], texts?: SkillTexts): string;
 /** 两份快照是否相同（按 id、版本、名字、描述与来源）。顺序无关。 */
 export declare function sameSkills(a: readonly CatalogSkill[], b: readonly CatalogSkill[]): boolean;
 /**
@@ -41,14 +59,14 @@ export declare function sameSnapshot(a: SkillsSnapshot, b: SkillsSnapshot): bool
  * 试用草稿被拒绝 / 批准了别人的同号版本时，内容变了而版本号可能不变）。
  * `prev` 为上一份快照（没有为空）。
  */
-export declare function skillsChangeText(prev: readonly CatalogSkill[], next: readonly CatalogSkill[], pinnedIds?: ReadonlySet<string>): string;
+export declare function skillsChangeText(prev: readonly CatalogSkill[], next: readonly CatalogSkill[], pinnedIds?: ReadonlySet<string>, texts?: SkillTexts): string;
 /** 压缩摘要之后补上的「当前目录」（与 system 里的第一份不同时）：完整列出，替代之前的目录与提醒。 */
-export declare function skillsCurrentText(skills: readonly CatalogSkill[]): string;
+export declare function skillsCurrentText(skills: readonly CatalogSkill[], texts?: SkillTexts): string;
 /**
  * The line restored after a compaction summary whose range holds inline skill invocations
  * (`names`: distinct, code point order); empty for none. Bodies are not re-injected.
  */
-export declare function invokedSkillsText(names: readonly string[]): string;
+export declare function invokedSkillsText(names: readonly string[], texts?: SkillTexts): string;
 /** The distinct names (code point order) of the inline invocations in `events` up to `upToSeq`. */
 export declare function invokedSkillNames(events: readonly ConversationEvent[], upToSeq: number): string[];
 /** A skill a person invoked: the version recorded in their message. */
@@ -78,7 +96,7 @@ export declare const PINNED_SKILLS_HEADER: string;
 /** One pinned skill with its body. */
 export declare function pinnedBlock(p: PinnedSkill): string;
 /** The pinned skills of the system snapshot (non-empty), after the catalog. */
-export declare function pinnedSystemText(pinned: readonly PinnedSkill[]): string;
+export declare function pinnedSystemText(pinned: readonly PinnedSkill[], texts?: SkillTexts): string;
 /**
  * The pinned change notice between two snapshots ({@link samePinned} false): each entry that is new
  * or has another version or source, with its whole body; then the names of the removed ones.
@@ -94,12 +112,12 @@ export declare function toolMapChangeText(next: string | undefined): string;
  * nothing else differs: logs before phase B render exactly as before), the pinned change, the
  * tool-name map change; joined by blank lines.
  */
-export declare function snapshotChangeText(prev: SkillsSnapshot | undefined, next: SkillsSnapshot): string;
+export declare function snapshotChangeText(prev: SkillsSnapshot | undefined, next: SkillsSnapshot, texts?: SkillTexts): string;
 /**
  * What follows a compaction summary when the covered snapshot is not the system one: today's
  * current catalog (when the skills differ from the system snapshot's), the current pinned skills
  * (when they differ), the tool-name map (when it differs); joined by blank lines, "" for nothing.
  */
-export declare function snapshotCurrentText(system: SkillsSnapshot | undefined, covered: SkillsSnapshot): string;
+export declare function snapshotCurrentText(system: SkillsSnapshot | undefined, covered: SkillsSnapshot, texts?: SkillTexts): string;
 /** The system snapshot's text after the agent's instructions: catalog, pinned skills, tool map. */
-export declare function snapshotSystemText(s: SkillsSnapshot): string;
+export declare function snapshotSystemText(s: SkillsSnapshot, texts?: SkillTexts): string;