@springbrand/agent-runtime 0.3.0-alpha.7 → 0.3.0-alpha.9

package/src/tools/skill/index.ts

@@ -0,0 +1,99 @@
+import { SkillRegistry } from "agents/skills";
+import { aiToolToPi } from "../adapters/ai-to-pi";
+import type { PiToolCandidate } from "../runtime/contracts";
+import type { PiSkillBinding, SkillPiToolOptions } from "./contracts";
+import { catalogSkillSource, materializeSkillResourceTool, wrapSkillResourceRead } from "./resources";
+import { scriptRunner, wrapSkillScript } from "./scripts";
+
+export type { PiSkillBinding, SkillPiToolOptions } from "./contracts";
+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_TOOL_PARAMETER_DESCRIPTIONS: Readonly<Record<string, Readonly<Record<string, string>>>> = {
+  activate_skill: {
+    name: "Exact name of the available Skill to activate.",
+  },
+  read_skill_resource: {
+    name: "Name of the activated Skill. Omit only when path starts with the Skill name.",
+    path: "Bundled resource path listed by activate_skill.",
+  },
+  run_skill_script: {
+    name: "Name of the activated Skill that supplies the script.",
+    path: "Bundled script path listed by activate_skill.",
+    input: "JSON input expected by the Skill script. Defaults to an empty object.",
+  },
+};
+
+/** Create Pi candidates from the official Agents SDK SkillRegistry tools. */
+export async function skillPiToolCandidates(
+  bindings: readonly PiSkillBinding[],
+  options: SkillPiToolOptions = {},
+): Promise<PiToolCandidate[]> {
+  if (bindings.length === 0) return [];
+
+  const availableToolNames = (options.tools ?? []).map(({ tool }) => tool.name);
+
+  const registry = new SkillRegistry(
+    bindings.map((binding) => catalogSkillSource(
+      binding,
+      options.transformSkillBody,
+      availableToolNames,
+    )),
+    scriptRunner(bindings, options),
+  );
+  await registry.load();
+
+  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"
+        ? {
+          description:
+            "Read a bundled resource listed by activate_skill. Returns structured resource metadata and content. Do not pass SKILL.md; activate_skill returns the Skill instructions.",
+        }
+        : {}),
+    });
+    const properties = (adapted.parameters as { properties?: unknown }).properties;
+    if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+      for (const [parameter, description] of Object.entries(
+        SKILL_TOOL_PARAMETER_DESCRIPTIONS[name] ?? {},
+      )) {
+        const schema = (properties as Record<string, unknown>)[parameter];
+        if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+          (schema as Record<string, unknown>).description ??= description;
+        }
+      }
+    }
+    if (name === "read_skill_resource") wrapSkillResourceRead(adapted, bindings);
+    if (name === "run_skill_script") wrapSkillScript(adapted, options.workspace);
+    return {
+      owner: "runtime-skill",
+      requiredExecutionLevel: "safe",
+      // activate_skill 返回的是 Skill 指令本身,是模型接下来所有动作的依据。把它外置
+      // 成文件,模型手里就只剩一个路径,必须再取一次才能知道该做什么 —— 而典型
+      // SKILL.md 正好落在会触发外置的区间。指令必须当场到手。
+      ...(name === "activate_skill"
+        ? { outputBudget: { kind: "structure" as const } }
+        : {}),
+      ...(name === "activate_skill"
+        ? { exposureMode: "direct" as const }
+        : { exposureMode: "codemode" as const }),
+      ...(name === "activate_skill" || name === "read_skill_resource"
+        ? { retry: "idempotent" as const }
+        : {}),
+      tool: adapted,
+    };
+  });
+}

package/src/tools/skill/resources.ts

