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

package/dist/runtime/context/build.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { MEDIA_LIMITS, } from "@capybara-hq/plugin-sdk";
 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,7 +323,7 @@ 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 里的
  *   不同，紧随摘要补一条完整的当前目录；
@@ -488,6 +489,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,12 +509,12 @@ 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 });
     }
@@ -588,7 +593,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 +613,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 +629,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 +674,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,7 @@
  * 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).
  */
 export declare const CLAUDE_CODE_TOOL_MAP: string;

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

@@ -6,19 +6,18 @@
  * 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).
  */
 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",
+    "Some skills in this conversation were written for Claude Code. Its tools Bash, Read, Write, Edit,",
+    "Glob, Grep, Skill, AskUserQuestion, ToolSearch and Agent 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, 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",
     // 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/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;

package/dist/runtime/context/skills.js

@@ -1,13 +1,23 @@
-/** 加载技能的内置工具名。 */
-export const SKILL_LOAD = "skill_load";
+import { SKILL_LOAD } from "../../tools/builtin-names.js";
+export const 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.",
+});
 /** 目录开头的说明（system 缓存段里的第一份目录）。 */
-export const SKILLS_CATALOG_HEADER = "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:";
+export const SKILLS_CATALOG_HEADER = SKILL_TEXTS.skillsCatalogHeader;
 /** 按码点比较名字（与区域设置无关，结果确定）。 */
 const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-/** 目录里每个技能描述最多的码点数（超出确定地截断；`skill_load` 仍返回完整正文）。 */
