@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.10

package/dist/evals/evals.module.js

@@ -0,0 +1,114 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EvalWorkersModule_1;
+import { hostname } from "node:os";
+import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { EventLogModule } from "../conversations/event-log.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { configuredProcessor } from "../infra/queue/configured-processor.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { runJob } from "../infra/queue/run-job.js";
+import { ModelsModule } from "../models/models.module.js";
+import { OrgLockModule } from "../orgs/org-lock.js";
+import { ProvidersModule } from "../runtime/providers.js";
+import { RuntimeModule } from "../runtime/runtime.module.js";
+import { EvalBudgetModule } from "./budget.js";
+import { EVAL_QUEUE_NAME, EvalJobs } from "./jobs.js";
+import { EvalReplaySeeder } from "./run-replay.js";
+import { EvalRunsService } from "./runs.service.js";
+import { EvalSetsService } from "./sets.service.js";
+import { TrajectoryService } from "./trajectory.service.js";
+import { EVAL_MAX_STALLED_COUNT, EvalWorker } from "./worker.js";
+/**
+ * Evals: the trajectory viewer, eval sets and cases, eval runs (the producer of
+ * `cap-kernel-evals`) and the run bookkeeping ({@link EvalBudgetModule}, re-exported).
+ */
+let EvalsModule = class EvalsModule {
+};
+EvalsModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            ModelsModule,
+            IdentityModule,
+            OrgLockModule,
+            ProvidersModule,
+            EvalBudgetModule,
+            QueueModule.registerQueue(EVAL_QUEUE_NAME),
+        ],
+        providers: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs],
+        exports: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs, EvalBudgetModule],
+    })
+], EvalsModule);
+export { EvalsModule };
+/** The consumer of `cap-kernel-evals` (one case per job): {@link EvalWorker}. */
+let EvalsProcessor = class EvalsProcessor extends WorkerHost {
+    evals;
+    constructor(evals) {
+        super();
+        this.evals = evals;
+    }
+    process(job, token) {
+        return runJob(EVAL_QUEUE_NAME, job, () => this.evals.process(job, token));
+    }
+    failed(job, err) {
+        this.evals.onFailed(job, err);
+    }
+    error(err) {
+        this.evals.onError(err);
+    }
+};
+__decorate([
+    OnWorkerEvent("failed")
+], EvalsProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], EvalsProcessor.prototype, "error", null);
+EvalsProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(EvalWorker))
+], EvalsProcessor);
+export { EvalsProcessor };
+/**
+ * The eval worker (step and full-run replays, the judge) over the runtime's loop and model
+ * registry, and the consumer of `cap-kernel-evals`, its options from the startup config
+ * (concurrency `evals.workerConcurrency`, the run queues' job lock and stalled detection). Imported
+ * only by the worker role (`WorkerModule`), so other roles get no processor and no BullMQ worker.
+ * The worker never starts by itself: the worker role (`WorkerRole`) starts it after the extensions
+ * loaded, and drains it on stop.
+ */
+let EvalWorkersModule = EvalWorkersModule_1 = class EvalWorkersModule {
+    static forRoot(config) {
+        const { jobLockMs, stalledIntervalMs } = config.runtime;
+        return {
+            module: EvalWorkersModule_1,
+            imports: [EvalsModule, RuntimeModule, EventLogModule, ModelsModule],
+            providers: [
+                EvalReplaySeeder,
+                EvalWorker,
+                configuredProcessor(EvalsProcessor, EVAL_QUEUE_NAME, {
+                    // the worker name is recorded on the job (BullMQ processedBy): which replica ran it
+                    name: `${hostname()}-${process.pid}`,
+                    concurrency: config.evals.workerConcurrency,
+                    lockDuration: jobLockMs,
+                    stalledInterval: stalledIntervalMs,
+                    maxStalledCount: EVAL_MAX_STALLED_COUNT,
+                }),
+            ],
+            exports: [EvalWorker, EvalsProcessor],
+        };
+    }
+};
+EvalWorkersModule = EvalWorkersModule_1 = __decorate([
+    Module({})
+    // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
+], EvalWorkersModule);
+export { EvalWorkersModule };

