@springbrand/agent-runtime 0.2.0-alpha.34 → 0.2.0-alpha.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.2.0-alpha.34",
+  "version": "0.2.0-alpha.38",
   "type": "module",
   "files": [
     "src",
@@ -23,6 +23,8 @@
     "@cloudflare/think": "0.15.0",
     "@earendil-works/pi-agent-core": "0.83.0",
     "@earendil-works/pi-ai": "0.83.0",
+    "@types/lodash-es": "^4.17.12",
+    "cron-schedule": "6.0.0",
     "isomorphic-git": "1.38.6",
     "lodash-es": "^4.18.1",
     "zod": "^4.4.3"

package/src/adapter/cloudflare/dynamic-worker-observability.ts

@@ -0,0 +1,84 @@
+import type { RuntimePlatformPort } from "../../kernel/bindings";
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+export type DynamicWorkerObservation = {
+  source: string;
+  attributes?: Readonly<Record<string, string>>;
+};
+
+type TailProps = DynamicWorkerObservation & {
+  workerId: string;
+  mainModule: string;
+};
+
+type ExportContext = Pick<DurableObjectState, "exports">;
+
+function attachTail(
+  context: ExportContext,
+  code: WorkerLoaderWorkerCode,
+  observation: DynamicWorkerObservation,
+  workerId: string,
+): WorkerLoaderWorkerCode {
+  const entrypoint = (context.exports as unknown as {
+    DynamicWorkerTail(options: { props: TailProps }): Fetcher;
+  }).DynamicWorkerTail;
+  const tail = entrypoint({
+    props: { ...observation, workerId, mainModule: code.mainModule },
+  });
+  return { ...code, tails: [...(code.tails ?? []), tail] };
+}
+
+export function observeDynamicWorkers(
+  context: ExportContext,
+  loader: WorkerLoader,
+  observation: DynamicWorkerObservation,
+): WorkerLoader {
+  return {
+    load: (code) =>
+      loader.load(attachTail(context, code, observation, crypto.randomUUID())),
+    get: (name, getCode) => {
+      const workerId = name ?? crypto.randomUUID();
+      return loader.get(name, async () =>
+        attachTail(context, await getCode(), observation, workerId)
+      );
+    },
+  };
+}
+
+export function observeDynamicWorkerPlatform(
+  context: ExportContext,
+  load: () => Promise<RuntimePlatformPort>,
+  observation: DynamicWorkerObservation,
+): () => Promise<RuntimePlatformPort> {
+  return async () => {
+    const platform = await load();
+    return {
+      ...platform,
+      loader: observeDynamicWorkers(context, platform.loader, observation),
+    };
+  };
+}
+
+export class DynamicWorkerTail extends WorkerEntrypoint<Cloudflare.Env, TailProps> {
+  tail(events: TraceItem[]): void {
+    for (const event of events) {
+      console.log({
+        ...this.ctx.props.attributes,
+        source: "dynamic-worker-tail",
+        dynamicWorkerSource: this.ctx.props.source,
+        dynamicWorkerId: this.ctx.props.workerId,
+        durableObjectId: event.durableObjectId ?? null,
+        mainModule: this.ctx.props.mainModule,
+        eventTimestamp: event.eventTimestamp,
+        scriptName: event.scriptName,
+        entrypoint: event.entrypoint,
+        outcome: event.outcome,
+        truncated: event.truncated,
+        cpuTime: event.cpuTime,
+        wallTime: event.wallTime,
+        logs: event.logs,
+        exceptions: event.exceptions,
+      });
+    }
+  }
+}

package/src/adapter/cloudflare/index.ts

@@ -13,9 +13,18 @@ export {
 } from "./universal-agent/preparation";
 export {
   assembleUniversalAgentTools,
-  selectTools,
 } from "./universal-agent/tools";
-export { createUniversalAgentHooks } from "./universal-agent/hooks";
+export {
+  DynamicWorkerTail,
+  observeDynamicWorkerPlatform,
+  observeDynamicWorkers,
+  type DynamicWorkerObservation,
+} from "./dynamic-worker-observability";
+export {
+  isValidTimeZone,
+  nextCronOccurrence,
+  zoneOffsetMs,
+} from "./scheduling/zoned-cron";
 
 export {
   CloudflareSandboxAdapter,

package/src/adapter/cloudflare/scheduling/zoned-cron.ts

@@ -0,0 +1,114 @@
+import { parseCronExpression } from "cron-schedule";
+
+export function zoneOffsetMs(instant: number, timeZone: string): number {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).formatToParts(new Date(instant));
+  const field = (type: Intl.DateTimeFormatPartTypes) =>
+    Number(parts.find((part) => part.type === type)?.value ?? 0);
+  const wallAsUtc = Date.UTC(
+    field("year"),
+    field("month") - 1,
+    field("day"),
+    field("hour") % 24,
+    field("minute"),
+    field("second"),
+  );
+  return wallAsUtc - Math.floor(instant / 1_000) * 1_000;
+}
+
+export function nextCronOccurrence(
+  cron: string,
+  timeZone: string,
+  after = Date.now(),
+): number {
+  const parsed = parseCronExpression(cron);
+  const secondPrecision = parsed.seconds.length !== 1 || parsed.seconds[0] !== 0;
+  const step = secondPrecision ? 1_000 : 60_000;
+  for (
+    let instant = Math.floor(after / step) * step + step;
+    instant <= after + 3 * 3_600_000;
+    instant += step
+  ) {
+    if (matches(parsed, instant + zoneOffsetMs(instant, timeZone))) return instant;
+  }
+
+  const wallAfter = after + zoneOffsetMs(after, timeZone);
+  const wallDate = new Date(wallAfter);
+  const firstDay = Date.UTC(
+    wallDate.getUTCFullYear(),
+    wallDate.getUTCMonth(),
+    wallDate.getUTCDate(),
+  );
+  for (let dayOffset = 0; dayOffset <= 366 * 5; dayOffset += 1) {
+    const day = firstDay + dayOffset * 86_400_000;
+    if (!matchesDate(parsed, new Date(day))) continue;
+    for (const hour of parsed.hours) {
+      for (const minute of parsed.minutes) {
+        for (const second of parsed.seconds) {
+          const wall = day + hour * 3_600_000 + minute * 60_000 + second * 1_000;
+          if (wall <= wallAfter) continue;
+          const resolved = wallTimeCandidates(wall, timeZone, after)[0];
+          if (resolved !== undefined) return resolved;
+        }
+      }
+    }
+  }
+  throw new Error("Cron has no occurrence in the next five years");
+}
+
+export function isValidTimeZone(timeZone: string): boolean {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function wallTimeCandidates(wallUtc: number, timeZone: string, after: number): number[] {
+  const offsets = new Set([
+    zoneOffsetMs(after, timeZone),
+    zoneOffsetMs(wallUtc - 2 * 86_400_000, timeZone),
+    zoneOffsetMs(wallUtc, timeZone),
+    zoneOffsetMs(wallUtc + 2 * 86_400_000, timeZone),
+  ]);
+  return [...offsets]
+    .map((offset) => wallUtc - offset)
+    .filter((instant) =>
+      instant > after && instant + zoneOffsetMs(instant, timeZone) === wallUtc
+    )
+    .sort((left, right) => left - right);
+}
+
+function matches(
+  cron: ReturnType<typeof parseCronExpression>,
+  wallUtc: number,
+): boolean {
+  const wall = new Date(wallUtc);
+  return cron.seconds.includes(wall.getUTCSeconds()) &&
+    cron.minutes.includes(wall.getUTCMinutes()) &&
+    cron.hours.includes(wall.getUTCHours()) &&
+    matchesDate(cron, wall);
+}
+
+function matchesDate(
+  cron: ReturnType<typeof parseCronExpression>,
+  wall: Date,
+): boolean {
+  if (!cron.months.includes(wall.getUTCMonth())) return false;
+  const daysRestricted = cron.days.length !== 31;
+  const weekdaysRestricted = cron.weekdays.length !== 7;
+  const dayMatches = cron.days.includes(wall.getUTCDate());
+  const weekdayMatches = cron.weekdays.includes(wall.getUTCDay());
+  return daysRestricted && weekdaysRestricted
+    ? dayMatches || weekdayMatches
+    : dayMatches && weekdayMatches;
+}

package/src/adapter/cloudflare/universal-agent/tools.ts

@@ -8,31 +8,18 @@ import type {
 import type { RuntimeDegradation } from "../../../kernel/degradation";
 import type { RuntimeMemoryProfile } from "../../../kernel/profile";
 import type { WorkspaceRevisionRestorePort } from "../../../workspace-versioning";
-import { createScheduleTools } from "../../../pi/tool/schedule";
-import { createWorkspaceRevisionTools } from "../../../pi/tool/workspace-revision";
+import { schedulePiToolCandidates } from "../../../pi/tool/schedule";
+import { workspaceRevisionPiToolCandidate } from "../../../pi/tool/workspace-revision";
 import {
-  createSandboxTools,
-  createWorkspaceTools,
+  sandboxPiToolCandidates,
+  workspacePiToolCandidates,
 } from "../../../pi/tool/workspace-sandbox";
-import {
-  mergeToolRegistries,
-  type RuntimeCodeExecutionFactory,
-  type ToolAssemblyResult,
-  type ToolRegistry,
-} from "../../../tool-registry";
-
-export function selectTools(
-  tools: ToolRegistry,
-  names: Iterable<string>,
-): ToolRegistry {
-  const selected = new Set(names);
-  return Object.fromEntries(
-    Object.entries(tools).filter(([name]) => selected.has(name)),
-  );
-}
+import type { RuntimeCodeExecutionFactory } from "../../../kernel/bindings";
+import type { ToolAssemblyResult } from "../../../runtime-definition";
+import type { PiToolCandidate } from "../../../pi/tool/compiler";
 
 export function assembleUniversalAgentTools(options: {
-  hostTools?: ToolRegistry;
+  hostTools?: readonly PiToolCandidate[];
   workspace?: WorkspacePort;
   workspaceRevisions?: WorkspaceRevisionRestorePort;
   codeExecution?: RuntimeCodeExecutionFactory;
@@ -45,15 +32,15 @@ export function assembleUniversalAgentTools(options: {
   degradations?: readonly RuntimeDegradation[];
   dispose?: () => Promise<void>;
 }): ToolAssemblyResult {
-  const tools = mergeToolRegistries(
-    options.hostTools ?? {},
-    options.workspace ? createWorkspaceTools(options.workspace) : {},
-    options.workspaceRevisions
-      ? createWorkspaceRevisionTools(options.workspaceRevisions)
-      : {},
-    options.sandbox ? createSandboxTools(options.sandbox) : {},
-    options.schedule ? createScheduleTools(options.schedule) : {},
-  );
+  const tools = [
+    ...(options.hostTools ?? []),
+    ...(options.workspace ? workspacePiToolCandidates(options.workspace) : []),
+    ...(options.workspaceRevisions
+      ? [workspaceRevisionPiToolCandidate(options.workspaceRevisions)]
+      : []),
+    ...(options.sandbox ? sandboxPiToolCandidates(options.sandbox) : []),
+    ...(options.schedule ? schedulePiToolCandidates(options.schedule) : []),
+  ];
 
   return {
     tools,

package/src/index.ts

@@ -23,8 +23,8 @@
  * - `canonical transcript` 是 Pi 持久化和恢复 Turn 时使用的权威消息历史。
  * - `admission` 是提示进入 Turn 前的接纳、去重和状态登记流程。
  * - `defineRuntimeAgent.load` 返回 config 和已加载 Resource。
- * - `defineRuntimeAgent.tools` 是 Host 第一层 Tool 注册表声明。
- * - `assembleRuntimeSnapshot` 消费该输入与 hooks，产出候选 Snapshot。
+ * - `defineRuntimeAgent.tools` 返回 Host 的 Pi Tool Candidate 装配结果。
+ * - `assembleRuntimeSnapshot` 消费已加载 Resource 与 Tool，产出候选 Snapshot。
  * - `Port` 是 Runtime 调用外部能力时依赖的最小接口（Definition 作者不直接装配）。
  * - `RuntimeBindings` 是本次装配选中的 Port 和可执行对象集合。
  * - `RuntimeBuilder` 是包内实现，用来校验贡献并生成候选结果。
@@ -61,33 +61,16 @@ export type {
   RuntimeSkillContribution,
   RuntimeToolSurfacePolicy,
 } from "./runtime-assembler";
-export { assembleRuntimeSnapshot, toolRegistryPiToolCandidates } from "./runtime-assembler";
+export { assembleRuntimeSnapshot } from "./runtime-assembler";
 export type {
-  PlatformToolContext,
-  PlatformToolRegistry,
-  PlatformToolSpec,
-  ProfileOverrides,
   ResolvedConnectors,
   ResolvedResources,
   RuntimeAgentContext,
-  RuntimeAgentHooks,
   RuntimeSettings,
   RuntimeToolBindings,
   ToolAssemblyResult,
-  ToolContext,
-  ToolRegistry,
-  ToolSpec,
 } from "./runtime-definition";
-export {
-  emptyPlatformToolRegistry,
-  emptyToolRegistry,
-  mergeToolRegistries,
-  normalizeToolAssembly,
-  piCandidateToToolSpec,
-  toolRegistryFromPiCandidates,
-} from "./tool-registry";
 export type { ModelOption } from "./lib/model-catalog";
-export type { RuntimeCodeExecutionFactory } from "./tool-registry";
 export {
   assembleSubagentPrompt,
   assembleSystemPrompt,
@@ -118,26 +101,15 @@ export type {
   PiDeclaredToolCallContext,
   PiDeclaredToolPolicy,
 } from "./pi/tool";
+export { memoryPiToolCandidate } from "./pi/tool";
+export { GET_TIME_TOOL_NAME, getTimePiToolCandidate } from "./pi/tool";
+export { schedulePiToolCandidates } from "./pi/tool";
 export {
-  createMemoryTools,
-  memoryPiToolCandidate,
-} from "./pi/tool";
-export {
-  createScheduleTools,
-  schedulePiToolCandidates,
-} from "./pi/tool";
-export {
-  createSandboxTools,
-  createWorkspaceRevisionTools,
-  createWorkspaceTools,
   sandboxPiToolCandidates,
   workspaceRevisionPiToolCandidate,
   workspacePiToolCandidates,
 } from "./pi/tool";
-export {
-  createSubagentTools,
-  subagentPiToolCandidates,
-} from "./pi/tool";
+export { subagentPiToolCandidates } from "./pi/tool";
 export { skillPiToolCandidates } from "./pi/tool";
 export type { PiSkillBinding } from "./pi/tool";
 export {

package/src/kernel/bindings.ts

@@ -2,7 +2,8 @@ import type { SkillSource } from "agents/skills";
 import type { ScheduleSpec } from "./receipts";
 import type { RuntimeActivityProjection } from "./state";
 import type { ExecutionLevel } from "../lib/execution-level";
-import type { ToolRegistry } from "./tool-surface";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { PiToolCandidate } from "../pi/tool/compiler";
 import type {
   RuntimeEventConfirmation,
   RuntimeLifecycleFact,
@@ -213,7 +214,7 @@ export interface WorkspacePort {
  */
 export interface RuntimeCodeExecutionPort {
   readonly description: string;
-  execute(input: { code: string }): Promise<unknown>;
+  execute(input: { code: string }): Promise<AgentToolResult<unknown>>;
 }
 
 /**
@@ -1022,12 +1023,11 @@ export interface RuntimeSkillSourceBinding {
  * 延迟到最终 Tool Surface 完成后再创建 Code Mode 执行能力。
  *
  * @remarks
- * 定义在这里而不是 `tool-registry.ts`：它的返回类型是本文件的
- * `RuntimeCodeExecutionPort`，而 `RuntimeBindings` 又要引用这个工厂 —— 放在
- * tool-registry 会让两个模块互相 import。`tool-registry.ts` 继续对外导出它。
+ * 工厂与返回 Port 同住 Host 绑定边界；输入直接使用最终 Pi Tool candidates，
+ * 不再经过 Registry 或另一份 Tool 元数据协议。
  */
 export interface RuntimeCodeExecutionFactory {
-  create(tools: ToolRegistry): RuntimeCodeExecutionPort;
+  create(candidates: readonly PiToolCandidate[]): RuntimeCodeExecutionPort;
 }
 
 export interface RuntimeBindings {

package/src/pi/assembly/extensions.ts

@@ -3,7 +3,6 @@ import {
   type ExtensionManifest,
   type ExtensionPermissions,
 } from "@cloudflare/think/extensions";
-import type { AgentTool } from "@earendil-works/pi-agent-core";
 import { asSchema } from "ai";
 import type {
   LoadedRuntimeExtension,
@@ -14,6 +13,7 @@ import type { RuntimeDegradation } from "../../kernel/degradation";
 import { withRuntimeLoadTimeout } from "../../kernel/runtime-load";
 import { sanitizeExtensionName } from "../../lib/extension-name";
 import type { PiToolCandidate } from "../tool/compiler";
+import { createPiDeclaredToolCandidate } from "../tool/declared";
 
 export interface PiExtensionContextContribution {
   readonly extensionName: string;
@@ -563,45 +563,30 @@ export async function assemblePiExtensions({
       const toolName = `${prefix}_${descriptor.name}`;
       toolNames.push(toolName);
       const description = `[${name}] ${descriptor.description}`;
-      // 作用：把 Extension 的原始执行结果包装成 Pi Agent Core 的 Tool 结果。
-      // 调用：编译后的共享 Tool 调度器在模型发起该 Extension Tool 时调用。
-      // 原因：所有 Extension 结果在这个边界统一变成 text content，同时在 details 保留未损失的原值。
-      const execute: AgentTool<any, {
-        extension: string;
-        result: unknown;
-      }>["execute"] = async (_toolCallId, params, signal) => {
-        const result = await loaded.execute(
+      const candidate = createPiDeclaredToolCandidate(
+        {
+          name: descriptor.name,
+          title: `${name}: ${descriptor.name}`,
+          description,
+          inputSchema: descriptor.inputSchema,
+        },
+        (input, { signal }) => loaded.execute(
           descriptor.name,
-          params as Readonly<Record<string, unknown>>,
+          input,
           signal,
-        );
-        return {
-          content: [{
-            type: "text" as const,
-            text: resultText(result),
-          }],
-          details: {
-            extension: name,
-            result,
-          },
-        };
-      };
-      const tool: AgentTool<any, {
-        extension: string;
-        result: unknown;
-      }> = Object.freeze({
-        name: toolName,
-        label: `${name}: ${descriptor.name}`,
-        description,
-        parameters: descriptor.inputSchema as AgentTool["parameters"],
-        execute,
-      });
-      candidates.push(Object.freeze({
-        owner: `extension:${name}@${extension.manifest.version}`,
-        requiredExecutionLevel,
-        summary: description,
-        tool,
-      }));
+        ),
+        {
+          owner: `extension:${name}@${extension.manifest.version}`,
+          modelName: toolName,
+          requiredExecutionLevel,
+          summary: description,
+          project: (result) => ({
+            content: [{ type: "text", text: resultText(result) }],
+            details: { extension: name, result },
+          }),
+        },
+      );
+      candidates.push(Object.freeze({ ...candidate, requiredExecutionLevel }));
     }
     loadedExtensions.push(Object.freeze({
       name,

package/src/pi/assembly/snapshot.ts

@@ -23,7 +23,13 @@ import type { PiToolCandidate } from "../tool/compiler";
 export interface PiToolSurface {
   finalize(
     candidates: readonly PiToolCandidate[],
-  ): readonly PiToolCandidate[];
+  ): FinalizedPiToolSurface;
+}
+
+/** Internal finalization output; not a second Tool protocol. */
+export interface FinalizedPiToolSurface {
+  readonly candidates: readonly PiToolCandidate[];
+  readonly codeExecutionCandidates: readonly PiToolCandidate[];
 }
 
 /** Immutable inputs consumed directly by Pi Agent Core. */

package/src/pi/runtime-adapter/assembly.ts

@@ -10,7 +10,7 @@ import type {
 import type { RuntimeProfile } from "../../kernel/profile";
 import type { ExecutionLevel } from "../../lib/execution-level";
 import type { RuntimeSnapshot } from "../../runtime-assembler";
-import type { PiRuntimeAssembly } from "../assembly";
+import type { FinalizedPiToolSurface, PiRuntimeAssembly } from "../assembly";
 import {
   assemblePiSystemContext,
   assemblePiExtensions,
@@ -77,7 +77,7 @@ interface PreparedPiAssembly {
   readonly loaded: readonly PiLoadedExtension[];
   readonly context: readonly PiExtensionContextContribution[];
   readonly degradations: PiExtensionAssembly["degradations"];
-  readonly candidates: readonly PiToolCandidate[];
+  readonly toolSurface: FinalizedPiToolSurface;
 }
 
 /**
@@ -193,6 +193,7 @@ export interface PreparedPiRuntimeState {
   readonly snapshot: RuntimeSnapshot;
   readonly assembly: PreparedPiAssembly;
   readonly candidates: readonly PiToolCandidate[];
+  readonly codeExecutionCandidates: readonly PiToolCandidate[];
 }
 
 // #endregion
@@ -411,21 +412,22 @@ async function preparePiAssembly(
       });
     },
   });
+  const toolSurface = snapshot.pi.toolSurface.finalize([
+    ...extensions.candidates,
+    listExtensionsPiToolCandidate(extensions.loaded),
+    ...(options.gatewaySession
+      ? createPiGatewayToolCandidates(options.gatewaySession)
+      : []),
+    ...createPiMcpToolCandidates(
+      options.mcpHost,
+      snapshot.profile.mcpServers,
+    ),
+  ]);
   return Object.freeze({
     loaded: extensions.loaded,
     context: extensions.context,
     degradations: extensions.degradations,
-    candidates: snapshot.pi.toolSurface.finalize([
-      ...extensions.candidates,
-      listExtensionsPiToolCandidate(extensions.loaded),
-      ...(options.gatewaySession
-        ? createPiGatewayToolCandidates(options.gatewaySession)
-        : []),
-      ...createPiMcpToolCandidates(
-        options.mcpHost,
-        snapshot.profile.mcpServers,
-      ),
-    ]),
+    toolSurface,
   });
 }
 
@@ -446,7 +448,7 @@ export async function preparePiRuntime(
   owner: object,
 ): Promise<PreparedPiRuntime> {
   const assembly = await preparePiAssembly(options);
-  const candidates = assembly.candidates;
+  const candidates = assembly.toolSurface.candidates;
   return Object.freeze(new PreparedRuntime(
     describeRuntime(options.snapshot, candidates, assembly.loaded),
     Object.freeze([
@@ -460,6 +462,9 @@ export async function preparePiRuntime(
       snapshot: options.snapshot,
       assembly,
       candidates: Object.freeze([...candidates]),
+      codeExecutionCandidates: Object.freeze([
+        ...assembly.toolSurface.codeExecutionCandidates,
+      ]),
     }),
   ));
 }

package/src/pi/runtime-adapter/execution.ts

@@ -49,7 +49,6 @@ import {
 import { EXECUTION_LEVELS } from "../../lib/execution-level";
 import { projectToolOutputForModel } from "../../layers/context/budget/gate";
 import type { SpillWorkspace } from "../../lib/artifacts";
-import { toolRegistryFromPiCandidates } from "../../tool-registry";
 
 // #region Single-run Pi bridge
 
@@ -816,7 +815,7 @@ export class PreparedPiTurnAdapter {
       },
     });
     this.candidates = state.candidates.map((candidate) => {
-      if (!candidate.codeExecutionTools) return bindCandidate(candidate);
+      if (candidate.tool.name !== "execute") return bindCandidate(candidate);
       const factory = state.snapshot.bindings.codeExecution;
       if (!factory) {
         throw new Error("Prepared Code Mode Tool requires a Runtime factory");
@@ -827,14 +826,12 @@ export class PreparedPiTurnAdapter {
           ...candidate.tool,
           execute: (toolCallId, input, signal, onUpdate) => {
             const runtimeCandidate = codeExecutionPiToolCandidate(
-              factory.create(toolRegistryFromPiCandidates(
-                candidate.codeExecutionTools!.map((inner) =>
-                  // Code Mode owns replay of its connector calls. Pi persists
-                  // only the parent execute attempt/result; recording an inner
-                  // input without a Pi settlement creates an orphan recovery
-                  // action that cannot be found on the direct Tool surface.
-                  bindCandidate(inner, toolCallId, false)
-                ),
+              factory.create(state.codeExecutionCandidates.map((inner) =>
+                // Code Mode owns replay of its connector calls. Pi persists
+                // only the parent execute attempt/result; recording an inner
+                // input without a Pi settlement creates an orphan recovery
+                // action that cannot be found on the direct Tool surface.
+                bindCandidate(inner, toolCallId, false)
               )),
             );
             return runtimeCandidate.tool.execute(