@@ -0,0 +1,322 @@
+import { type SkillResource, type SkillSource } from "agents/skills";
+import { tool } from "ai";
+import { z } from "zod";
+import type { WorkspacePort } from "../../config/ports";
+import type { RuntimeSkillBodyTransform } from "../../config/definition";
+import { STORAGE_LEAF_MAX_CHARS } from "../../context/memory/budget/gate";
+import { result } from "../runtime/result";
+import { serializeWorkspaceMutation } from "../workspace";
+import type { PiSkillBinding } from "./contracts";
+
+/**
+ * `run_skill_script` 一次挂载的 Skill 资源总量上限。
+ *
+ * 上游 SkillRegistry 在启动脚本前会把 Skill 的**全部**资源读进内存
+ * （`readSkillResources`），运行器随后还要再复制几份：files map、base64 解码后的
+ * 字节、以及内联进生成源码的那份 JSON。同一个资源包因此会在 Worker isolate 里
+ * 同时存在三到四份，按四倍放大倒推 128 MB 的 DO 内存上限，安全线落在 8 MB。
+ *
+ * 这道闸只认体积不认 Skill 名字：以后再上一个大包不需要改代码。
+ */
+const SKILL_RESOURCE_BUDGET_BYTES = 8 * 1024 * 1024;
+
+type LoadedSkill = NonNullable<Awaited<ReturnType<SkillSource["load"]>>>;
+
+const SKILL_RESOURCE_READ_GUIDANCE =
+  "Bundled Skill resources are not Workspace files. " +
+  "Inside execute, use tools.read_skill_resource for text instead of state.* on /skills.";
+
+const SKILL_RESOURCE_MATERIALIZE_GUIDANCE =
+  "Inside execute, use tools.materialize_skill_resource for Workspace assets when available.";
+
+/**
+ * 按体积裁掉超预算的 Skill 资源，并把裁掉的事实写回 Skill 正文。
+ *
+ * @remarks
+ * `catalogSkillSource` 在每次 `load` 后调用，必须在这一层拦截：上游拿到 descriptor
+ * 后会立刻把它们全读进内存，等运行器收到请求时资源已经在堆上，再判断就晚了。
+ *
+ * 裁掉的资源必须**说出来**。它们同时会从 `activate_skill` 的资源清单里消失，若不
+ * 在正文里点名，模型只会看到一个凭空少了文件的 Skill，然后去猜。
+ *
+ * 已知缺口：没有 `size` 的 descriptor 不计入预算。R2 来源的 size 来自对象列表因而
+ * 总是存在；manifest 来源可能没有，此时这道闸对那些资源不生效。宁可放过也不误杀，
+ * 因为误杀会让本来能跑的 Skill 直接坏掉。
+ */
+function budgetSkillResources(skill: LoadedSkill): LoadedSkill {
+  const resources = skill.resources ?? [];
+  const kept: typeof resources = [];
+  const dropped: { path: string; size: number }[] = [];
+  let used = 0;
+
+  for (const resource of resources) {
+    if (typeof resource.size !== "number") {
+      kept.push(resource);
+      continue;
+    }
+    if (used + resource.size > SKILL_RESOURCE_BUDGET_BYTES) {
+      dropped.push({ path: resource.path, size: resource.size });
+      continue;
+    }
+    used += resource.size;
+    kept.push(resource);
+  }
+
+  if (dropped.length === 0) return skill;
+  const budgetMb = Math.round(SKILL_RESOURCE_BUDGET_BYTES / (1024 * 1024));
+  // materialize_skill_resource 也要把整份资源读进内存(base64 字符串 → atob 副本 →
+  // Uint8Array),放大倍数和挂载路径同量级。把一个单独就超预算的文件推荐给它,只是把
+  // OOM 从脚本挪到复制那一步 —— 那种资源这一轮就是拿不到,必须直说。
+  const portable = dropped.filter((entry) => entry.size <= SKILL_RESOURCE_BUDGET_BYTES);
+  const oversized = dropped.filter((entry) => entry.size > SKILL_RESOURCE_BUDGET_BYTES);
+  const lines = [
+    `> ${dropped.length} bundled resource(s) exceed the ${budgetMb} MB ` +
+    "script-mount budget and are NOT available to run_skill_script.",
+  ];
+  if (portable.length > 0) {
+    lines.push(
+      `> If any of these resources are needed, copy all required ones into the Workspace ` +
+      `in one execute with tools.materialize_skill_resource: ` +
+      `${portable.map((entry) => entry.path).join(", ")}.`,
+    );
+  }
+  if (oversized.length > 0) {
+    lines.push(
+      `> These are individually larger than ${budgetMb} MB and cannot be loaded at ` +
+      `all in this session — do not try: ${oversized.map((entry) => entry.path).join(", ")}.`,
+    );
+  }
+  return { ...skill, resources: kept, body: `${skill.body}\n\n${lines.join("\n")}` };
+}
+
+export function catalogSkillSource(
+  binding: PiSkillBinding,
+  transformSkillBody: RuntimeSkillBodyTransform | undefined,
+  availableToolNames: readonly string[],
+): SkillSource {
+  const source = binding.source;
+  return {
+    id: source.id,
+    get fingerprint() {
+      return source.fingerprint;
+    },
+    // Runtime configuration already resolved the catalogue; Skill content stays lazy.
+    list: async () => [{
+      name: binding.name,
+      description: binding.description,
+      sourceId: source.id,
+    }],
+    load: async (name) => {
+      const skill = await source.load(name);
+      if (!skill) return null;
+      const prepared = transformSkillBody
+        ? {
+          ...skill,
+          body: transformSkillBody({
+            name: skill.name,
+            body: skill.body,
+            availableToolNames,
+          }),
+        }
+        : skill;
+      const loaded = budgetSkillResources(prepared);
+      const hasOversizedResource = skill.resources?.some((resource) =>
+        typeof resource.size === "number" &&
+        resource.size > SKILL_RESOURCE_BUDGET_BYTES
+      );
+      const guidance = hasOversizedResource
+        ? SKILL_RESOURCE_READ_GUIDANCE
+        : `${SKILL_RESOURCE_READ_GUIDANCE} ${SKILL_RESOURCE_MATERIALIZE_GUIDANCE}`;
+      return loaded.resources?.length
+        ? {
+          ...loaded,
+          body: `${loaded.body}\n\n${guidance}`,
+        }
+        : loaded;
+    },
+    ...(source.readResource
+      ? {
+        readResource: (name: string, path: string) =>
+          source.readResource!(name, path)
+      }
+      : {}),
+    ...(source.refresh ? { refresh: () => source.refresh!() } : {}),
+  };
+}
+
+const SKILL_ENTRY_READ_GUIDANCE =
+  "SKILL.md contains the Skill instructions; use activate_skill instead.";
+
+function resourceTarget(
+  bindings: readonly PiSkillBinding[],
+  input: unknown,
+): { binding: PiSkillBinding; path: string } | null {
+  if (input === null || typeof input !== "object") return null;
+  const target = input as { name?: unknown; path?: unknown };
+  if (typeof target.path !== "string") return null;
+  if (typeof target.name === "string") {
+    const binding = bindings.find(({ name }) => name === target.name);
+    return binding ? { binding, path: target.path } : null;
+  }
+  const [name, ...rest] = target.path.split("/");
+  const binding = bindings.find((candidate) => candidate.name === name);
+  return binding && rest.length > 0
+    ? { binding, path: rest.join("/") }
+    : null;
+}
+
+function materializationRequired(name: string, path: string, bytes?: number) {
+  return result({
+    status: "materialization_required",
+    name,
+    path,
+    ...(bytes === undefined ? {} : { bytes }),
+    next: "tools.materialize_skill_resource",
+  });
+}
+
+function structuredSkillResource(
+  details: string,
+  target: { binding: PiSkillBinding; path: string },
+): ReturnType<typeof result> | null {
+  const firstNewline = details.indexOf("\n");
+  const closing = "\n</skill_resource>";
+  if (
+    firstNewline < 0 ||
+    !details.startsWith("<skill_resource ") ||
+    !details.endsWith(closing)
+  ) return null;
+  const header = details.slice(0, firstNewline);
+  const attribute = (name: string) =>
+    new RegExp(`${name}="([^"]*)"`, "u").exec(header)?.[1];
+  const kind = attribute("kind");
+  const encoding = attribute("encoding");
+  if (!kind || !encoding) return null;
+  const mimeType = attribute("mimeType");
+  return result({
+    name: target.binding.name,
+    path: target.path,
+    kind,
+    encoding,
+    ...(mimeType ? { mimeType } : {}),
+    content: details.slice(firstNewline + 1, -closing.length),
+  });
+}
+
+export 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;
+}
+
+export 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 and its parent directories are created automatically; do not call state.mkdir first. " +
+      "When multiple resources are needed, copy them sequentially in one execute; never start one execute per resource. " +
+      "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 } : {}),
+      };
+    },
+  });
+}
+
+export function wrapSkillResourceRead(adapted: import("@earendil-works/pi-agent-core").AgentTool<any, unknown>, bindings: readonly PiSkillBinding[]): void {
+  const execute = adapted.execute;
+  adapted.execute = async (toolCallId, input, signal) => {
+    const target = input as { name?: unknown; path?: unknown };
+    const parts = typeof target.path === "string"
+      ? target.path.split("/")
+      : [];
+    if (
+      target.path === "SKILL.md" ||
+      (target.name === undefined &&
+        parts.length === 2 &&
+        parts[1] === "SKILL.md")
+    ) {
+      return {
+        content: [{ type: "text", text: SKILL_ENTRY_READ_GUIDANCE }],
+        details: SKILL_ENTRY_READ_GUIDANCE,
+      };
+    }
+    const resolved = resourceTarget(bindings, input);
+    if (resolved) {
+      const skill = await resolved.binding.source
+        .load(resolved.binding.name)
+        .catch(() => null);
+      const descriptor = skill?.resources?.find(({ path }) =>
+        path === resolved.path
+      );
+      if (
+        typeof descriptor?.size === "number" &&
+        descriptor.size > STORAGE_LEAF_MAX_CHARS
+      ) {
+        return materializationRequired(
+          resolved.binding.name,
+          resolved.path,
+          descriptor.size,
+        );
+      }
+    }
+    const output = await execute(toolCallId, input, signal);
+    if (
+      resolved &&
+      typeof output.details === "string" &&
+      output.details.length > STORAGE_LEAF_MAX_CHARS
+    ) {
+      return materializationRequired(
+        resolved.binding.name,
+        resolved.path,
+      );
+    }
+    if (resolved && typeof output.details === "string") {
+      const structured = structuredSkillResource(output.details, resolved);
+      if (structured) return structured;
+    }
+    return output;
+  };
+}

