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

package/dist/evals/reconstruct.js

@@ -1,11 +1,12 @@
 import { sanitizeParams, } from "@capybara-hq/plugin-sdk";
-import { AgentDefinitionSchema, normalizeStoredDefinition, } from "../agents/definition.js";
+import { AgentDefinitionSchema, builtinDisabled, canonicalDisabledTools, normalizeStoredDefinition, } from "../agents/definition.js";
 import { sameModel, selectionAt } from "../conversations/selection.js";
 import { ApiError } from "../errors.js";
 import { mediaRefs, planMedia, } from "../runtime/context/build.js";
 import { assembleModelRequest } from "../runtime/model-call.js";
 import { CHILD_REMOVED_TOOLS } from "../runtime/subagents/definition.js";
 import { PINNED_SKILLS_LIMITS } from "../skills/catalog.js";
+import { AGENT_TOOL } from "../tools/builtin-names.js";
 import { canonicalJson } from "./recorded-tools.js";
 import { toEvents } from "./snapshot.js";
 const DRIFT_ORDER = [
@@ -210,13 +211,31 @@ export function subagentStartedOf(events) {
     const e = events.find((x) => x.type === "subagent_started");
     return e?.type === "subagent_started" ? e.payload : undefined;
 }
-const sameTemplate = (logged, t) => logged.source !== "plugin" || (logged.id === t.id && logged.version === t.version);
+const sameTemplate = (logged, t) => logged.source !== "plugin" ||
+    (logged.id === t.id &&
+        logged.version === t.version &&
+        (logged.platformTemplateId ?? null) === (t.platformTemplateId ?? null));
 const pinsOf = (d) => [...new Set(d.skills?.pinned ?? [])].slice(0, PINNED_SKILLS_LIMITS.count);
-/** Tool refs as a sub-agent gets them without template narrowing (general and org agents). */
-const childToolsOf = (d) => canonicalJson(d.tools.filter((t) => t.kind !== "builtin" || !CHILD_REMOVED_TOOLS.includes(t.name)));
+/**
+ * A sub-agent's tools without template narrowing (general and org agents), as compared: its
+ * turned-off tools (tools default-on spec §4) and its key filter's allowlist and `deny` keys,
+ * {@link CHILD_REMOVED_TOOLS} left out. `Agent` depends on the child's depth, not on the
+ * definition (agent map spec §4.1): a `deny` of it never counts, and a turned-off `Agent` counts
+ * only when the logged child had it (`keepAgent`), so a child logged without it (at the depth
+ * limit, or before nesting) compares equal to a candidate that offers it.
+ */
+const childToolsOf = (d, keepAgent) => canonicalJson({
+    disabled: canonicalDisabledTools((d.disabledTools ?? []).filter((r) => keepAgent || r.kind !== "builtin" || r.name !== AGENT_TOOL)),
+    allow: d.subagentTools?.allow ?? null,
+    deny: (d.subagentTools?.deny ?? []).filter((k) => !CHILD_REMOVED_TOOLS.includes(k) && k !== AGENT_TOOL),
+});
+/** Does the child have `Agent` by its definition (not turned off, not removed by its filter)? */
+const hasAgent = (d) => !builtinDisabled(d.disabledTools, AGENT_TOOL) &&
+    !(d.subagentTools?.deny ?? []).includes(AGENT_TOOL) &&
+    (d.subagentTools?.allow === undefined || d.subagentTools.allow.includes(AGENT_TOOL));
 /** The parent's selection a template child depends on: its tools, org skills and roster entry. */
 const parentSide = (d, started) => canonicalJson({
-    tools: d.tools,
+    disabledTools: canonicalDisabledTools(d.disabledTools ?? []),
     orgSkills: d.skills?.orgSkills ?? [],
     listed: started.template.source === "general"
         ? d.subagents?.general !== false
@@ -236,22 +255,29 @@ const parentSide = (d, started) => canonicalJson({
  *   parent version (its own version is {@link ReconstructOptions.subagentTemplate}). Template
  *   narrowing that needs the database (inline and plugin tool allowlists, skill names) is not
  *   recomputed: those compare instructions only.
- * Models and params are not part of it: they are candidate axes of their own.
+ * Models and params are not part of it: they are candidate axes of their own. Neither is the
+ * candidate's `subagents` block as the child's own roster (allowlist, templates, limits; only a
+ * template child's entry in its parent's roster counts, `parentSide`) nor whether it offers `Agent`:
+ * whether a child has `Agent` follows its depth (`keepAgent` comes only from the logged child), and
+ * what a nesting child dispatches is recorded as its `Agent` results, which replay reuses (agent
+ * map spec §4.1, §8). A roster-only candidate therefore reports no `subagent_changed`.
  */
 export function subagentChanged(started, logged, candidate, sameVersion, 
 /** The parent's definition at the case's version (the snapshot's), for template children. */
 original) {
+    const keepAgent = hasAgent(logged);
+    const childTools = (d) => childToolsOf(d, keepAgent);
     const differs = (instructions, pinned, tools) => instructions !== logged.instructions ||
         (pinned !== null && canonicalJson(pinned) !== canonicalJson(pinsOf(logged))) ||
-        (tools !== null && tools !== childToolsOf(logged));
+        (tools !== null && tools !== childTools(logged));
     if (sameVersion) {
-        return differs(candidate.instructions, pinsOf(candidate), canonicalJson(candidate.tools));
+        return differs(candidate.instructions, pinsOf(candidate), childTools(candidate));
     }
     switch (started.template.source) {
         case "agent":
-            return differs(candidate.instructions, pinsOf(candidate), childToolsOf(candidate));
+            return differs(candidate.instructions, pinsOf(candidate), childTools(candidate));
         case "general":
-            return (differs(candidate.instructions, [], childToolsOf(candidate)) ||
+            return (differs(candidate.instructions, [], childTools(candidate)) ||
                 (original !== undefined && parentSide(original, started) !== parentSide(candidate, started)));
         case "inline": {
             const t = candidate.subagents?.inline?.find((x) => x.name === started.agentType);

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

@@ -1,4 +1,6 @@
+import type { SandboxRoots } from "@capybara-hq/plugin-sdk";
 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 +17,43 @@ 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 roots of the latest `device_paths` event the original run had logged by this call's
+     * step (environments spec §13.1, ruling R22): set on every recorded call from the step where an
+     * event was logged onward. A replay that matches the call writes the event when the eval
+     * conversation's latest one differs, so a candidate whose first sandbox call lands in another
+     * step still gets the line, once.
+     */
+    devicePaths?: SandboxRoots;
 }
+/**
+ * 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 rc-era 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 +76,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,7 @@
+import { devicePathsChange } from "../runtime/context/device-paths.js";
 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 +10,85 @@ 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 rc-era 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();
+    // rc-era snapshots hold definitions from before tools were on by default: an enabled `tools`
+    // list of refs (tools default-on spec §2)
+    for (const def of Object.values(s.definitions)) {
+        const refs = def.tools;
+        if (!Array.isArray(refs))
+            continue;
+        for (const t of refs) {
+            if (t?.kind === "plugin" && typeof t.plugin === "string" && typeof t.name === "string") {
+                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 +105,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,10 +138,29 @@ export function recordedCalls(s) {
                 started.set(p.callId, p.specHash);
         }
     }
+    // a device_paths event belongs to the step of the assistant message before it, and holds
+    // for that step's calls and every later step's (until the next one)
+    const pathsOf = new Map();
+    const assistants = own.filter((e) => e.type === "assistant_message").map((e) => e.seq);
+    let current;
+    let next = 0;
+    for (const [i, a] of assistants.entries()) {
+        const end = assistants[i + 1] ?? Number.POSITIVE_INFINITY;
+        for (; next < own.length && own[next].seq < end; next++) {
+            const e = own[next];
+            if (e.type === "device_paths" && e.seq > a) {
+                current = e.payload.roots;
+            }
+        }
+        if (current !== undefined)
+            pathsOf.set(a, current);
+    }
+    const scope = legacyScopeOf(s);
     const out = [];
     for (const e of own) {
         if (e.type !== "assistant_message")
             continue;
+        const paths = pathsOf.get(e.seq);
         const content = e.payload.content;
         for (const b of content) {
             if (b.type !== "tool_call")
@@ -76,14 +169,17 @@ 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 }),
                 ...(r.contentTypes !== undefined && { contentTypes: r.contentTypes }),
                 specHash: started.get(call.id) ?? "",
+                ...(paths !== undefined && { devicePaths: paths }),
             });
         }
     }
@@ -98,9 +194,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;
@@ -132,7 +233,14 @@ export class RecordedToolPipeline {
             const rec = this.take(call.name, matchKey(call.name, call.input));
             if (!rec)
                 this.misses++;
+            // the original run had told the model the instance's directories by this call: so does the
+            // replay, when the eval conversation's latest record differs (as the sandbox tools write it)
+            const paths = rec?.devicePaths;
+            const change = paths === undefined
+                ? null
+                : devicePathsChange(await eventLog.latestOfType(ctx.conversationId, "device_paths"), paths, ctx.runId);
             await eventLog.append(ctx.conversationId, [
+                ...(change ? [change] : []),
                 {
                     type: "tool_call_started",
                     runId: ctx.runId,
@@ -162,6 +270,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

@@ -18,8 +18,13 @@ import type { ResolvedCandidate } from "./step-replay.js";
  * {@link RecordedToolPipeline}（只回放记录的结果，不执行任何工具、沙箱、连接器或审批）。
  *
  * - 种子：原运行 `run_started` 之前的事件按原 seq 插入（`last_seq` 停在其前一位，新的 `run_started` 因此与原来同 seq），
- *   原运行开始时的 `skills_catalog` 照抄；然后写 `runs` 行与 `run_started`，`agent` 用候选定义。
- * - 插话：原运行中途吸收的 user_message，在「原吸收步骤 ≤ 当前步骤」时追加进评测对话并交给 loop。
+ *   原运行开始时的 `skills_catalog` 与 `run_context` 照抄；然后写 `runs` 行与 `run_started`，`agent` 用候选定义。
+ * - 插话：原运行中途吸收的可吸收事件（user_message, and finished background tasks: background Bash
+ *   spec §4.4），在「原吸收步骤 ≤ 当前步骤」时追加进评测对话并交给 loop（a recorded finish is
+ *   appended as recorded: no task starts, polls or stops; likewise a sub-agent's delivery, agent map
+ *   spec §8: no child is dispatched, sent to or woken）。
+ * - A wake run (its boundary a finished background task or a sub-agent's delivery, not a message)
+ *   is seeded from that event.
  * - 计费（C7，与单步回放同一套）：每次模型请求（含压缩、重试、兜底）发出前查运行仍在执行、仍持有认领；
  *   收完按真实用量、没收完按估算 `consumeTokens`（越限即 `capped`，下一次请求前停下）。
  * - 附件按快照自己的组织与原对话取（C3）。
@@ -37,6 +42,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">;
@@ -96,7 +106,7 @@ export interface ReplaySeed {
     /** The conversation's `consumed_seq` when the original run started. */
     consumed: number;
     seeds: SnapshotEvent[];
-    /** The run's trigger seq (the last user message before it). */
+    /** The run's trigger seq (its boundary: the last unconsumed message, or the waking finish). */
     trigger: number;
     agentVersion: number;
     model: ModelRef;
@@ -104,6 +114,13 @@ export interface ReplaySeed {
     catalog: {
         payload: unknown;
     } | undefined;
+    /**
+     * The original run's `run_context` event (run context spec §8), copied as is: a candidate sees
+     * the original date, names and org, never the eval day's.
+     */
+    runContext: {
+        payload: unknown;
+    } | undefined;
 }
 /**
  * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the

package/dist/evals/run-replay.js

@@ -13,16 +13,18 @@ import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { normalizeStoredDefinition } from "../agents/definition.js";
 import { EventLog } from "../conversations/event-log.js";
+import { isAbsorbable, } from "../conversations/events.js";
 import { ApiError } from "../errors.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { RunError } from "../runtime/model-call.js";
+import { runContextIdemKey } from "../runtime/run-context.service.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() {
@@ -120,6 +122,16 @@ let EvalReplaySeeder = class EvalReplaySeeder {
                     },
                 ]
                 : []),
+            ...(p.runContext
+                ? [
+                    {
+                        type: "run_context",
+                        runId,
+                        idemKey: runContextIdemKey(runId),
+                        payload: p.runContext.payload,
+                    },
+                ]
+                : []),
         ]);
         if (onSeeded && !(await onSeeded(conversationId)))
             throw new ReplayClaimLost();
@@ -177,7 +189,7 @@ const ZERO = {
     cacheWriteTokens: 0,
 };
 /** 一次运行的工具调用序列、最后的回复、停止原因、用量与步数（基线与候选同一算法）。 */
-function summarize(events, runId) {
+function summarize(events, runId, scope) {
     const toolCalls = [];
     let usage = ZERO;
     let last = null;
@@ -189,8 +201,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 +232,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，再删对话（事件、运行随之级联删除）。
@@ -252,6 +272,29 @@ function absorbedByStep(s) {
     }
     return out;
 }
+/**
+ * The replayed run's boundary (`trigger_seq`): a wake run's recorded one (`run_started.triggerSeq`,
+ * background Bash spec §3, agent map spec §5.3); otherwise the newest message after `consumed`, else the newest finish
+ * after it that could have woken the run (not reported, no `stoppedBy`), else the last
+ * message (old logs, as before).
+ */
+function replayTrigger(started, seeds, consumed) {
+    const recorded = started;
+    if ((recorded.trigger === "background_task" || recorded.trigger === "subagent") &&
+        recorded.triggerSeq !== undefined) {
+        return recorded.triggerSeq;
+    }
+    const lastMessage = seeds.findLast((e) => e.type === "user_message")?.seq;
+    if (lastMessage !== undefined && lastMessage > consumed)
+        return lastMessage;
+    const wake = seeds.findLast((e) => {
+        if (e.type !== "background_task_finished" || e.seq <= consumed)
+            return false;
+        const p = e.payload;
+        return !p.reported && p.stoppedBy === undefined;
+    })?.seq;
+    return wake ?? lastMessage ?? 0;
+}
 const readAll = async (eventLog, conversationId) => {
     const out = [];
     let after = 0;
@@ -286,8 +329,9 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             consumed = Math.max(consumed, e.payload.consumedUpToSeq);
         }
     }
-    const trigger = seeds.findLast((e) => e.type === "user_message")?.seq ?? 0;
+    const trigger = replayTrigger(start.payload, seeds, consumed);
     const catalog = s.events.find((e) => e.runId === s.runId && e.type === "skills_catalog" && e.seq > R);
+    const runContext = s.events.find((e) => e.runId === s.runId && e.type === "run_context" && e.seq > R);
     // a sub-agent's case (spec §15.3) runs the effective definition frozen in its subagent_started
     // (the request renders that event's preamble and instructions; its tools come from it too), with
     // only the candidate's model and params, and the logged step limit
@@ -299,6 +343,10 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             model: candidate.model,
             modelParams: candidate.params,
         };
+    const triggerEvent = s.events.find((e) => e.seq === trigger);
+    const forkRun = triggerEvent?.type === "user_message" &&
+        triggerEvent.payload.skill !== undefined &&
+        triggerEvent.payload.dispatch !== undefined;
     const conversationId = randomUUID();
     const runId = randomUUID();
     await d.seeder.seed({
@@ -315,6 +363,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         agentVersion: candidate.agentVersion,
         model: agent.model,
         catalog,
+        runContext,
     }, d.onSeeded);
     await d.hooks?.afterRunSeeded?.(evalRunId, conversationId);
     // 停止：取消 / 越限 / 熔断 / 失去认领 / 截止时间 → 中止 loop（进行中的请求立即停下，loop 以 aborted 返回）
@@ -399,8 +448,10 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         return metered;
     };
     const registry = {
-        resolve: async (ref) => {
-            const r = await d.registry.resolve(ref);
+        // the case's org (its effective provider config), whatever the replayed step passes
+        // (and its disabled lists: a candidate disabled there is refused, spec B §5.3)
+        resolve: async (_orgId, ref, opts) => {
+            const r = await d.registry.resolve(s.orgId, ref, opts);
             return { ...r, provider: meter(r.provider) };
         },
     };
@@ -419,7 +470,8 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             return "stop";
         },
     });
-    // 插话：原运行开始之后到达、且被原运行某一步吸收的 user_message
+    // 插话：原运行开始之后到达、且被原运行某一步吸收的可吸收事件（user_message /
+    // background_task_finished / subagent_delivery）
     const absorbed = absorbedByStep(s);
     const stepsInOrder = [...absorbed.keys()].sort((a, b) => a - b);
     /** 第 k 步（含）之前原运行吸收到的最大位置；原运行没有模型调用时不设限。 */
@@ -434,7 +486,10 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         return cap;
     };
     const interjections = s.events
-        .filter((e) => e.type === "user_message" && e.seq > R)
+        .filter((e) => (e.type === "user_message" ||
+        e.type === "background_task_finished" ||
+        e.type === "subagent_delivery") &&
+        e.seq > R)
         .flatMap((e) => {
         const step = stepsInOrder.find((k) => absorbed.get(k) >= e.seq);
         return step === undefined ? [] : [{ event: e, step }];
@@ -442,7 +497,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     /** 已追加的插话：原 seq → 评测对话里的 seq。 */
     const fed = new Map();
     let prepared = 0;
-    const pendingUserMessages = async (afterSeq) => {
+    const pendingAbsorbable = async (afterSeq) => {
         prepared++;
         // loop 的步骤从 1 起（与运行时相同），每步的 prepare 调用一次：第 n 次调用即第 n 步
         const k = prepared;
@@ -451,7 +506,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
                 continue;
             const [w] = await eventLog.append(conversationId, [
                 {
-                    type: "user_message",
+                    type: x.event.type,
                     idemKey: `replay_interjection:${runId}:${x.event.seq}`,
                     payload: x.event.payload,
                 },
@@ -463,7 +518,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         const fedSeqs = new Set(fed.values());
         const out = [];
         for (const e of await readAll(eventLog, conversationId)) {
-            if (e.type !== "user_message" || e.seq <= afterSeq)
+            if (!isAbsorbable(e) || e.seq <= afterSeq)
                 continue;
             if (fedSeqs.has(e.seq) || (e.seq < R && e.seq <= cap))
                 out.push(e);
@@ -494,13 +549,16 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             signal: loopSignal,
             shutdown: new AbortController().signal,
             sink: () => { },
-            pendingUserMessages,
+            pendingAbsorbable,
             limits: {
                 maxSteps: subagent === undefined ? runtime.maxSteps : Math.min(subagent.maxSteps, runtime.maxSteps),
                 deadline,
             },
             // replays never fire plugin hooks (the loop deps omit them too, P-18)
             conversationKind: "eval",
+            // a child case offers a sub-agent's message tools, as its recorded requests did (a fork
+            // invocation's child, whose run a task with the invocation record started, has none)
+            ...(subagent !== undefined && !forkRun && { subagent: true }),
         });
     }
     catch (e) {
@@ -558,5 +616,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 }),
+    };
 }