package/dist/evals/evals.schemas.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+export declare const EvalSetCreateBody: z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    rubric: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalSetPatchBody: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    rubric: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const EvalAddCaseBody: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strict>;
+export declare const EvalSampleBody: z.ZodObject<{
+    from: z.ZodOptional<z.ZodISODateTime>;
+    to: z.ZodOptional<z.ZodISODateTime>;
+    count: z.ZodNumber;
+    status: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        completed: "completed";
+        failed: "failed";
+    }>>;
+    minToolCalls: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const EvalCandidateSchema: z.ZodObject<{
+    agentVersion: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** `tokenCap` is only type-checked here; the service judges the range (`eval.token_cap_invalid`). */
+export declare const EvalRunEstimateBody: z.ZodObject<{
+    mode: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    candidate: z.ZodObject<{
+        agentVersion: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    judge: z.ZodDefault<z.ZodBoolean>;
+    tokenCap: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const EvalRunStartBody: z.ZodObject<{
+    mode: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    candidate: z.ZodObject<{
+        agentVersion: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    judge: z.ZodDefault<z.ZodBoolean>;
+    tokenCap: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * `view=light`: no content blocks (result tables and polling; the response carries `asOf`);
+ * default `full`. `updatedSince` (ISO time) takes only what changed after it.
+ */
+export declare const EvalRunResultsQuery: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    view: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        light: "light";
+    }>>;
+    updatedSince: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalLabelBody: z.ZodObject<{
+    label: z.ZodNullable<z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+    }>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvalSetParams: z.ZodObject<{
+    setId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalCaseParams: z.ZodObject<{
+    setId: z.ZodString;
+    caseId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalRunParams: z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalResultParams: z.ZodObject<{
+    runId: z.ZodString;
+    resultId: z.ZodString;
+}, z.core.$strip>;
+export declare const EvalLabelParams: z.ZodObject<{
+    resultId: z.ZodString;
+}, z.core.$strip>;
+export declare const EVAL_ROUTES: readonly RouteSchemas[];

package/dist/evals/evals.schemas.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { ModelRef } from "../agents/definition.js";
+const NAME = z.string().trim().min(1).max(200);
+const DESCRIPTION = z.string().max(2000);
+const RUBRIC = z.string().min(1).max(20_000);
+export const EvalSetCreateBody = z
+    .object({
+    agentId: z.string().min(1).max(100),
+    name: NAME,
+    description: DESCRIPTION.optional(),
+    rubric: RUBRIC.optional(),
+})
+    .strict();
+export const EvalSetPatchBody = z
+    .object({
+    name: NAME.optional(),
+    description: DESCRIPTION.optional(),
+    rubric: RUBRIC.nullable().optional(),
+})
+    .strict();
+export const EvalAddCaseBody = z
+    .object({ conversationId: z.string().min(1).max(100), runId: z.string().min(1).max(100) })
+    .strict();
+export const EvalSampleBody = z
+    .object({
+    from: z.iso.datetime({ offset: true }).optional(),
+    to: z.iso.datetime({ offset: true }).optional(),
+    count: z.number().int().min(1).max(50),
+    status: z.enum(["completed", "failed", "any"]).optional(),
+    minToolCalls: z.number().int().min(0).max(1000).optional(),
+})
+    .strict();
+export const EvalCandidateSchema = z
+    .object({
+    agentVersion: z.number().int().min(1).optional(),
+    model: ModelRef.strict().optional(),
+    modelParams: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+    instructions: z.string().max(100_000).optional(),
+})
+    .strict();
+/** `tokenCap` is only type-checked here; the service judges the range (`eval.token_cap_invalid`). */
+export const EvalRunEstimateBody = z
+    .object({
+    mode: z.enum(["step", "run"]),
+    candidate: EvalCandidateSchema,
+    judge: z.boolean().default(false),
+    tokenCap: z.number().int().optional(),
+})
+    .strict();
+export const EvalRunStartBody = EvalRunEstimateBody;
+/**
+ * `view=light`: no content blocks (result tables and polling; the response carries `asOf`);
+ * default `full`. `updatedSince` (ISO time) takes only what changed after it.
+ */
+export const EvalRunResultsQuery = z
+    .object({
+    after: z.string().max(100).optional(),
+    limit: z.coerce.number().int().min(1).max(200).default(50),
+    view: z.enum(["full", "light"]).default("full"),
+    updatedSince: z
+        .string()
+        .max(64)
+        .refine((v) => !Number.isNaN(Date.parse(v)), { message: "must be an ISO timestamp" })
+        .optional(),
+})
+    .strict();
+export const EvalLabelBody = z
+    .object({
+    label: z.enum(["pass", "fail"]).nullable(),
+    note: z.string().max(2000).optional(),
+})
+    .strict();
+/** The path params the eval routes read (`@Param`), bounded as the operations take them. */
+const Id = z.string().min(1).max(100);
+export const EvalSetParams = z.object({ setId: Id });
+export const EvalCaseParams = z.object({ setId: Id, caseId: Id });
+export const EvalRunParams = z.object({ runId: Id });
+export const EvalResultParams = z.object({ runId: Id, resultId: Id });
+export const EvalLabelParams = z.object({ resultId: Id });
+const O = "/api/v1/orgs/:orgId";
+export const EVAL_ROUTES = [
+    { route: `POST ${O}/eval-sets`, body: EvalSetCreateBody },
+    { route: `GET ${O}/eval-sets` },
+    { route: `GET ${O}/eval-sets/:setId`, params: EvalSetParams },
+    { route: `PATCH ${O}/eval-sets/:setId`, params: EvalSetParams, body: EvalSetPatchBody },
+    { route: `DELETE ${O}/eval-sets/:setId`, params: EvalSetParams },
+    { route: `POST ${O}/eval-sets/:setId/cases`, params: EvalSetParams, body: EvalAddCaseBody },
+    {
+        route: `POST ${O}/eval-sets/:setId/cases/sample`,
+        params: EvalSetParams,
+        body: EvalSampleBody,
+    },
+    { route: `GET ${O}/eval-sets/:setId/cases/:caseId`, params: EvalCaseParams },
+    { route: `DELETE ${O}/eval-sets/:setId/cases/:caseId`, params: EvalCaseParams },
+    {
+        route: `POST ${O}/eval-sets/:setId/runs/estimate`,
+        params: EvalSetParams,
+        body: EvalRunEstimateBody,
+    },
+    { route: `POST ${O}/eval-sets/:setId/runs`, params: EvalSetParams, body: EvalRunStartBody },
+    { route: `GET ${O}/eval-sets/:setId/runs`, params: EvalSetParams },
+    { route: `GET ${O}/eval-runs/:runId`, params: EvalRunParams },
+    { route: `GET ${O}/eval-runs/:runId/results`, params: EvalRunParams, query: EvalRunResultsQuery },
+    { route: `GET ${O}/eval-runs/:runId/results/:resultId`, params: EvalResultParams },
+    { route: `POST ${O}/eval-runs/:runId/cancel`, params: EvalRunParams },
+    { route: `PUT ${O}/eval-results/:resultId/label`, params: EvalLabelParams, body: EvalLabelBody },
+];

package/dist/evals/jobs.d.ts

@@ -0,0 +1,20 @@
+import type { Queue } from "bullmq";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export declare const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export declare const evalJobId: (runId: string, caseId: string) => string;
+/** 评测任务的数据。 */
+export interface EvalJobData {
+    runId: string;
+    caseId: string;
+    orgId: string;
+}
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+export declare class EvalJobs {
+    private readonly queue;
+    constructor(queue: Pick<Queue, "addBulk">);
+    enqueue(jobs: EvalJobData[]): Promise<void>;
+}

package/dist/evals/jobs.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { getQueueToken } from "@nestjs/bullmq";
+import { Inject, Injectable } from "@nestjs/common";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export const evalJobId = (runId, caseId) => `eval-${runId}-${caseId}`;
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+let EvalJobs = class EvalJobs {
+    queue;
+    constructor(queue) {
+        this.queue = queue;
+    }
+    async enqueue(jobs) {
+        await this.queue.addBulk(jobs.map((data) => ({
+            name: "case",
+            data,
+            opts: {
+                jobId: evalJobId(data.runId, data.caseId),
+                // 处理函数外的暂时故障（PG / Redis）：指数退避重试，不让整个用例一次失败。
+                // 结果按认领号写入，重做不会重复写结果
+                attempts: 3,
+                backoff: { type: "exponential", delay: 1000 },
+                removeOnComplete: true,
+                removeOnFail: 1000,
+            },
+        })));
+    }
+};
+EvalJobs = __decorate([
+    Injectable(),
+    __param(0, Inject(getQueueToken(EVAL_QUEUE_NAME)))
+], EvalJobs);
+export { EvalJobs };

package/dist/evals/reconstruct.d.ts

@@ -63,10 +63,7 @@ export interface ReconstructOptions {
      * eval worker reads the current one). Another version than the logged one is a candidate change
      * (`subagent_changed`).
      */
-    subagentTemplate?: {
-        id: string;
-        version: number;
-    };
+    subagentTemplate?: SubagentTemplateRef;
     /**
      * A child case under another agent version (`agentVersion` differs): that version's own
      * definition, compared with the logged sub-agent for `subagent_changed` (the candidate
@@ -87,6 +84,16 @@ export declare function reconstructRequest(s: CaseSnapshot, modelCallSeq: number
 type SubagentStarted = EventPayload<"subagent_started">;
 /** The `subagent_started` of a sub-agent's (child) log, or undefined for any other conversation. */
 export declare function subagentStartedOf(events: readonly ConversationEvent[]): SubagentStarted | undefined;
+/**
+ * A plugin template child's template as a new dispatch would use it: the selected id, the version
+ * and the platform template whose content it is (absent: the org's own template; plugin scope
+ * phase 2, a linked copy shares its id with both sources, whose version numbers may collide).
+ */
+export interface SubagentTemplateRef {
+    id: string;
+    version: number;
+    platformTemplateId?: string;
+}
 /**
  * Does a candidate change what a sub-agent (child) case would run (`subagent_changed`, spec
  * §15.1)? Pure, from the snapshot alone, comparing the model-visible parts of the effective
@@ -101,7 +108,12 @@ export declare function subagentStartedOf(events: readonly ConversationEvent[]):
  *   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 declare function subagentChanged(started: SubagentStarted, logged: AgentDefinition, candidate: AgentDefinition, sameVersion: boolean, 
 /** The parent's definition at the case's version (the snapshot's), for template children. */
@@ -115,10 +127,7 @@ export declare function subagentCaseChanged(s: CaseSnapshot, c: {
     changed: boolean;
     definition: AgentDefinition;
     agentVersion: number;
-    subagentTemplate?: {
-        id: string;
-        version: number;
-    };
+    subagentTemplate?: SubagentTemplateRef;
     subagentVersion?: AgentDefinition;
 }): boolean;
 /** 还原该请求要查的附件 id（该模型用得到的引用，去重、按出现顺序；见 `mediaRefs`）。 */

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 `environment_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.
+     */
+    environmentPaths?: 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<{