package/src/tools/skill/scripts.ts

@@ -0,0 +1,168 @@
+import {
+  runner as createSkillScriptRunner,
+  type SkillScriptRequest,
+  type SkillScriptRunner,
+} from "agents/skills";
+import { truncateResponse, truncateResult } from "@cloudflare/codemode";
+import type { WorkspacePort } from "../../config/ports";
+import { piCandidatesToAiTools } from "../adapters/pi-to-ai";
+import { result } from "../runtime/result";
+import { serializeWorkspaceMutation } from "../workspace";
+import type { PiSkillBinding, SkillPiToolOptions } from "./contracts";
+import { resourceBytes } from "./resources";
+
+const SKILL_SCRIPT_OUTPUT_ROOT = "/scratch/skill-output";
+
+export function scriptRunner(
+  bindings: readonly PiSkillBinding[],
+  options: SkillPiToolOptions,
+): SkillScriptRunner | null {
+  if (!options.loader || !bindings.some((binding) => binding.script)) {
+    return null;
+  }
+  const byName = new Map(bindings.map((binding) => [binding.name, binding]));
+  return {
+    async run(request: SkillScriptRequest) {
+      const policy = byName.get(request.skill.name)?.script;
+      if (!policy) {
+        throw new Error(`Skill cannot run scripts: ${request.skill.name}`);
+      }
+      const workspace = policy.workspace !== "none" && options.workspace
+        ? policy.workspace
+        : "none";
+      let toolCallOrdinal = 0;
+      const selected = (options.tools ?? []).filter(({ tool }) =>
+        policy.tools.includes(tool.name)
+      );
+      return createSkillScriptRunner({
+        loader: options.loader!,
+        network: policy.network === "full",
+        workspace,
+        ...(workspace !== "none" && options.workspace
+          ? { workspaceInstance: options.workspace }
+          : {}),
+        tools: piCandidatesToAiTools(selected, {
+          fallbackToolCallId: (name) =>
+            `skill-script:${++toolCallOrdinal}:${name}`,
+        }),
+      }).run(request);
+    },
+  };
+}
+
+function normalizeRunSkillScriptArguments(input: unknown): unknown {
+  if (input === null || typeof input !== "object") return input;
+  const value = input as Record<string, unknown>;
+  if (typeof value.input !== "string") return input;
+  try {
+    const decoded = JSON.parse(value.input);
+    return decoded !== null && typeof decoded === "object"
+      ? { ...value, input: decoded }
+      : input;
+  } catch {
+    return input;
+  }
+}
+
+type ScriptOutputFile = {
+  path?: unknown;
+  content?: unknown;
+  encoding?: unknown;
+  mimeType?: unknown;
+};
+
+function scratchSegment(value: string): string {
+  const segment = value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  return !segment || segment === "." || segment === ".." ? "_" : segment;
+}
+
+function outputRelativePath(value: unknown): string {
+  const path = String(value ?? "output.txt").replace(/^\/?output\//, "");
+  const parts = path.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) {
+    throw new Error(`Invalid Skill output path: ${path}`);
+  }
+  return parts.join("/");
+}
+
+async function projectSkillScriptResult(
+  details: unknown,
+  input: unknown,
+  toolCallId: string,
+  workspace: WorkspacePort | undefined,
+  signal: AbortSignal | undefined,
+): Promise<unknown> {
+  const record = details !== null && typeof details === "object"
+    ? details as Record<string, unknown>
+    : null;
+  const outputFiles = Array.isArray(record?.outputFiles)
+    ? record.outputFiles as ScriptOutputFile[]
+    : [];
+  const target = input as { name?: unknown };
+  const outputs: Array<{ path: string; bytes: number; mediaType?: string }> = [];
+  if (outputFiles.length > 0 && !workspace) {
+    throw new Error("Skill output files require Workspace access");
+  }
+  for (const file of outputFiles) {
+    signal?.throwIfAborted();
+    const relative = outputRelativePath(file.path);
+    const destination = `${SKILL_SCRIPT_OUTPUT_ROOT}/${scratchSegment(String(target.name ?? "skill"))}/${scratchSegment(toolCallId)}/${relative}`;
+    const content = String(file.content ?? "");
+    const binary = file.encoding === "base64";
+    const mediaType = typeof file.mimeType === "string"
+      ? file.mimeType
+      : binary ? "application/octet-stream" : "text/plain";
+    let bytes = new Blob([content]).size;
+    await serializeWorkspaceMutation(workspace!, destination, async () => {
+      const parent = destination.replace(/\/[^/]+$/, "");
+      await workspace!.mkdir(parent, { recursive: true });
+      if (!binary) {
+        await workspace!.writeFile(destination, content, mediaType);
+        return;
+      }
+      const decoded = resourceBytes({
+        path: relative,
+        kind: "file",
+        encoding: "base64",
+        content,
+      });
+      bytes = decoded.byteLength;
+      await workspace!.writeFileBytes(destination, decoded, mediaType);
+    });
+    outputs.push({ path: destination, bytes, mediaType });
+  }
+  const scriptResult = record && "result" in record
+    ? record.result
+    : record && ("outputFiles" in record || "logs" in record)
+      ? Object.fromEntries(Object.entries(record).filter(([key]) =>
+        key !== "outputFiles" && key !== "logs"
+      ))
+      : details;
+  const logs = Array.isArray(record?.logs)
+    ? record.logs.map(String)
+    : [];
+  return {
+    result: truncateResult(scriptResult),
+    ...(logs.length > 0
+      ? { logs: [truncateResponse(logs.join("\n"))] }
+      : {}),
+    ...(outputs.length > 0 ? { outputs } : {}),
+  };
+}
+
+export function wrapSkillScript(adapted: import("@earendil-works/pi-agent-core").AgentTool<any, unknown>, workspace: WorkspacePort | undefined): void {
+  adapted.description +=
+    " Large artifacts must be written directly to Workspace, not returned or logged; scratch outputs are materialized to Workspace and returned only as file references.";
+  adapted.prepareArguments = normalizeRunSkillScriptArguments;
+  const execute = adapted.execute;
+  adapted.execute = async (toolCallId, input, signal) => {
+    const output = await execute(toolCallId, input, signal);
+    return result(await projectSkillScriptResult(
+      output.details,
+      input,
+      toolCallId,
+      workspace,
+      signal,
+    ));
+  };
+}

