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

package/dist/conversations/event-log.js

@@ -191,6 +191,25 @@ let EventLog = class EventLog {
             .executeTakeFirst();
         return r && toEvent(r);
     }
+    /**
+     * The file state (`tool_result.view.file`) the latest `Read` / `Write` / `Edit` result of this
+     * conversation recorded for `path` (a normalized sandbox path); null when none did. One index
+     * probe per call: the partial index `conversation_events_file_state_idx` of migration 0063
+     * (conversation_id, view.file.path, seq DESC; tool_result rows only) answers it, also for a path
+     * never read (the query's predicate must keep matching that index's expression).
+     */
+    async latestFileState(conversationId, path) {
+        const r = await this.db
+            .selectFrom("conversation_events")
+            .select(sql `payload->'view'->'file'`.as("file"))
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "tool_result")
+            .where(sql `payload->'view'->'file'->>'path' = ${path}`)
+            .orderBy("seq", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        return r ? { size: r.file.size, sha256: r.file.sha256 } : null;
+    }
     validate(e) {
         const r = ConversationEventSchema.safeParse({ type: e.type, payload: e.payload });
         if (!r.success) {

package/dist/conversations/events.d.ts

@@ -86,10 +86,10 @@ export type LogContentBlock = Exclude<ContentBlock, MediaBlock> | (MediaBlock ex
 } : never : never);
 /**
  * Structured view of a builtin tool's result (UI refresh B, spec §5.5 / §5.9): display only, like
- * `display`. `command`: `sandbox_bash` (the model's `description`, the exit code, null when the
+ * `display`. `command`: `Bash` (the model's `description`, the exit code, null when the
  * command was stopped, and whether it timed out; the web shows "Failed" for a non-zero exit even
- * though `isError` stays false); `edit`: `sandbox_edit` / `sandbox_write` (a capped line diff);
- * `read`: `sandbox_read` (the line range shown).
+ * though `isError` stays false); `edit`: `Edit` / `Write` (a capped line diff);
+ * `read`: `Read` (the line range shown).
  */
 export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"command">;
@@ -103,6 +103,11 @@ export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     added: z.ZodNumber;
     removed: z.ZodNumber;
     truncated: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+    }, z.core.$strip>>;
     hunks: z.ZodArray<z.ZodObject<{
         oldStart: z.ZodNumber;
         newStart: z.ZodNumber;
@@ -120,6 +125,11 @@ export declare const ToolViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     path: z.ZodString;
     fromLine: z.ZodOptional<z.ZodNumber>;
     toLine: z.ZodOptional<z.ZodNumber>;
+    file: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "kind">;
 export type ToolView = z.infer<typeof ToolViewSchema>;
 /**
@@ -441,6 +451,11 @@ export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             added: z.ZodNumber;
             removed: z.ZodNumber;
             truncated: z.ZodBoolean;
+            file: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                size: z.ZodNumber;
+                sha256: z.ZodString;
+            }, z.core.$strip>>;
             hunks: z.ZodArray<z.ZodObject<{
                 oldStart: z.ZodNumber;
                 newStart: z.ZodNumber;
@@ -458,6 +473,11 @@ export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             path: z.ZodString;
             fromLine: z.ZodOptional<z.ZodNumber>;
             toLine: z.ZodOptional<z.ZodNumber>;
+            file: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                size: z.ZodNumber;
+                sha256: z.ZodString;
+            }, z.core.$strip>>;
         }, z.core.$strip>], "kind">>;
         card: z.ZodOptional<z.ZodObject<{
             plugin: z.ZodString;

package/dist/conversations/events.js

@@ -75,12 +75,22 @@ const STOP_REASONS = ["end_turn", "tool_use", "max_tokens", "refusal", "other"];
 const EFFORT_ENUM = ["low", "medium", "high", "xhigh", "max"];
 const seqNo = z.number().int().nonnegative();
 const count = z.number().int().nonnegative();
+/**
+ * The state of a file a `Read` / `Write` / `Edit` saw or left (display only, but the kernel reads it
+ * back from the log to decide read-before-write): the full normalized path, the file's full size and
+ * the sha256 of the bytes handled (the first bytes only for a file over `Read`'s byte limit).
+ */
+const FileStateViewSchema = z.object({
+    path: z.string().max(4096),
+    size: count,
+    sha256: z.string().regex(/^[0-9a-f]{64}$/),
+});
 /**
  * Structured view of a builtin tool's result (UI refresh B, spec §5.5 / §5.9): display only, like
- * `display`. `command`: `sandbox_bash` (the model's `description`, the exit code, null when the
+ * `display`. `command`: `Bash` (the model's `description`, the exit code, null when the
  * command was stopped, and whether it timed out; the web shows "Failed" for a non-zero exit even
- * though `isError` stays false); `edit`: `sandbox_edit` / `sandbox_write` (a capped line diff);
- * `read`: `sandbox_read` (the line range shown).
+ * though `isError` stays false); `edit`: `Edit` / `Write` (a capped line diff);
+ * `read`: `Read` (the line range shown).
  */
 export const ToolViewSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -96,6 +106,7 @@ export const ToolViewSchema = z.discriminatedUnion("kind", [
         added: count,
         removed: count,
         truncated: z.boolean(),
+        file: FileStateViewSchema.optional(),
         hunks: z
             .array(z.object({
             oldStart: count,
@@ -114,6 +125,7 @@ export const ToolViewSchema = z.discriminatedUnion("kind", [
         path: z.string().max(TOOL_VIEW_PATH_MAX_CHARS),
         fromLine: count.optional(),
         toLine: count.optional(),
+        file: FileStateViewSchema.optional(),
     }),
 ]);
 const ModelUsageShape = {
@@ -260,13 +272,13 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
              */
             absorbedUpToSeq: seqNo.optional(),
             /**
-             * 本次请求带给模型的工具（按发送顺序：未启用 tool_search 时按 key 排序；启用时为内置工具按 key 排序，
+             * 本次请求带给模型的工具（按发送顺序：未启用 ToolSearch 时按 key 排序；启用时为内置工具按 key 排序，
              * 其后是已加载工具按首次加载顺序）及其定义指纹（`ResolvedTool.specHash`）。
              * 模型不支持工具时为空数组。较早的事件可能没有。
              */
             tools: z.array(z.object({ key: z.string(), specHash: z.string() })).optional(),
             /**
-             * 启用 tool_search 时 system 第二块目录里的工具（按 key 排序）及定义指纹；定义同样存在
+             * 启用 ToolSearch 时 system 第二块目录里的工具（按 key 排序）及定义指纹；定义同样存在
              * `capybara.tool_specs`，目录文本可由它们还原。未启用时不写。
              */
             catalog: z.array(z.object({ key: z.string(), specHash: z.string() })).optional(),
@@ -339,7 +351,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         outputId: z.string().optional(),
         contentTypes: z.array(z.string()).optional(),
         /**
-         * `tool_search` 本次加载的工具 key（没有匹配时不写）。已加载集合 = 会话中全部 tool_result 的
+         * `ToolSearch` 本次加载的工具 key（没有匹配时不写）。已加载集合 = 会话中全部 tool_result 的
          * `loadedTools` 并集（含已被摘要覆盖的部分），构建请求时由日志还原，不放进程内存。
          */
         loadedTools: z.array(z.string()).optional(),
@@ -395,7 +407,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         reason: z.string().max(APPROVAL_DENY_REASON_MAX_CHARS).optional(),
     })),
     /**
-     * 工具调用需要用户输入（`ask_user`、插件工具的 `input_required`、MCP elicitation）：输入请求已建，
+     * 工具调用需要用户输入（`AskUserQuestion`、插件工具的 `input_required`、MCP elicitation）：输入请求已建，
      * run 暂停等待回答。界面据此显示表单卡片（不进模型请求）。
      */
     ev("question_asked", z.object({
@@ -423,7 +435,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         reason: z.enum(["provider_rejected"]),
     })),
     /**
-     * agent 经 `sandbox_deliver` 把沙箱里的文件交付给用户（M5 T8，C3）：字节在对象存储
+     * agent 经 `Deliver` 把沙箱里的文件交付给用户（M5 T8，C3）：字节在对象存储
      * `kernel/<orgId>/<objectKey>`（`objectKey` = `artifacts/<conversationId>/<artifactId>`，相对内核前缀），
      * 这里只有元数据。网页从日志重建产物列表；不进模型请求（模型看到的是同一调用的 tool_result 确认）。
      */
@@ -439,7 +451,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
     /**
      * 本对话此刻生效的技能（M5 T14，Ruling M17）：运行开始时内核解析生效的技能集合（agent 版本选中的组织技能 +
      * agent 自己的技能，未删除，取 current_version），与日志里上一份快照不同才写。模型看到的技能目录只来自这里：
-     * 第一份（在任何 `model_call` 之前）进 system 缓存段，之后的在所在位置渲染为英文变更提醒；`skill_load` 按最新一份
+     * 第一份（在任何 `model_call` 之前）进 system 缓存段，之后的在所在位置渲染为英文变更提醒；`Skill` 按最新一份
      * 把名字解析为 id 与版本。按 name 排序。
      */
     ev("skills_catalog", z.object({
@@ -451,12 +463,12 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
             version: z.number().int().positive(),
             /**
              * 内容来源（对象前缀，T15）：已生成的版本为 `skill_versions.object_prefix`，试用中的草稿为申请的
-             * `object_prefix`。同号的草稿与正式版本靠它区分；`skill_load` 只按它解析。
+             * `object_prefix`。同号的草稿与正式版本靠它区分；`Skill` 只按它解析。
              */
             source: z.string().min(1).max(512),
             /**
              * The catalog item (plugin) name the skill came from (phase B); absent for the org's
-             * own and the agent's skills, and in snapshots written before phase B. `skill_load`
+             * own and the agent's skills, and in snapshots written before phase B. `Skill`
              * resolves `<plugin>:<name>` with it; it is not model-visible otherwise.
              */
             plugin: z.string().min(1).max(64).optional(),
@@ -465,7 +477,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         /**
          * Pinned skills (phase B, spec §9.1) in the agent's order: each a skill of `skills` (same
          * id, version and source) with its SKILL.md body as read at run start or written by
-         * skill_write. Absent means none (every snapshot before phase B).
+         * SkillWrite. Absent means none (every snapshot before phase B).
          */
         pinned: z
             .array(z.object({
@@ -534,7 +546,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         warnings: z.array(z.string()).optional(),
     })),
     /**
-     * Parent log (phase C, spec §14.1): the `agent` call `callId` started (or resumed) the sub-agent
+     * Parent log (phase C, spec §14.1): the `Agent` call `callId` started (or resumed) the sub-agent
      * `subagentId` (its child conversation id) with run `childRunId`. Not model-visible: the model
      * sees the call's tool_call / tool_result pair.
      */
@@ -550,7 +562,7 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         tierFallback: z.boolean().optional(),
         /**
          * Phase D: the seq of the person's fork invocation this dispatch runs (`callId` is
-         * `skill-<seq>`, step 0, no tool call); absent for an `agent` call.
+         * `skill-<seq>`, step 0, no tool call); absent for an `Agent` call.
          */
         invokedSeq: seqNo.optional(),
     })),

package/dist/db/kernel-schema.d.ts

@@ -269,7 +269,7 @@ export interface RunsTable {
     /** 0054: when this run's `subagents` wait expires (set while it waits on sub-agents). */
     wait_expires_at: TsNullable;
 }
-/** 0053: one row per sub-agent dispatch (an `agent` call of a parent run). */
+/** 0053: one row per sub-agent dispatch (an `Agent` call of a parent run). */
 export interface SubagentDispatchesTable {
     parent_run_id: string;
     parent_call_id: string;
@@ -400,7 +400,7 @@ export interface ApprovalsTable {
     /** 0056: the reason given with a denial (null without one). */
     deny_reason: Generated<string | null>;
 }
-/** 0010_tools.sql：ask_user 提问。 */
+/** 0010_tools.sql：AskUserQuestion 提问。 */
 export interface QuestionsTable {
     id: string;
     org_id: string;

package/dist/evals/recorded-tools.d.ts

@@ -1,4 +1,5 @@
 import type { EventLog } from "../conversations/event-log.js";
+import { type LegacyScope } from "../tools/legacy-keys.js";
 import { type ToolPipeline, type ToolStepContext } from "../tools/pipeline.js";
 import type { CaseSnapshot } from "./snapshot.js";
 /**
@@ -15,12 +16,34 @@ export interface RecordedCall {
     inputKey: string;
     content: string;
     isError: boolean;
-    /** 原结果里的 `tool_search` 已加载工具（照抄：之后请求的已加载集合由日志还原）。 */
+    /** 原结果里的 `ToolSearch` 已加载工具（照抄：之后请求的已加载集合由日志还原）。 */
     loadedTools?: string[];
     contentTypes?: string[];
     /** 原 `tool_call_started` 的定义指纹（没有开始事件的调用为空串）。 */
     specHash: string;
+    /** The recorded call used release-candidate names; `toolKey` and `inputKey` are already the current ones. */
+    legacy?: true;
 }
+/**
+ * The connectors and extensions an rc `<x>__<tool>` key can name, from positive evidence in the
+ * snapshot only (a head with no evidence, or evidence of both kinds, stays unmapped, so its
+ * recorded calls are unmatched, which is a safe miss):
+ * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
+ *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
+ * - an extension: that definition exists without `connectorData` and its name is the key's tool
+ *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ */
+export declare function legacyScopeOf(s: CaseSnapshot): LegacyScope;
+/**
+ * A recorded call in the current names: an rc builtin or `<x>__<tool>` key becomes its current
+ * key with the input's parameters renamed. Only the recorded side is ever normalized; a call
+ * already in current names (or one that cannot be mapped) is returned as is.
+ */
+export declare function currentCall(name: string, input: unknown, scope: LegacyScope): {
+    name: string;
+    input: unknown;
+    legacy: boolean;
+};
 /** 规范化 JSON：对象键递归按码点排序，数组保持顺序；`undefined` 按 JSON 规则省略。 */
 export declare function canonicalJson(v: unknown): string;
 /** The matching key of a call: the canonical JSON of its input without the ignored fields. */
@@ -43,7 +66,10 @@ export declare class RecordedToolPipeline implements Pick<ToolPipeline, "runStep
     private readonly d;
     private readonly used;
     private misses;
+    private legacyHits;
     constructor(d: RecordedToolPipelineDeps);
+    /** Calls so far matched with a recording made under release-candidate tool names. */
+    legacyMatches(): number;
     /** 至今没有匹配到记录的调用数。 */
     unmatched(): number;
     runStep(ctx: ToolStepContext): Promise<{

package/dist/evals/recorded-tools.js

@@ -1,4 +1,6 @@
 import { assistantIdemKey } from "../runtime/model-call.js";
+import { MATCH_IGNORED_FIELDS } from "../tools/builtin-names.js";
+import { isLegacyPrefixedKey, legacyToolInput, legacyToolKey, } from "../tools/legacy-keys.js";
 import { RUN_STOPPED_TEXT } from "../tools/pipeline.js";
 /**
  * 整轮回放的工具管线（C6 / Review Focus 3）：只回放原运行记录的工具结果，**从不执行任何工具**——
@@ -7,6 +9,77 @@ import { RUN_STOPPED_TEXT } from "../tools/pipeline.js";
  */
 /** 没有匹配记录时模型看到的工具结果（模型可见，英文）。 */
 export const REPLAY_NO_RECORDING = "[replay] No recorded result matches this tool call (same tool and arguments); the tool was not executed during replay.";
+/**
+ * The connectors and extensions an rc `<x>__<tool>` key can name, from positive evidence in the
+ * snapshot only (a head with no evidence, or evidence of both kinds, stays unmapped, so its
+ * recorded calls are unmatched, which is a safe miss):
+ * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
+ *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
+ * - an extension: that definition exists without `connectorData` and its name is the key's tool
+ *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ */
+export function legacyScopeOf(s) {
+    const hashes = new Map();
+    const note = (key, hash) => {
+        if (!isLegacyPrefixedKey(key))
+            return;
+        const set = hashes.get(key) ?? new Set();
+        if (hash !== undefined && hash !== "")
+            set.add(hash);
+        hashes.set(key, set);
+    };
+    for (const e of s.events) {
+        if (e.type === "tool_call_started") {
+            const p = e.payload;
+            note(p.toolKey, p.specHash);
+        }
+        else if (e.type === "model_call") {
+            const r = e.payload.request;
+            for (const t of [...(r?.tools ?? []), ...(r?.catalog ?? [])])
+                note(t.key, t.specHash);
+        }
+    }
+    const extensionNames = new Set();
+    const connectorSlugs = new Set();
+    const planted = new Set();
+    for (const def of Object.values(s.definitions)) {
+        for (const t of def.tools)
+            if (t.kind === "plugin")
+                planted.add(`${t.plugin}__${t.name}`);
+    }
+    for (const [key, set] of hashes) {
+        const i = key.indexOf("__");
+        const head = key.slice(0, i);
+        const tool = key.slice(i + 2);
+        for (const h of set) {
+            const spec = s.toolSpecs[h];
+            if (spec === undefined)
+                continue;
+            if (spec.connectorData !== undefined) {
+                connectorSlugs.add(head);
+            }
+            else if (spec.name === tool) {
+                extensionNames.add(head);
+            }
+        }
+    }
+    for (const key of planted) {
+        if (hashes.has(key))
+            extensionNames.add(key.slice(0, key.indexOf("__")));
+    }
+    return { connectorSlugs, extensionNames };
+}
+/**
+ * A recorded call in the current names: an rc builtin or `<x>__<tool>` key becomes its current
+ * key with the input's parameters renamed. Only the recorded side is ever normalized; a call
+ * already in current names (or one that cannot be mapped) is returned as is.
+ */
+export function currentCall(name, input, scope) {
+    const key = legacyToolKey(name, scope);
+    if (key === null)
+        return { name, input, legacy: false };
+    return { name: key, input: legacyToolInput(name, input), legacy: true };
+}
 /** 规范化 JSON：对象键递归按码点排序，数组保持顺序；`undefined` 按 JSON 规则省略。 */
 export function canonicalJson(v) {
     const norm = (x) => {
@@ -23,14 +96,6 @@ export function canonicalJson(v) {
     };
     return JSON.stringify(norm(v) ?? null);
 }
-/**
- * Input fields left out when matching, per tool: display-only arguments the model writes that do not
- * change what the tool does. `sandbox_bash`'s `description` became required in UI refresh B, so a
- * recording without it and a replayed call with one (or a different wording) still match.
- */
-const MATCH_IGNORED_FIELDS = {
-    sandbox_bash: ["description"],
-};
 /** The matching key of a call: the canonical JSON of its input without the ignored fields. */
 export function matchKey(toolKey, input) {
     const ignored = MATCH_IGNORED_FIELDS[toolKey];
@@ -64,6 +129,7 @@ export function recordedCalls(s) {
                 started.set(p.callId, p.specHash);
         }
     }
+    const scope = legacyScopeOf(s);
     const out = [];
     for (const e of own) {
         if (e.type !== "assistant_message")
@@ -76,9 +142,11 @@ export function recordedCalls(s) {
             const r = results.get(call.id);
             if (!r)
                 continue;
+            const cur = currentCall(call.name, call.input, scope);
             out.push({
-                toolKey: call.name,
-                inputKey: matchKey(call.name, call.input),
+                toolKey: cur.name,
+                inputKey: matchKey(cur.name, cur.input),
+                ...(cur.legacy && { legacy: true }),
                 content: r.content,
                 isError: r.isError,
                 ...(r.loadedTools !== undefined && { loadedTools: r.loadedTools }),
@@ -98,9 +166,14 @@ export class RecordedToolPipeline {
     d;
     used = new Set();
     misses = 0;
+    legacyHits = 0;
     constructor(d) {
         this.d = d;
     }
+    /** Calls so far matched with a recording made under release-candidate tool names. */
+    legacyMatches() {
+        return this.legacyHits;
+    }
     /** 至今没有匹配到记录的调用数。 */
     unmatched() {
         return this.misses;
@@ -162,6 +235,8 @@ export class RecordedToolPipeline {
         if (i < 0)
             return undefined;
         this.used.add(i);
+        if (this.d.recordings[i]?.legacy === true)
+            this.legacyHits++;
         return this.d.recordings[i];
     }
 }

package/dist/evals/run-replay.d.ts

@@ -37,6 +37,11 @@ export interface RunReplayResult {
     usage: ModelUsage;
     steps: number;
     unmatched: number;
+    /**
+     * Set when a call was matched with a recording made under the release-candidate tool names
+     * (`sandbox_edit` for `Edit`, `docs__search` for `mcp__docs__search`, old parameter names).
+     */
+    legacyKeyMatch?: true;
 }
 /** 原运行（基线）的同形摘要。 */
 export type RunBaseline = Omit<RunReplayResult, "conversationId" | "outcome" | "unmatched">;

package/dist/evals/run-replay.js

@@ -22,7 +22,7 @@ import { RunError } from "../runtime/model-call.js";
 import { recordedSkillForks } from "../runtime/subagents/skill-fork.js";
 import { skillsCatalogIdemKey } from "../skills/catalog.js";
 import { ACTIVE_EVAL_STATUSES, addUsage, consumeTokens, TOO_MANY_ERRORS, usageTokens, } from "./budget.js";
-import { RecordedToolPipeline, recordedCalls } from "./recorded-tools.js";
+import { currentCall, legacyScopeOf, RecordedToolPipeline, recordedCalls, } from "./recorded-tools.js";
 /** 写种子时发现已失去认领或运行已不在执行：本次执行停下，不留评测对话。 */
 export class ReplayClaimLost extends Error {
     constructor() {
@@ -177,7 +177,7 @@ const ZERO = {
     cacheWriteTokens: 0,
 };
 /** 一次运行的工具调用序列、最后的回复、停止原因、用量与步数（基线与候选同一算法）。 */
-function summarize(events, runId) {
+function summarize(events, runId, scope) {
     const toolCalls = [];
     let usage = ZERO;
     let last = null;
@@ -189,8 +189,14 @@ function summarize(events, runId) {
             const p = e.payload;
             steps.add(p.step);
             for (const b of p.content) {
-                if (b.type === "tool_call")
+                if (b.type !== "tool_call")
+                    continue;
+                if (scope === undefined)
                     toolCalls.push({ name: b.name, input: b.input });
+                else {
+                    const { name, input } = currentCall(b.name, b.input, scope);
+                    toolCalls.push({ name, input });
+                }
             }
             last = { content: p.content, stopReason: p.stopReason };
         }
@@ -214,7 +220,9 @@ function summarize(events, runId) {
 }
 /** 原运行（快照）的摘要，作为整轮回放的基线。 */
 export function runBaseline(s) {
-    return summarize(s.events, s.runId);
+    // an rc recording is read in the current tool names, so the diff against a candidate only
+    // shows real differences
+    return summarize(s.events, s.runId, legacyScopeOf(s));
 }
 /**
  * 删掉一个评测对话（崩溃重跑前清掉上一次的残留）：先删它各次运行的 checkpoint，再删对话（事件、运行随之级联删除）。
@@ -558,5 +566,11 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     });
     await Promise.allSettled([...charges]);
     const summary = summarize(await readAll(eventLog, conversationId), runId);
-    return { conversationId, outcome: outcome.kind, ...summary, unmatched: pipeline.unmatched() };
+    return {
+        conversationId,
+        outcome: outcome.kind,
+        ...summary,
+        unmatched: pipeline.unmatched(),
+        ...(pipeline.legacyMatches() > 0 && { legacyKeyMatch: true }),
+    };
 }

package/dist/evals/trajectory.d.ts

@@ -54,7 +54,7 @@ export interface TrajectoryToolCall {
         byAccountId: string | null;
         decidedAt: string | null;
     } | null;
-    /** 最近一次输入请求（`ask_user`、插件 `input_required`、MCP elicitation）。 */
+    /** 最近一次输入请求（`AskUserQuestion`、插件 `input_required`、MCP elicitation）。 */
     question: {
         questionId: string;
         askedAt: string;
@@ -64,7 +64,7 @@ export interface TrajectoryToolCall {
     /** A `tool.preExecute` policy hook denied the call (it never started). */
     hookDenied?: TrajectoryHookDenial;
     /**
-     * An `agent` call that dispatched (or resumed) a sub-agent (phase C, spec §15.4): the child
+     * An `Agent` call that dispatched (or resumed) a sub-agent (phase C, spec §15.4): the child
      * conversation (`subagentId`, whose trajectory the viewer links to), the run it started and that
      * run's end (`running` until its `subagent_finished`).
      */

package/dist/identity/settings.js

@@ -68,7 +68,7 @@ export const DEPLOYMENT_SETTINGS = z.object({
     /** 组织能否自建连接器（不经企业目录）。 */
     customConnectors: CustomPolicy.default("allow"),
     /**
-     * 组织能否自建技能（不经企业目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`skill_write`，私有 agent 的
+     * 组织能否自建技能（不经企业目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`SkillWrite`，私有 agent 的
      * agent 级技能与共享 agent 经负责人审批的变更）不受此开关约束——那是 agent 定义的一部分，由 R3 / R4 把关。
      */
     customSkills: CustomPolicy.default("allow"),

package/dist/lifecycle/kernel-lifecycle.js

@@ -36,6 +36,7 @@ import { GatewayRole } from "../roles/gateway-role.js";
 import { WorkerRole } from "../roles/worker-role.js";
 import { UsageReporter } from "../runtime/usage-report.js";
 import { sandboxConfigWarnings } from "../sandbox/sandbox.service.js";
+import { warnLegacyToolKeys } from "../tools/legacy-data.js";
 import { KERNEL_APP_OPTIONS } from "./tokens.js";
 /**
  * The stop phase budgets. Each phase waits `min(its budget, what is left of the total)`, where the
@@ -193,6 +194,10 @@ let KernelLifecycle = class KernelLifecycle {
         // In flight for the stop: aborted when the shutdown begins, which then waits for its session to end
         await this.shutdown.trackInFlight(migrate(config.db.url, { schema: KERNEL_SCHEMA, dir: KERNEL_MIGRATIONS_DIR }, { connectTimeoutMs: config.db.connectTimeoutMs, signal: this.shutdown.signal }));
         this.checkpoint();
+        // Rows still holding a release-candidate tool key that migration 0063 could not map: one
+        // read-only count, a WARN when there are any (tool naming spec §8.2); never blocks the start
+        await warnLegacyToolKeys(this.kdb.db, this.log).catch((e) => this.log.warn("tools.legacy_key_count_failed", { error: errMsg(e) }));
+        this.checkpoint();
         // official 清单来源按配置同步（幂等；每个副本启动时都做）
         await this.marketplaces.syncOfficialFromConfig();
         // The bootstrap plugins (spec §7), once per manifest across replicas (the Redis lock

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

@@ -8,10 +8,10 @@ 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` 外都需要审批（执行时实时读取）。
  * - `sandboxEgress`：组织的沙箱出站（Ruling M19 / D6），缺省跟随部署的 `sandbox.limits.egress` + `allowHosts`。
  *   见 {@link effectiveSandboxEgress}。存量值非法时按 `none` 读（宁可断网，不悄悄放宽到部署默认）。
  */

package/dist/orgs/settings.service.js

@@ -21,10 +21,10 @@ 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` 外都需要审批（执行时实时读取）。
  * - `sandboxEgress`：组织的沙箱出站（Ruling M19 / D6），缺省跟随部署的 `sandbox.limits.egress` + `allowHosts`。
  *   见 {@link effectiveSandboxEgress}。存量值非法时按 `none` 读（宁可断网，不悄悄放宽到部署默认）。
  */

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

@@ -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;
@@ -75,8 +75,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,7 +224,7 @@ 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 里的
  *   不同，紧随摘要补一条完整的当前目录；
@@ -245,7 +245,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[];