@springbrand/agent-runtime 0.1.3-alpha.8 → 0.2.0-alpha.14

package/src/pi/tool/skill.ts

@@ -1,17 +1,20 @@
 import {
   runner as createSkillScriptRunner,
   SkillRegistry,
+  type SkillResource,
   type SkillScriptRequest,
   type SkillScriptRunner,
   type SkillSource,
 } from "agents/skills";
-import { jsonSchema, type ToolSet } from "ai";
+import { jsonSchema, tool, type ToolSet } from "ai";
+import { z } from "zod";
 import type {
   RuntimeSkillScriptPolicy,
   WorkspacePort,
 } from "../../kernel/bindings";
 import { aiToolToPi } from "./ai-adapter";
 import type { PiToolCandidate } from "./compiler";
+import { serializeWorkspaceMutation } from "./workspace-sandbox";
 
 /** A configured Skill source and its script capabilities. */
 export interface PiSkillBinding {
@@ -103,11 +106,72 @@ const SKILL_TOOL_LABELS: Readonly<Record<string, string>> = {
   activate_skill: "Activate Skill",
   read_skill_resource: "Read Skill resource",
   run_skill_script: "Run Skill script",
+  materialize_skill_resource: "Materialize Skill resource",
 };
 
 const SKILL_ENTRY_READ_GUIDANCE =
   "SKILL.md contains the Skill instructions; use activate_skill instead.";
 
+function resourceBytes(resource: SkillResource): Uint8Array {
+  if ((resource.encoding ?? "text") === "text") {
+    return new TextEncoder().encode(resource.content);
+  }
+  const binary = atob(resource.content);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+function materializeSkillResourceTool(
+  bindings: readonly PiSkillBinding[],
+  workspace: WorkspacePort,
+) {
+  const names = bindings.map(({ name }) => name) as [string, ...string[]];
+  const byName = new Map(bindings.map((binding) => [binding.name, binding]));
+  return tool({
+    description:
+      "Copy a complete bundled Skill resource directly into the Workspace without returning its contents to the model. " +
+      "Use this instead of read_skill_resource when a template, script, image, font, or other asset must become a Workspace file. " +
+      "The destination is created or overwritten, including parent directories.",
+    inputSchema: z.object({
+      name: z.enum(names).describe("Activated Skill name"),
+      path: z.string().min(1).describe("Bundled resource path listed by activate_skill"),
+      destination: z.string().min(1).describe("Absolute destination path in the Workspace"),
+    }),
+    execute: async ({ name, path, destination }, { abortSignal }) => {
+      abortSignal?.throwIfAborted();
+      const source = byName.get(name)?.source;
+      if (!source?.readResource) {
+        throw new Error(`Skill \"${name}\" has no readable resources.`);
+      }
+      const resource = await source.readResource(name, path);
+      if (!resource) throw new Error(`Resource not found: ${name}/${path}`);
+      abortSignal?.throwIfAborted();
+      const bytes = resourceBytes(resource);
+
+      await serializeWorkspaceMutation(workspace, destination, async () => {
+        abortSignal?.throwIfAborted();
+        const parent = destination.replace(/\/[^/]+$/, "");
+        if (parent && parent !== "/") {
+          await workspace.mkdir(parent, { recursive: true });
+        }
+        await workspace.writeFileBytes(destination, bytes, resource.mimeType);
+      });
+
+      return {
+        name,
+        path: resource.path,
+        destination,
+        bytesWritten: bytes.byteLength,
+        encoding: resource.encoding ?? "text",
+        ...(resource.mimeType ? { mimeType: resource.mimeType } : {}),
+      };
+    },
+  });
+}
+
 /** Create Pi candidates from the official Agents SDK SkillRegistry tools. */
 export async function skillPiToolCandidates(
   bindings: readonly PiSkillBinding[],
@@ -121,7 +185,15 @@ export async function skillPiToolCandidates(
   );
   await registry.load();
 
-  return Object.entries(registry.tools()).map(([name, tool]) => {
+  const tools = registry.tools();
+  if (options.workspace) {
+    tools.materialize_skill_resource = materializeSkillResourceTool(
+      bindings,
+      options.workspace,
+    );
+  }
+
+  return Object.entries(tools).map(([name, tool]) => {
     const adapted = aiToolToPi(name, tool, {
       label: SKILL_TOOL_LABELS[name] ?? name,
       ...(name === "read_skill_resource"
@@ -154,7 +226,10 @@ export async function skillPiToolCandidates(
     }
     return {
       owner: "runtime-skill",
-      requiredExecutionLevel: name === "run_skill_script" ? "high" : "safe",
+      requiredExecutionLevel:
+        name === "run_skill_script" || name === "materialize_skill_resource"
+          ? "high"
+          : "safe",
       tool: adapted,
     };
   });

package/src/pi/tool/subagent.ts

@@ -1,8 +1,17 @@
 import type { AgentTool, AgentToolResult } from "@earendil-works/pi-agent-core";
 import { z } from "zod";
-import type { RuntimeSubagentPort } from "../../kernel/bindings";
+import type {
+  RuntimeSubagentLifecyclePort,
+  RuntimeSubagentPort,
+  RuntimeSubagentRunResult,
+  RuntimeSubagentUsageEvent,
+} from "../../kernel/bindings";
 import { AGENT_TYPES } from "../../layers/orchestration/subagents/agent-types/registry";
 import { serializeOutput } from "../../lib/artifacts";
+import {
+  isZeroSubagentUsage,
+  subagentTerminalStatus,
+} from "../../kernel/subagent-runtime";
 import type { PiToolCandidate } from "./compiler";
 import {
   toolRegistryFromPiCandidates,
@@ -38,6 +47,61 @@ function failure(agentType: string, status: string, error?: string) {
   };
 }
 
+async function runRegisteredSubagent(
+  lifecycle: RuntimeSubagentLifecyclePort,
+  subagentRunId: string,
+  run: () => Promise<RuntimeSubagentRunResult>,
+): Promise<RuntimeSubagentRunResult> {
+  let result: RuntimeSubagentRunResult;
+  try {
+    result = await run();
+  } catch (error) {
+    await lifecycle.onTerminal({
+      subagentRunId,
+      status: "failed",
+      zeroUsage: true,
+    });
+    throw error;
+  }
+  if (result.runId !== subagentRunId) {
+    await recordSubagentResult(lifecycle, {
+      ...result,
+      runId: subagentRunId,
+      status: "error",
+    });
+    throw new Error("SubAgent run ID changed after durable registration");
+  }
+  return result;
+}
+
+async function recordSubagentResult(
+  lifecycle: RuntimeSubagentLifecyclePort,
+  run: RuntimeSubagentRunResult,
+): Promise<void> {
+  const status = subagentTerminalStatus(run.status);
+  if (run.usage) {
+    const event: RuntimeSubagentUsageEvent = {
+      eventId: `${run.runId}:usage`,
+      submissionId: lifecycle.submissionId,
+      runId: run.runId,
+      subagentRunId: run.runId,
+      parentRunId: lifecycle.parentRunId,
+      ...(lifecycle.accountId ? { accountId: lifecycle.accountId } : {}),
+      ...(lifecycle.rateVersion !== undefined ? { rateVersion: lifecycle.rateVersion } : {}),
+      ...(lifecycle.slotIdentity ? { slotIdentity: lifecycle.slotIdentity } : {}),
+      kind: "subagent",
+      status,
+      usage: run.usage,
+    };
+    await lifecycle.onUsage(event);
+  }
+  await lifecycle.onTerminal({
+    subagentRunId: run.runId,
+    status,
+    zeroUsage: !run.usage || isZeroSubagentUsage(run.usage),
+  });
+}
+
 /**
  * 把已启用的 SubAgent 类型转换成 Pi 候选工具。
  *
@@ -53,6 +117,7 @@ function failure(agentType: string, status: string, error?: string) {
 export function subagentPiToolCandidates(
   subagents: RuntimeSubagentPort | undefined,
   enabledSubagents: readonly string[],
+  lifecycle?: RuntimeSubagentLifecyclePort,
 ): PiToolCandidate[] {
   if (!subagents) return [];
   const types = [...new Set(enabledSubagents)].flatMap((name) => {
@@ -79,10 +144,38 @@ export function subagentPiToolCandidates(
       // 适配层只固定类型名并统一结果语义。
       async execute(_toolCallId, input, signal) {
         signal?.throwIfAborted();
-        const run = await subagents.run(
-          type.name,
-          input as Record<string, unknown>,
-        );
+        const childInput = input as Record<string, unknown>;
+        if (lifecycle && !subagents.reserve) {
+          throw new Error("Durable SubAgent execution requires run reservation");
+        }
+        const reserved = lifecycle
+          ? await subagents.reserve!(type.name, childInput, {
+              parentRunId: lifecycle.parentRunId,
+              submissionId: lifecycle.submissionId,
+              toolCallId: _toolCallId,
+            })
+          : undefined;
+        if (reserved && lifecycle) await lifecycle.onRegistered(reserved.runId);
+        const runOptions = lifecycle
+          ? {
+              parentRunId: lifecycle.parentRunId,
+              submissionId: lifecycle.submissionId,
+              ...(reserved ? { subagentRunId: reserved.runId } : {}),
+              ...(lifecycle.accountId ? { accountId: lifecycle.accountId } : {}),
+              ...(lifecycle.rateVersion !== undefined ? { rateVersion: lifecycle.rateVersion } : {}),
+              ...(lifecycle.slotIdentity ? { slotIdentity: lifecycle.slotIdentity } : {}),
+            }
+          : undefined;
+        const run = lifecycle && reserved
+          ? await runRegisteredSubagent(
+              lifecycle,
+              reserved.runId,
+              () => subagents.run(type.name, childInput, runOptions),
+            )
+          : await subagents.run(type.name, childInput);
+        if (lifecycle && !run.childStillRunning) {
+          await recordSubagentResult(lifecycle, run);
+        }
         if (run.status !== "completed" || run.output === undefined) {
           return result(failure(type.name, run.status, run.error));
         }
@@ -112,7 +205,7 @@ export function subagentPiToolCandidates(
     // 调用：Pi 需要子任务异步进行、不应阻塞当前 Turn 时调用。
     // 原因：先用具体 AgentType Schema 复核嵌套 input，
     // 再把 detached 和通知语义交给 Host，避免后台入口绕过类型约束。
-    async execute(_toolCallId, value, signal) {
+    async execute(toolCallId, value, signal) {
       signal?.throwIfAborted();
       const input = value as z.infer<typeof parameters>;
       const parsed = AGENT_TYPES.byName[input.agentType]!.inputSchema.safeParse(
@@ -123,15 +216,47 @@ export function subagentPiToolCandidates(
           `SubAgent input failed schema validation: ${parsed.error.message}`,
         );
       }
-      const run = await subagents.run(
-        input.agentType,
-        parsed.data as Record<string, unknown>,
-        {
-          detached: true,
-          maxBudgetMs: BACKGROUND_MAX_BUDGET_MS,
-          notifySource: "dispatch-background",
-        },
-      );
+      if (lifecycle && !subagents.reserve) {
+        throw new Error("Durable SubAgent execution requires run reservation");
+      }
+      const reserved = lifecycle
+        ? await subagents.reserve!(
+            input.agentType,
+            parsed.data as Record<string, unknown>,
+            {
+              parentRunId: lifecycle.parentRunId,
+              submissionId: lifecycle.submissionId,
+              toolCallId,
+            },
+          )
+        : undefined;
+      if (reserved && lifecycle) await lifecycle.onRegistered(reserved.runId);
+      const runInput = parsed.data as Record<string, unknown>;
+      const runOptions = {
+        detached: true,
+        maxBudgetMs: BACKGROUND_MAX_BUDGET_MS,
+        notifySource: "dispatch-background",
+        ...(lifecycle
+          ? {
+              parentRunId: lifecycle.parentRunId,
+              submissionId: lifecycle.submissionId,
+              ...(reserved ? { subagentRunId: reserved.runId } : {}),
+              ...(lifecycle.accountId ? { accountId: lifecycle.accountId } : {}),
+              ...(lifecycle.rateVersion !== undefined ? { rateVersion: lifecycle.rateVersion } : {}),
+              ...(lifecycle.slotIdentity ? { slotIdentity: lifecycle.slotIdentity } : {}),
+            }
+          : {}),
+      };
+      const run = lifecycle && reserved
+        ? await runRegisteredSubagent(
+            lifecycle,
+            reserved.runId,
+            () => subagents.run(input.agentType, runInput, runOptions),
+          )
+        : await subagents.run(input.agentType, runInput, runOptions);
+      if (lifecycle && !run.childStillRunning && run.status !== "running") {
+        await recordSubagentResult(lifecycle, run);
+      }
       return result({
         runId: run.runId,
         status: run.status,
@@ -153,8 +278,9 @@ export function subagentPiToolCandidates(
 export function createSubagentTools(
   subagents: RuntimeSubagentPort | undefined,
   enabledSubagents: readonly string[],
+  lifecycle?: RuntimeSubagentLifecyclePort,
 ): ToolRegistry {
   return toolRegistryFromPiCandidates(
-    subagentPiToolCandidates(subagents, enabledSubagents),
+    subagentPiToolCandidates(subagents, enabledSubagents, lifecycle),
   );
 }

package/src/pi/tool/workspace-revision.ts

@@ -0,0 +1,64 @@
+import type { AgentTool, AgentToolResult } from "@earendil-works/pi-agent-core";
+import { Type } from "@earendil-works/pi-ai";
+import type { WorkspaceRevisionRestorePort } from "../../workspace-versioning";
+import { serializeOutput } from "../../lib/artifacts";
+import {
+  toolRegistryFromPiCandidates,
+  type ToolRegistry,
+} from "../../tool-registry";
+import type { PiToolCandidate } from "./compiler";
+
+const parameters = Type.Object({
+  target: Type.Union([
+    Type.Literal("previous"),
+    Type.String({
+      pattern: "^[0-9a-f]{40}$",
+      description: "A complete revision ID shown in Workspace history.",
+    }),
+  ], {
+    description: "Use previous for the revision immediately before the current one.",
+  }),
+});
+
+function result<T>(details: T): AgentToolResult<T> {
+  return {
+    content: [{ type: "text", text: serializeOutput(details).text }],
+    details,
+  };
+}
+
+export function workspaceRevisionPiToolCandidate(
+  versions: WorkspaceRevisionRestorePort,
+): PiToolCandidate {
+  const tool: AgentTool<typeof parameters> = {
+    name: "restore_workspace_revision",
+    label: "Restore Workspace revision",
+    description:
+      "Restore the configured Workspace tree to the previous revision or an exact revision. Use only when the person explicitly asks to roll back. This always asks for approval and changes only the Workspace files managed by the Host.",
+    parameters,
+    async execute(_toolCallId, input, signal) {
+      signal?.throwIfAborted();
+      return result({
+        status: "restored",
+        ...await versions.restore(input.target),
+        note: "The approved Workspace revision is now current.",
+      });
+    },
+  };
+  return {
+    owner: "workspace",
+    tool,
+    requiredExecutionLevel: "safe",
+    alwaysRequiresApproval: true,
+    source: "action",
+    summary: "Restore the Workspace tree",
+  };
+}
+
+export function createWorkspaceRevisionTools(
+  versions: WorkspaceRevisionRestorePort,
+): ToolRegistry {
+  return toolRegistryFromPiCandidates([
+    workspaceRevisionPiToolCandidate(versions),
+  ]);
+}

package/src/pi/tool/workspace-sandbox.ts

@@ -111,7 +111,7 @@ const mutationQueues = new WeakMap<
   Map<string, Promise<void>>
 >();
 
-function serializeByPath<T>(
+export function serializeWorkspaceMutation<T>(
   workspace: WorkspacePort,
   path: string,
   run: () => Promise<T>,
@@ -193,7 +193,7 @@ export function workspacePiToolCandidates(
       signal?.throwIfAborted();
       running(onUpdate, "Writing the Workspace file.");
 
-      return serializeByPath(workspace, path, async () => {
+      return serializeWorkspaceMutation(workspace, path, async () => {
         // 排队期间可能已经被取消,拿到闸之后必须重新确认,否则会写一个已放弃的结果。
         signal?.throwIfAborted();
         return writeTool.execute(
@@ -221,7 +221,7 @@ export function workspacePiToolCandidates(
       running(onUpdate, "Editing the Workspace file.");
       // 读-比对-写整段都在闸内:闸只包住最后那次 writeFile 的话,基准内容仍然可能在
       // 比对之后被别的调用换掉,丢写照旧发生。
-      return serializeByPath(workspace, params.path, async () => {
+      return serializeWorkspaceMutation(workspace, params.path, async () => {
         signal?.throwIfAborted();
         const output = await editTool.execute(
           toolCallId,
@@ -267,7 +267,7 @@ export function workspacePiToolCandidates(
       if (typeof path !== "string") {
         return removeTool.execute(toolCallId, params, signal, onUpdate);
       }
-      return serializeByPath(workspace, path, () =>
+      return serializeWorkspaceMutation(workspace, path, () =>
         removeTool.execute(toolCallId, params, signal, onUpdate),
       );
     },

package/src/pi/turn/tool-recovery.ts

@@ -429,7 +429,7 @@ function assertIdentity(
       state.assemblyRevision !== milestone.assemblyRevision)
   ) {
     throw new Error(
-      "Pi recovery milestone does not belong to the active Turn revision",
+      "SpringBrand recovery milestone does not belong to the active Turn revision",
     );
   }
 }
@@ -496,7 +496,7 @@ export function replayPiToolRecovery(
         const previous = tools[milestone.toolCallId];
         if (previous && !sameToolInput(previous, milestone)) {
           throw new Error(
-            `Conflicting Pi Tool input for ${milestone.toolCallId}`,
+            `Conflicting SpringBrand Tool input for ${milestone.toolCallId}`,
           );
         }
         tools[milestone.toolCallId] = previous ?? {
@@ -891,7 +891,7 @@ export function applyRecoveredPiApprovalDecision(
 ): RecoveredPiApprovalDecision {
   const approval = state.approvals[input.executionId];
   if (!approval) {
-    throw new Error(`Unknown Pi Tool approval ${input.executionId}`);
+    throw new Error(`Unknown SpringBrand Tool approval ${input.executionId}`);
   }
   const transition = decidePiToolApproval(
     approval,
@@ -908,7 +908,7 @@ export function applyRecoveredPiApprovalDecision(
     return { milestones: [], outcome: transition.outcome };
   }
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool approval is missing its Turn revision");
+    throw new Error("SpringBrand Tool approval is missing its Turn revision");
   }
 
   const identity: RecoveryIdentity = {
@@ -951,7 +951,7 @@ export function recordRecoveredPiToolInteraction(
   interaction: PiToolInteraction,
 ): PiToolRecoveryMilestone[] {
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool interaction is missing its Turn revision");
+    throw new Error("SpringBrand Tool interaction is missing its Turn revision");
   }
   return [{
     version: 1,
@@ -989,7 +989,7 @@ export function applyRecoveredPiToolInteractionSettlement(
 ): RecoveredPiToolInteractionSettlement {
   const interaction = state.interactions[input.interactionId];
   if (!interaction) {
-    throw new Error(`Unknown Pi Tool interaction ${input.interactionId}`);
+    throw new Error(`Unknown SpringBrand Tool interaction ${input.interactionId}`);
   }
   const transition = input.kind === "respond"
     ? respondPiToolInteraction(interaction, {
@@ -1008,7 +1008,7 @@ export function applyRecoveredPiToolInteractionSettlement(
     return { milestones: [], outcome };
   }
   if (!state.turnId || !state.assemblyRevision) {
-    throw new Error("Pi Tool interaction is missing its Turn revision");
+    throw new Error("SpringBrand Tool interaction is missing its Turn revision");
   }
 
   const identity: RecoveryIdentity = {

package/src/runtime-agent-context.ts

@@ -37,6 +37,7 @@ export interface RuntimeAgentToolResult {
   output?: unknown;
   summary?: string;
   error?: string;
+  childStillRunning?: boolean;
 }
 
 export type RuntimeAgentRole = "primary" | "temporary";

package/src/runtime-agent.ts

@@ -652,9 +652,14 @@ export function defineRuntimeAgent<
         const policy = assembly.surfacePolicy;
         return {
           ...assembly,
-          bindings: assembly.bindings?.workspace
-            ? { workspace: assembly.bindings.workspace }
-            : {},
+          bindings: {
+            ...(assembly.bindings?.workspace
+              ? { workspace: assembly.bindings.workspace }
+              : {}),
+            ...(assembly.bindings?.codeExecution
+              ? { codeExecution: assembly.bindings.codeExecution }
+              : {}),
+          },
           memoryProfile: {
             enabled: false,
             memoryTokens: 2_000,

package/src/runtime-assembler.ts

@@ -1,6 +1,5 @@
 import type { SkillSource } from "agents/skills";
 import type {
-  RuntimeCodeExecutionPort,
   RuntimeGatewayPort,
   RuntimeMemoryPort,
   RuntimePlatformPort,
@@ -44,7 +43,11 @@ import type {
   RuntimeSkillContribution,
   RuntimeToolSurfacePolicy,
 } from "./runtime-definition";
-import type { ToolRegistry } from "./tool-registry";
+import {
+  toolRegistryFromPiCandidates,
+  type RuntimeCodeExecutionFactory,
+  type ToolRegistry,
+} from "./tool-registry";
 import { withRuntimeLoadTimeout } from "./kernel/runtime-load";
 import {
   basePiToolCandidates,
@@ -52,9 +55,11 @@ import {
 } from "./pi/tool/base";
 import {
   browserQuickActionPiToolCandidates,
+  codeExecutionPiToolCandidate,
 } from "./pi/tool/core";
 import { skillPiToolCandidates } from "./pi/tool/skill";
 import { createWebSearch } from "./pi/tool/web-search";
+import { subagentPiToolCandidates } from "./pi/tool/subagent";
 import { resolvePiModel } from "./pi/runtime-adapter/models";
 
 /** Runtime Assembler：校验一份扁平输入并生成可原子提交的 Snapshot。 */
@@ -76,7 +81,7 @@ export interface RuntimeAssemblyInput {
   readonly provider: RuntimeProviderPort;
   readonly platform: RuntimePlatformPort;
   readonly workspace?: WorkspacePort;
-  readonly codeExecution?: RuntimeCodeExecutionPort;
+  readonly codeExecution?: RuntimeCodeExecutionFactory;
   readonly sandbox?: RuntimeSandboxPort;
   readonly memory?: RuntimeMemoryPort;
   readonly hostTools: readonly PiToolCandidate[];
@@ -149,6 +154,7 @@ function assertMemoryProfile(profile: RuntimeMemoryProfile): void {
 }
 
 interface ToolSurfaceInput {
+  readonly codeExecution?: RuntimeCodeExecutionFactory;
   readonly platform: RuntimePlatformPort;
   readonly workspace?: WorkspacePort;
   readonly memory?: {
@@ -214,18 +220,46 @@ async function createToolSurface(
           ...staticCandidates,
           ...candidates,
         ]) {
-          const name = requiredName(candidate.tool.name, "Pi Tool");
+          const name = requiredName(candidate.tool.name, "SpringBrand Tool");
           if (!visible(candidate)) continue;
           if (!EXECUTION_LEVELS.includes(candidate.requiredExecutionLevel)) {
-            throw new Error(`Pi Tool ${name} execution level is invalid`);
+            throw new Error(`SpringBrand Tool ${name} execution level is invalid`);
           }
           if (tools.has(name)) {
-            throw new Error(`Duplicate Runtime Pi Tool: ${name}`);
+            throw new Error(`Duplicate Runtime SpringBrand Tool: ${name}`);
           }
           tools.set(name, Object.freeze({ ...candidate }));
         }
 
-        return Object.freeze([...tools.values()]);
+        const finalized = [...tools.values()];
+        if (tools.has("execute")) {
+          throw new Error("SpringBrand reserved Runtime Tool name: execute");
+        }
+        if (
+          !input.codeExecution ||
+          deny.has("execute") ||
+          allowsTool?.("execute") === false
+        ) {
+          return Object.freeze(finalized);
+        }
+        const mergeable = finalized.filter(
+          (candidate) =>
+            !candidate.interaction &&
+            typeof candidate.tool.execute === "function",
+        );
+        const direct = finalized.filter(
+          (candidate) =>
+            candidate.interaction ||
+            typeof candidate.tool.execute !== "function",
+        );
+        return Object.freeze([
+          Object.freeze(codeExecutionPiToolCandidate(
+            input.codeExecution.create(
+              toolRegistryFromPiCandidates(mergeable),
+            ),
+          )),
+          ...direct,
+        ]);
       },
     }),
     extensions: input.extensions.filter(
@@ -245,7 +279,7 @@ class RuntimeBuilder {
   private platform?: RuntimePlatformPort;
   private gateway?: RuntimeGatewayPort;
   private workspace?: WorkspacePort;
-  private codeExecution?: RuntimeCodeExecutionPort;
+  private codeExecution?: RuntimeCodeExecutionFactory;
   private sandbox?: RuntimeSandboxPort;
   private schedule?: RuntimeSchedulePort;
   private memoryProfile: RuntimeMemoryProfile = DISABLED_MEMORY;
@@ -469,12 +503,19 @@ class RuntimeBuilder {
     });
     const skillSources = [...this.skillSources.values()];
     const toolSurface = await createToolSurface({
+      ...(this.codeExecution ? { codeExecution: this.codeExecution } : {}),
       platform: this.platform,
       ...(this.workspace ? { workspace: this.workspace } : {}),
       ...(this.memoryProfile.enabled && this.memory
         ? { memory: { port: this.memory, profile: this.memoryProfile } }
         : {}),
-      hostTools: this.hostTools,
+      hostTools: [
+        ...this.hostTools,
+        ...subagentPiToolCandidates(
+          this.subagents,
+          [...this.enabledSubagents],
+        ),
+      ],
       skills: skillSources,
       enabledSubagents: [...this.enabledSubagents],
       webSearch,
@@ -492,6 +533,7 @@ class RuntimeBuilder {
       ...(this.memoryProfile.enabled && this.memory
         ? { memory: this.memory }
         : {}),
+      ...(this.subagents ? { subagents: this.subagents } : {}),
       skills: Object.freeze({
         sources: Object.freeze(skillSources),
       }),
@@ -632,6 +674,8 @@ function hooksToTurnEventsPort<
   if (
     !hooks.onTurnEnd &&
     !hooks.onModelUsage &&
+    !hooks.onSubagentUsage &&
+    !hooks.onLifecycleFact &&
     !hooks.onToolStart &&
     !hooks.onToolSettled &&
     !hooks.onApproval &&
@@ -645,6 +689,8 @@ function hooksToTurnEventsPort<
       ? (messages) => hooks.onTurnEnd!(ctx, messages)
       : async () => undefined,
     ...(hooks.onModelUsage ? { onModelUsage: hooks.onModelUsage } : {}),
+    ...(hooks.onSubagentUsage ? { onSubagentUsage: hooks.onSubagentUsage } : {}),
+    ...(hooks.onLifecycleFact ? { onLifecycleFact: hooks.onLifecycleFact } : {}),
     ...(hooks.onToolStart ? { onToolStart: hooks.onToolStart } : {}),
     ...(hooks.onToolSettled ? { onToolSettled: hooks.onToolSettled } : {}),
     ...(hooks.onApproval ? { onApproval: hooks.onApproval } : {}),
@@ -754,9 +800,15 @@ export async function assembleRuntimeSnapshot<
     ...(toolAssembly.bindings?.workspace
       ? { workspace: toolAssembly.bindings.workspace }
       : {}),
+    ...(toolAssembly.bindings?.codeExecution
+      ? { codeExecution: toolAssembly.bindings.codeExecution }
+      : {}),
     ...(memoryProfile.enabled && toolAssembly.bindings?.memory
       ? { memory: toolAssembly.bindings.memory }
       : {}),
+    ...(toolAssembly.bindings?.subagents
+      ? { subagents: toolAssembly.bindings.subagents }
+      : {}),
     hostTools,
     skills: resources.skills,
     connectors: resources.connectors.servers,