package/src/tools/{subagent-authority.ts → subagent/authority.ts}

@@ -47,10 +47,10 @@ export interface RuntimeSubmissionAdmissionInput {
 export type RuntimeSubmissionAdmissionResult =
   | { readonly accepted: true }
   | {
-      readonly accepted: false;
-      readonly code: string;
-      readonly retryable?: boolean;
-    };
+    readonly accepted: false;
+    readonly code: string;
+    readonly retryable?: boolean;
+  };
 
 export type RuntimeSubmissionAdmissionHook = (
   input: RuntimeSubmissionAdmissionInput,
@@ -58,36 +58,36 @@ export type RuntimeSubmissionAdmissionHook = (
 
 export type RuntimeLifecycleFact =
   | {
-      readonly kind: "submission-admitted";
-      readonly eventId: string;
-      readonly submissionId: string;
-      readonly runId: string;
-    }
+    readonly kind: "submission-admitted";
+    readonly eventId: string;
+    readonly submissionId: string;
+    readonly runId: string;
+  }
   | {
-      readonly kind: "submission-terminal";
-      readonly eventId: string;
-      readonly submissionId: string;
-      readonly runId: string;
-      readonly status: "completed" | "aborted" | "skipped" | "error";
-      readonly childRegistrationClosed: true;
-      readonly zeroUsage: boolean;
-    }
+    readonly kind: "submission-terminal";
+    readonly eventId: string;
+    readonly submissionId: string;
+    readonly runId: string;
+    readonly status: "completed" | "aborted" | "skipped" | "error";
+    readonly childRegistrationClosed: true;
+    readonly zeroUsage: boolean;
+  }
   | {
-      readonly kind: "subagent-run-registered";
-      readonly eventId: string;
-      readonly submissionId: string;
-      readonly subagentRunId: string;
-      readonly parentRunId: string;
-    }
+    readonly kind: "subagent-run-registered";
+    readonly eventId: string;
+    readonly submissionId: string;
+    readonly subagentRunId: string;
+    readonly parentRunId: string;
+  }
   | {
-      readonly kind: "subagent-terminal";
-      readonly eventId: string;
-      readonly submissionId: string;
-      readonly subagentRunId: string;
-      readonly parentRunId: string;
-      readonly status: "completed" | "failed" | "aborted" | "skipped";
-      readonly zeroUsage: boolean;
-    };
+    readonly kind: "subagent-terminal";
+    readonly eventId: string;
+    readonly submissionId: string;
+    readonly subagentRunId: string;
+    readonly parentRunId: string;
+    readonly status: "completed" | "failed" | "aborted" | "skipped";
+    readonly zeroUsage: boolean;
+  };
 
 export interface RuntimeEventConfirmation {
   readonly confirmed: true;