+/** 目录里每个技能描述最多的码点数（超出确定地截断；`Skill` 仍返回完整正文）。 */
 export const CATALOG_DESCRIPTION_MAX_CHARS = 300;
 /** 折叠成一行，按码点截到 {@link CATALOG_DESCRIPTION_MAX_CHARS}。 */
 function shortDescription(d) {
@@ -21,8 +31,8 @@ function shortDescription(d) {
 const line = (s) => `- ${s.name}: ${shortDescription(s.description)}`;
 const lines = (skills) => [...skills].sort(byName).map(line).join("\n");
 /** 第一份目录（进 system 缓存段），按名字排序。 */
-export function skillsCatalogText(skills) {
-    return `${SKILLS_CATALOG_HEADER}\n${lines(skills)}`;
+export function skillsCatalogText(skills, texts = SKILL_TEXTS) {
+    return `${texts.skillsCatalogHeader}\n${lines(skills)}`;
 }
 /** 两份快照是否相同（按 id、版本、名字、描述与来源）。顺序无关。 */
 export function sameSkills(a, b) {
@@ -66,7 +76,7 @@ export function sameSnapshot(a, b) {
 /**
  * The catalog differences between two snapshots. `pinnedIds` (the next snapshot's pinned ids, phase
  * B) are left out of `updated`: a pinned skill's new body is rendered by {@link pinnedChangeText},
- * and the pinned header says not to call `skill_load` for it.
+ * and the pinned header says not to call `Skill` for it.
  */
 function catalogChanges(prev, next, pinnedIds) {
     const before = new Map(prev.map((s) => [s.id, s]));
@@ -86,14 +96,14 @@ function catalogChanges(prev, next, pinnedIds) {
  * 试用草稿被拒绝 / 批准了别人的同号版本时，内容变了而版本号可能不变）。
  * `prev` 为上一份快照（没有为空）。
  */
-export function skillsChangeText(prev, next, pinnedIds) {
+export function skillsChangeText(prev, next, pinnedIds, texts = SKILL_TEXTS) {
     const { added, updated, removed } = catalogChanges(prev, next, pinnedIds);
     const parts = ["The skills available in this conversation have changed."];
     if (added.length > 0) {
-        parts.push(`New skills (call ${SKILL_LOAD} with the name to use one):\n${lines(added)}`);
+        parts.push(`${texts.newSkills}\n${lines(added)}`);
     }
     if (updated.length > 0) {
-        parts.push(`Updated skills (call ${SKILL_LOAD} again before relying on earlier instructions):\n${lines(updated)}`);
+        parts.push(`${texts.updatedSkills}\n${lines(updated)}`);
     }
     if (removed.length > 0) {
         parts.push(`Removed skills (no longer available; do not use them): ${[...removed]
@@ -106,22 +116,21 @@ export function skillsChangeText(prev, next, pinnedIds) {
     return parts.join("\n\n");
 }
 /** 压缩摘要之后补上的「当前目录」（与 system 里的第一份不同时）：完整列出，替代之前的目录与提醒。 */
-export function skillsCurrentText(skills) {
+export function skillsCurrentText(skills, texts = SKILL_TEXTS) {
     if (skills.length === 0) {
         return "No skills are available in this conversation now (this replaces any earlier list of skills).";
     }
-    return ("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):\n${lines(skills)}`);
+    return `${texts.currentSkills}\n${lines(skills)}`;
 }
 // ---- Skills a person invoked (phase D spec §4.4; model-visible, English) ----
 /**
  * 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 function invokedSkillsText(names) {
+export function invokedSkillsText(names, texts = SKILL_TEXTS) {
     if (names.length === 0)
         return "";
-    return `Skills the user invoked earlier in this conversation: ${names.join(", ")}. Call ${SKILL_LOAD} with a name to read its instructions again.`;
+    return texts.invokedSkills(names);
 }
 /** The distinct names (code point order) of the inline invocations in `events` up to `upToSeq`. */
 export function invokedSkillNames(events, upToSeq) {
@@ -180,16 +189,14 @@ export function systemSkillsCatalog(events) {
 }
 // ---- Pinned skills and the tool-name map (phase B, spec §9.1, §9.4; model-visible, English) ----
 /** The header of the pinned skills in the system cache segment. */
-export const PINNED_SKILLS_HEADER = "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.";
+export const PINNED_SKILLS_HEADER = SKILL_TEXTS.pinnedSkillsHeader;
 /** One pinned skill with its body. */
 export function pinnedBlock(p) {
     return `<pinned_skill name="${p.name}" version="${p.version}">\n${p.body.trim()}\n</pinned_skill>`;
 }
 /** The pinned skills of the system snapshot (non-empty), after the catalog. */
-export function pinnedSystemText(pinned) {
-    return `${PINNED_SKILLS_HEADER}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
+export function pinnedSystemText(pinned, texts = SKILL_TEXTS) {
+    return `${texts.pinnedSkillsHeader}\n\n${pinned.map(pinnedBlock).join("\n\n")}`;
 }
 /**
  * The pinned change notice between two snapshots ({@link samePinned} false): each entry that is new
@@ -233,7 +240,7 @@ export function toolMapChangeText(next) {
  * nothing else differs: logs before phase B render exactly as before), the pinned change, the
  * tool-name map change; joined by blank lines.
  */
-export function snapshotChangeText(prev, next) {
+export function snapshotChangeText(prev, next, texts = SKILL_TEXTS) {
     const prevSkills = prev?.skills ?? [];
     const pinnedDiff = !samePinned(prev?.pinned, next.pinned);
     const mapDiff = prev?.toolMap !== next.toolMap;
@@ -247,7 +254,7 @@ export function snapshotChangeText(prev, next) {
         : !sameSkills(prevSkills, next.skills);
     const parts = [];
     if (catalogDiff || (!pinnedDiff && !mapDiff)) {
-        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds));
+        parts.push(skillsChangeText(prevSkills, next.skills, pinnedIds, texts));
     }
     if (pinnedDiff)
         parts.push(pinnedChangeText(prev?.pinned, next.pinned));
@@ -260,10 +267,10 @@ export function snapshotChangeText(prev, next) {
  * 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 function snapshotCurrentText(system, covered) {
+export function snapshotCurrentText(system, covered, texts = SKILL_TEXTS) {
     const parts = [];
     if (!sameSkills(system?.skills ?? [], covered.skills)) {
-        parts.push(skillsCurrentText(covered.skills));
+        parts.push(skillsCurrentText(covered.skills, texts));
     }
     if (!samePinned(system?.pinned, covered.pinned))
         parts.push(pinnedCurrentText(covered.pinned));
@@ -273,10 +280,10 @@ export function snapshotCurrentText(system, covered) {
     return parts.join("\n\n");
 }
 /** The system snapshot's text after the agent's instructions: catalog, pinned skills, tool map. */
-export function snapshotSystemText(s) {
-    let text = skillsCatalogText(s.skills);
+export function snapshotSystemText(s, texts = SKILL_TEXTS) {
+    let text = skillsCatalogText(s.skills, texts);
     if (s.pinned && s.pinned.length > 0)
-        text += `\n\n${pinnedSystemText(s.pinned)}`;
+        text += `\n\n${pinnedSystemText(s.pinned, texts)}`;
     if (s.toolMap !== undefined)
         text += `\n\n${s.toolMap}`;
     return text;

package/dist/runtime/loop.d.ts

@@ -53,7 +53,7 @@ export interface SubagentParent {
     otherAgent?: boolean;
 }
 /**
- * 运行在等什么人处理：审批（`approvals` 行）或输入请求（`questions` 行，统一承载 `ask_user`、
+ * 运行在等什么人处理：审批（`approvals` 行）或输入请求（`questions` 行，统一承载 `AskUserQuestion`、
  * 插件工具的 `input_required` 与 MCP elicitation）。`expiresAt` 为 ISO 时间。
  * `subagents` (phase C, spec §7.2): sub-agents dispatched in a step are still running; the id is
  * `sa-<runId>-<step>` (no `:`, it is part of BullMQ job ids).

package/dist/runtime/model-call.js

@@ -128,7 +128,7 @@ async function runStep(deps, input, wrapUp) {
         }
         // 每步实时解析（连接器 / 插件状态可能在步骤之间变化），解析结果记在 model_call；收尾调用同样带工具
         // a skills catalog snapshot (Ruling M17; an empty one too) or a person's skill invocation in the
-        // log → skill_load is offered (see skillLoadOffered)
+        // log → Skill is offered (see skillLoadOffered)
         const resolved = await deps.tools.forAgent(input.orgId, {
             tools: input.agent.tools ?? [],
             subagents: input.agent.subagents,

package/dist/runtime/run-finish.d.ts

@@ -19,7 +19,7 @@ export interface FinishRunArgs {
     floorToTrigger?: boolean;
     /**
      * Runs in the transaction once the run is known not to be terminal, before the terminal event:
-     * a parent's open `agent` calls get their results here (sub-agents spec §12, review m1).
+     * a parent's open `Agent` calls get their results here (sub-agents spec §12, review m1).
      */
     beforeTerminal?: () => Promise<void>;
 }

package/dist/runtime/run-queue.d.ts

@@ -24,7 +24,7 @@ export declare class RunQueue {
     private readonly finisher;
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     private readonly checkpoints;
-    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    /** The run's open `Agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
     private readonly pipeline;
     private readonly events;
     private readonly log;
@@ -32,11 +32,11 @@ export declare class RunQueue {
     constructor(kdb: KernelDb, eventLog: EventLog, lock: Pick<ConversationLock, "holder">, jobs: RunJobs, finisher: Pick<RunFinish, "finishIn">, 
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, 
-    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    /** The run's open `Agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
     pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, events: KernelEvents, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost);
     private get db();
     /**
-     * The `beforeTerminal` of an orphan repair: writes the run's open `agent` call results in the
+     * The `beforeTerminal` of an orphan repair: writes the run's open `Agent` call results in the
      * repair's transaction; `fire()` runs their observe hooks after the commit (review m1).
      */
     private stopOpenCalls;

package/dist/runtime/run-queue.js

@@ -48,7 +48,7 @@ let RunQueue = class RunQueue {
     constructor(kdb, eventLog, lock, jobs, finisher, 
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     checkpoints, 
-    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    /** The run's open `Agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
     pipeline, events, log, txHost) {
         this.kdb = kdb;
         this.eventLog = eventLog;
@@ -65,7 +65,7 @@ let RunQueue = class RunQueue {
         return this.kdb.db;
     }
     /**
-     * The `beforeTerminal` of an orphan repair: writes the run's open `agent` call results in the
+     * The `beforeTerminal` of an orphan repair: writes the run's open `Agent` call results in the
      * repair's transaction; `fire()` runs their observe hooks after the commit (review m1).
      */
     stopOpenCalls(runId) {

package/dist/runtime/run-worker.d.ts

@@ -63,7 +63,7 @@ export declare class RunWorker {
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     private readonly skillsCatalog;
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */
@@ -94,7 +94,7 @@ export declare class RunWorker {
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     skillsCatalog: Pick<SkillsCatalogService, "record">, 
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */

package/dist/runtime/run-worker.js

@@ -10,7 +10,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Inject, Injectable, Optional } from "@nestjs/common";
 import { DelayedError } from "bullmq";
 import { sql } from "kysely";
-import { normalizeStoredDefinition } from "../agents/definition.js";
 import { conversationTopic, EventLog, } from "../conversations/event-log.js";
 import { effectiveDefinition, NO_SELECTION, readSelection, sameModel, sameSelection, } from "../conversations/selection.js";
 import { TitleQueue } from "../conversations/titles.js";
@@ -24,6 +23,7 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { pinnedFailureText, SkillsCatalogService } from "../skills/catalog.js";
+import { normalizeStoredDefinitionIn } from "../tools/legacy-data.js";
 import { ToolPipeline } from "../tools/pipeline.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
@@ -109,7 +109,7 @@ let RunWorker = class RunWorker {
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     skillsCatalog, 
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */
@@ -525,7 +525,7 @@ let RunWorker = class RunWorker {
             // a follow-up runs with its task message's narrowing (final review I1): the frozen tools
             // and org skills the current version still allows, recorded at its dispatch
             const trigger = (await this.eventLog.readAfter(conversationId, Number(run.trigger_seq) - 1, 1))[0];
-            agent = childRunDefinition(normalizeStoredDefinition(started.payload.definition), trigger?.type === "user_message" && trigger.seq === Number(run.trigger_seq)
+            agent = childRunDefinition(await normalizeStoredDefinitionIn(this.db, conv.org_id, started.payload.definition), trigger?.type === "user_message" && trigger.seq === Number(run.trigger_seq)
                 ? trigger.payload.dispatch?.narrowed
                 : undefined);
             maxSteps = Math.min(started.payload.maxSteps, runtime.maxSteps);
@@ -552,7 +552,7 @@ let RunWorker = class RunWorker {
                 .where("agent_id", "=", conv.agent_id)
                 .where("version", "=", run.agent_version)
                 .executeTakeFirstOrThrow();
-            saved = normalizeStoredDefinition(version.definition);
+            saved = await normalizeStoredDefinitionIn(this.db, conv.org_id, version.definition);
             agent = saved;
         }
         let startedAt = run.started_at;

package/dist/runtime/subagents/definition.d.ts

@@ -6,11 +6,7 @@ import type { KernelConfigService } from "../../infra/config/kernel-config.servi
 import type { ModelPurposesService } from "../../models/purposes.js";
 import type { ProviderRegistry } from "../providers.js";
 import type { RosterEntry } from "./roster.js";
-/**
- * Tools a sub-agent never gets (spec §5.3, §5.5): `agent` (depth 1), `ask_user` (the person does not
- * see the child), `sandbox_deliver` (delivering files is the parent's job) and `skill_write`.
- */
-export declare const CHILD_REMOVED_TOOLS: readonly ["agent", "ask_user", "sandbox_deliver", "skill_write"];
+export { CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
 /**
  * The roster entry's template is gone (an inline template edited away, a plugin template
  * uninstalled) between resolving the roster and reading it. The dispatch refuses the call as an
@@ -100,4 +96,3 @@ export declare function intersectTools(frozen: readonly AgentToolRef[], current:
 export declare function narrowFollowUp(frozen: Pick<AgentDefinition, "tools" | "skills">, current: Pick<AgentDefinition, "tools" | "skills">): FollowUpNarrowing;
 /** The definition a child run uses: the frozen one with its trigger's follow-up narrowing. */
 export declare function childRunDefinition(frozen: AgentDefinition, narrowed: FollowUpNarrowing | undefined): AgentDefinition;
-export {};