@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/extension/acceptance-schema.ts

@@ -1,88 +0,0 @@
-import { Type } from "../shared/native-typebox.ts";
-
-const AcceptanceEvidenceKind = Type.Enum(
-  [
-    "changed-files",
-    "tests-added",
-    "commands-run",
-    "validation-output",
-    "residual-risks",
-    "no-staged-files",
-    "diff-summary",
-    "review-findings",
-    "manual-notes",
-  ] as const,
-  { type: "string" },
-);
-
-const AcceptanceGateSchema = Type.Object(
-  {
-    id: Type.String({ minLength: 1 }),
-    must: Type.String({ minLength: 1 }),
-    evidence: Type.Optional(Type.Array(AcceptanceEvidenceKind)),
-    severity: Type.Optional(Type.Enum(["required", "recommended"] as const, { type: "string" })),
-  },
-  { additionalProperties: false },
-);
-
-const AcceptanceVerifyCommandSchema = Type.Object(
-  {
-    id: Type.String({ minLength: 1 }),
-    command: Type.String({ minLength: 1 }),
-    timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-    cwd: Type.Optional(Type.String()),
-    env: Type.Optional(Type.Unsafe({ type: "object", additionalProperties: { type: "string" } })),
-    allowFailure: Type.Optional(Type.Boolean()),
-  },
-  { additionalProperties: false },
-);
-
-export const AcceptanceOverride = Type.Unsafe({
-  type: "object",
-  properties: {
-    criteria: {
-      type: "array",
-      items: { anyOf: [{ type: "string", minLength: 1 }, AcceptanceGateSchema] },
-    },
-    evidence: { type: "array", items: AcceptanceEvidenceKind },
-    verify: { type: "array", items: AcceptanceVerifyCommandSchema },
-    stopRules: { type: "array", items: { type: "string", minLength: 1 } },
-    maxFinalizationTurns: { type: "integer", minimum: 1, maximum: 10 },
-  },
-  additionalProperties: false,
-  description:
-    "Optional acceptance contract. criteria=definition of done, evidence/verify=proof, stopRules=constraints, maxFinalizationTurns=self-review budget; at least one required. no-staged-files requires the entire Git index to be empty, including pre-existing staged paths. Continue/resume/answer overrides apply only to newly started continuations, never to a live child's acceptance. See the pi-subagents skill.",
-});
-
-// The everyday tools use closed acceptance shapes. Advanced callers retain the full contract.
-export const DelegateAcceptance = Type.Object(
-  {
-    criteria: Type.Optional(Type.Array(AcceptanceGateSchema)),
-    evidence: Type.Optional(Type.Array(AcceptanceEvidenceKind)),
-    verify: Type.Optional(
-      Type.Array(
-        Type.Object(
-          {
-            ...AcceptanceVerifyCommandSchema.properties,
-            env: Type.Optional(
-              Type.Array(
-                Type.Object(
-                  { name: Type.String({ minLength: 1 }), value: Type.String() },
-                  { additionalProperties: false },
-                ),
-              ),
-            ),
-          },
-          { additionalProperties: false },
-        ),
-      ),
-    ),
-    stopRules: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    maxFinalizationTurns: Type.Optional(Type.Integer({ minimum: 1, maximum: 10 })),
-  },
-  {
-    additionalProperties: false,
-    description:
-      "Acceptance criteria, evidence, verification commands and stop rules. Criteria use objects; verification environment uses unique name/value pairs. Self-review budget: 1–10 turns.",
-  },
-);

package/src/extension/build-info.ts

@@ -1,2 +0,0 @@
-// Replaced with literal provenance in the compiled artifact by scripts/build.mjs.
-export const EXTENSION_BUILD: Readonly<{ version?: string; sha256?: string }> = Object.freeze({});

package/src/extension/chain-schema.ts

@@ -1,276 +0,0 @@
-import { Type } from "../shared/native-typebox.ts";
-import { AcceptanceOverride } from "./acceptance-schema.ts";
-import {
-  JsonSchemaObject,
-  ModelOverride,
-  OutputModeOverride,
-  OutputOverride,
-  ReadsOverride,
-  SkillOverride,
-  requiredObject,
-} from "./schema-overrides.ts";
-
-const ParallelTaskSchema = Type.Object(
-  {
-    agent: Type.String({ minLength: 1 }),
-    task: Type.Optional(
-      Type.String({
-        minLength: 1,
-        description:
-          "Task template with {task}, {previous}, {chain_dir} variables. Defaults to {previous}.",
-      }),
-    ),
-    phase: Type.Optional(
-      Type.String({ description: "Phase/group label for status and graph rendering." }),
-    ),
-    label: Type.Optional(Type.String({ description: "User-facing label for this parallel task." })),
-    as: Type.Optional(
-      Type.String({ description: "Safe identifier used as {outputs.name} in later chain steps." }),
-    ),
-    outputSchema: Type.Optional(JsonSchemaObject),
-    cwd: Type.Optional(Type.String()),
-    count: Type.Optional(
-      Type.Integer({ minimum: 1, description: "Repeat this parallel task N times." }),
-    ),
-    output: Type.Optional(OutputOverride),
-    outputMode: Type.Optional(OutputModeOverride),
-    reads: Type.Optional(ReadsOverride),
-    progress: Type.Optional(
-      Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" }),
-    ),
-    skill: Type.Optional(SkillOverride),
-    model: ModelOverride,
-    acceptance: Type.Optional(AcceptanceOverride),
-  },
-  { additionalProperties: false },
-);
-
-const DynamicExpandSchema = Type.Object(
-  {
-    from: Type.Object(
-      {
-        output: Type.String({ description: "Prior named structured output to expand from." }),
-        path: Type.String({ description: "JSON Pointer into the structured output, e.g. /items." }),
-      },
-      { additionalProperties: false },
-    ),
-    item: Type.Optional(
-      Type.String({ description: "Template variable name for each item. Defaults to item." }),
-    ),
-    key: Type.Optional(
-      Type.String({ description: "JSON Pointer relative to each item for stable child ids." }),
-    ),
-    maxItems: Type.Optional(
-      Type.Integer({
-        minimum: 0,
-        description: "Required fanout bound unless configured globally.",
-      }),
-    ),
-    onEmpty: Type.Optional(
-      Type.Enum(["skip", "fail"] as const, {
-        type: "string",
-        description: "Empty input behavior. Defaults to skip.",
-      }),
-    ),
-  },
-  { additionalProperties: false },
-);
-
-const DynamicParallelTemplateSchema = Type.Object(
-  {
-    agent: Type.String({ minLength: 1 }),
-    task: Type.Optional(
-      Type.String({
-        minLength: 1,
-        description:
-          "Task template with {item}, {item.path}, {task}, {previous}, {chain_dir}, {outputs.name} variables.",
-      }),
-    ),
-    phase: Type.Optional(
-      Type.String({ description: "Phase/group label for status and graph rendering." }),
-    ),
-    label: Type.Optional(
-      Type.String({ description: "User-facing label; item templates supported." }),
-    ),
-    outputSchema: Type.Optional(JsonSchemaObject),
-    cwd: Type.Optional(Type.String()),
-    output: Type.Optional(OutputOverride),
-    outputMode: Type.Optional(OutputModeOverride),
-    reads: Type.Optional(ReadsOverride),
-    progress: Type.Optional(
-      Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" }),
-    ),
-    skill: Type.Optional(SkillOverride),
-    model: ModelOverride,
-    acceptance: Type.Optional(AcceptanceOverride),
-  },
-  { additionalProperties: false },
-);
-
-const DynamicCollectSchema = Type.Object(
-  {
-    as: Type.String({ description: "Safe output name for the ordered collected result array." }),
-    outputSchema: Type.Optional(JsonSchemaObject),
-  },
-  { additionalProperties: false },
-);
-
-// Flattened so chain steps do not need an object-shape anyOf/oneOf union.
-export const ChainItemSchema = Type.Object(
-  {
-    agent: Type.Optional(Type.String({ minLength: 1, description: "Sequential step agent name" })),
-    task: Type.Optional(
-      Type.String({
-        minLength: 1,
-        description:
-          "Task template: {task}=original request, {previous}=prior step response, {chain_dir}=shared folder, {outputs.name}=prior named output. Required for first step; defaults to '{previous}'.",
-      }),
-    ),
-    phase: Type.Optional(
-      Type.String({ description: "Phase/group label for status and graph rendering." }),
-    ),
-    label: Type.Optional(Type.String({ description: "User-facing label for this chain step." })),
-    as: Type.Optional(
-      Type.String({ description: "Safe identifier used as {outputs.name} in later chain steps." }),
-    ),
-    outputSchema: Type.Optional(JsonSchemaObject),
-    cwd: Type.Optional(Type.String()),
-    output: Type.Optional(OutputOverride),
-    outputMode: Type.Optional(OutputModeOverride),
-    reads: Type.Optional(ReadsOverride),
-    progress: Type.Optional(
-      Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" }),
-    ),
-    skill: Type.Optional(SkillOverride),
-    model: ModelOverride,
-    acceptance: Type.Optional(AcceptanceOverride),
-    parallel: Type.Optional(
-      Type.Unsafe({
-        anyOf: [
-          Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" }),
-          DynamicParallelTemplateSchema,
-        ],
-        description:
-          "Static parallel tasks array, or a single dynamic fanout child template when expand/collect are present.",
-      }),
-    ),
-    expand: Type.Optional(DynamicExpandSchema),
-    collect: Type.Optional(DynamicCollectSchema),
-    concurrency: Type.Optional(
-      Type.Integer({ minimum: 1, description: "Max concurrent tasks (default: 4)" }),
-    ),
-    failFast: Type.Optional(
-      Type.Boolean({ description: "Stop on first failure (default: false)" }),
-    ),
-    worktree: Type.Optional(
-      Type.Boolean({ description: "Create isolated git worktrees for each parallel task." }),
-    ),
-  },
-  {
-    description:
-      "Chain step: {agent, task?} sequential, {parallel: [...]} concurrent, or {expand, parallel: {...}, collect} dynamic fanout.",
-    additionalProperties: false,
-    allOf: [
-      { anyOf: [requiredObject("agent"), requiredObject("parallel")] },
-      {
-        not: {
-          anyOf: [
-            requiredObject("agent", "parallel"),
-            { ...requiredObject("expand"), properties: { parallel: { type: "array", items: {} } } },
-          ],
-        },
-      },
-      {
-        if: requiredObject("expand"),
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: {
-          ...requiredObject("parallel", "collect"),
-          properties: { parallel: { type: "object" } },
-        },
-      },
-      {
-        if: requiredObject("collect"),
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: {
-          ...requiredObject("expand", "parallel"),
-          properties: { parallel: { type: "object" } },
-        },
-      },
-      {
-        if: { ...requiredObject("parallel"), properties: { parallel: { type: "object" } } },
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: requiredObject("expand", "collect"),
-      },
-      {
-        if: requiredObject("agent"),
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: {
-          not: {
-            anyOf: [
-              requiredObject("concurrency"),
-              requiredObject("failFast"),
-              requiredObject("worktree"),
-            ],
-          },
-        },
-      },
-      {
-        if: {
-          ...requiredObject("parallel"),
-          properties: { parallel: { type: "array", items: {} } },
-        },
-
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: {
-          not: {
-            anyOf: [
-              requiredObject("task"),
-              requiredObject("phase"),
-              requiredObject("label"),
-              requiredObject("as"),
-              requiredObject("outputSchema"),
-              requiredObject("output"),
-              requiredObject("outputMode"),
-              requiredObject("reads"),
-              requiredObject("progress"),
-              requiredObject("skill"),
-              requiredObject("model"),
-              requiredObject("acceptance"),
-              requiredObject("expand"),
-              requiredObject("collect"),
-            ],
-          },
-        },
-      },
-      {
-        if: { ...requiredObject("parallel"), properties: { parallel: { type: "object" } } },
-
-        // JSON Schema's non-callable consequence keyword is not a Promise method.
-        // oxlint-disable-next-line unicorn/no-thenable
-        then: {
-          not: {
-            anyOf: [
-              requiredObject("task"),
-              requiredObject("as"),
-              requiredObject("outputSchema"),
-              requiredObject("cwd"),
-              requiredObject("output"),
-              requiredObject("outputMode"),
-              requiredObject("reads"),
-              requiredObject("progress"),
-              requiredObject("skill"),
-              requiredObject("model"),
-              requiredObject("acceptance"),
-              requiredObject("worktree"),
-            ],
-          },
-        },
-      },
-    ],
-  },
-);

package/src/extension/child-runtime.ts

@@ -1,302 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
-import { discoverAgents } from "../agents/agents.ts";
-import { getArtifactsDir } from "../shared/artifacts.ts";
-import {
-  createSubagentExecutor,
-  normalizeSubagentParamsLike,
-} from "../runs/foreground/subagent-executor.ts";
-import { interruptAsyncRun } from "../runs/foreground/foreground-control.ts";
-import {
-  SUBAGENT_EAGER_TOOL_ENV,
-  SUBAGENT_PARENT_CHILD_INDEX_ENV,
-} from "../runs/shared/pi-args.ts";
-import {
-  resolveNestedRouteFromEnv,
-  type NestedControlRequestRecord,
-} from "../runs/shared/nested-events.ts";
-import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.ts";
-import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.ts";
-import { readStatus } from "../shared/utils.ts";
-import { SubagentParams } from "./schemas.ts";
-import { loadConfig } from "./config.ts";
-import { registerCompactSubagentTools } from "./compact-tools.ts";
-import { adaptFinalizedToolResult, registerToolResultAdapter } from "./tool-result.ts";
-import { renderSubagentResult } from "../tui/render.ts";
-import type { AsyncStatus, ReadonlyDetails } from "../shared/types.ts";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import { registerParentUsage } from "../runs/shared/parent-usage.ts";
-import { resolveCurrentSessionId } from "../shared/session-identity.ts";
-import { ownedRunList, restoreOwnedRunsAsync } from "../runs/shared/run-records.ts";
-import { closeRunHistory, runHistoryIndex, startRunHistory } from "../runs/shared/history-index.ts";
-import { createCompletionDelivery } from "../runs/background/completion-delivery.ts";
-import { createRuntimeState, expandTilde, getSubagentSessionRoot } from "./runtime-storage.ts";
-import { NestedControlInbox } from "./nested-control-inbox.ts";
-import { removeSharedRuntimeValue, setSharedRuntimeValue } from "./runtime-reload.ts";
-
-export const CHILD_CLEANUP_KEY = "__piSubagentFanoutChildControlInboxCleanup";
-const acceptanceGuidelines = [
-  "For goal-style requests such as /goal, goal, active goal, or work until evidence says done, use explicit acceptance on the delegated run: criteria for the target, evidence/verify for proof, stopRules for constraints, and maxFinalizationTurns for the bounded loop.",
-  "For implementation handoffs from a plan, PRD, spec, issue, or broad fix, put implementation instructions and plan paths in task, and put the definition of done, evidence, verification commands, constraints, and loop cap in acceptance.",
-];
-
-/** Owns the fanout child's session, completion delivery and inbox resources. */
-export class FanoutChildRuntime {
-  private readonly config = loadConfig();
-  private readonly state;
-  private readonly parentUsage;
-  private readonly completionDelivery;
-  private readonly adaptToolResult;
-  private readonly executor;
-  private readonly compact = this.config.compactChildTools !== false;
-  private sessionReset: Promise<void> | undefined;
-  private inbox: NestedControlInbox | undefined;
-  private readonly checks = new Set<Promise<void>>();
-  private readonly cleanup = (): Promise<void> => this.shutdown();
-
-  private readonly pi: ExtensionAPI;
-
-  constructor(pi: ExtensionAPI) {
-    this.pi = pi;
-    this.state = createRuntimeState(pi);
-    const toolNames = this.compact ? ["subagent", "delegate", "agent_runs"] : ["subagent"];
-    this.parentUsage = registerParentUsage(pi, toolNames);
-    this.completionDelivery = createCompletionDelivery(pi, this.state, this.parentUsage);
-    this.adaptToolResult = registerToolResultAdapter(pi, toolNames);
-    this.executor = createSubagentExecutor({
-      pi,
-      state: this.state,
-      config: this.config,
-      asyncByDefault: this.config.asyncByDefault === true,
-      tempArtifactsDir: getArtifactsDir(null),
-      getSubagentSessionRoot,
-      expandTilde,
-      discoverAgents,
-      allowMutatingManagementActions: false,
-      ensureSessionState: (ctx) => this.ensureSessionState(ctx),
-    });
-  }
-
-  private ensureSessionState(ctx: ExtensionContext): Promise<void> {
-    const sessionId = resolveCurrentSessionId(ctx.sessionManager);
-    if (this.sessionReset) {
-      return this.sessionReset;
-    }
-    if (this.state.currentSessionId === sessionId) {
-      this.state.lastUiContext = ctx;
-      return Promise.resolve();
-    }
-    this.sessionReset = this.resetSession(ctx, sessionId).finally(() => {
-      this.sessionReset = undefined;
-    });
-    return this.sessionReset;
-  }
-
-  private async resetSession(ctx: ExtensionContext, sessionId: string | null): Promise<void> {
-    await this.completionDelivery.stopAndJoin();
-    await closeRunHistory(this.state);
-    this.state.lastUiContext = ctx;
-    this.state.foregroundRuns?.clear();
-    await restoreOwnedRunsAsync(this.state, ctx);
-    this.state.currentSessionId = sessionId;
-    startRunHistory(this.state, ctx);
-    this.completionDelivery.start();
-  }
-
-  private guidelines(): string[] {
-    return [
-      "Delegate useful helper work within your assigned task when it saves time or improves quality; the original parent owns integration and final delivery.",
-      "Nested execution defaults to foreground unless configuration explicitly opts into async. Set async:false whenever the nested result must appear in this child's report; use async:true only for intentionally detached work.",
-      this.compact
-        ? "Use load_subagent({advanced:false}), then agent_runs({action:'profiles'}) before delegation unless the executable agent is already known. Use load_subagent for advanced workflows."
-        : "Use subagent action:list before nested execution unless the executable nested agent is already known from the task context.",
-      "Do not use subagent child-safe mode for agent config mutation actions; create, update, and delete are blocked here.",
-    ];
-  }
-
-  private registerTools(): void {
-    if (this.compact) {
-      const checkRuns = registerCompactSubagentTools(this.pi, {
-        executor: this.executor,
-        state: this.state,
-        getHistoryIndex: () => runHistoryIndex(this.state),
-        adapt: (result, ctx) =>
-          adaptFinalizedToolResult(result, ctx, this.parentUsage, this.adaptToolResult),
-        guidelines: [...this.guidelines(), ...acceptanceGuidelines],
-        childSafe: true,
-        asyncByDefault: this.config.asyncByDefault === true,
-        keepAdvancedActive: process.env[SUBAGENT_EAGER_TOOL_ENV] === "1",
-        listRuns: async (params, ctx) => {
-          await this.ensureSessionState(ctx);
-          return ownedRunList(this.state, params);
-        },
-      });
-      this.state.onRunsChanged = () => this.trackCheck(checkRuns());
-    }
-    const tool: ToolDefinition<typeof SubagentParams, ReadonlyDetails> = {
-      name: "subagent",
-      defaultActive: !this.compact,
-      label: "Subagent",
-      description: [
-        "Delegate to subagents from child-safe fanout mode.",
-        ...acceptanceGuidelines,
-        "Allowed management/control actions: list, get, status, history, search, nudge, interrupt, extend, resume, questions, answer, review, doctor. History/search browse only directly owned saved work; bounded previews and index freshness are not canonical proof. Exact status is concise; full:true includes the full task/configuration. Review notes are parent-only, not sent to children. Put actionable instructions in resume/nudge. Resume/answer overrides do not amend live acceptance.",
-        "Agent config mutation actions create, update, and delete are blocked in this mode.",
-      ].join("\n"),
-      promptSnippet:
-        "Delegate nested child-safe subagent work from an explicitly allowed fanout child.",
-      promptGuidelines: this.guidelines(),
-      parameters: SubagentParams,
-      execute: async (id, params, signal, onUpdate, ctx) =>
-        adaptFinalizedToolResult(
-          await this.executor.execute({
-            toolCallId: id,
-            params: normalizeSubagentParamsLike(params),
-            signal,
-            onUpdate,
-            ctx,
-          }),
-          ctx,
-          this.parentUsage,
-          this.adaptToolResult,
-        ),
-      renderResult: renderSubagentResult,
-    };
-    this.pi.registerTool(tool);
-  }
-
-  private trackCheck(pending: Promise<void>): void {
-    this.checks.add(pending);
-    pending
-      .finally(() => {
-        this.checks.delete(pending);
-      })
-      .catch((error: unknown) => {
-        console.error("Could not reconcile nested subagent controls:", error);
-      });
-  }
-
-  private async executeControl(
-    request: ReadonlyInput<NestedControlRequestRecord>,
-  ): Promise<{ readonly ok: boolean; readonly message: string }> {
-    const asyncDir =
-      this.state.ownedRuns?.get(request.targetRunId)?.asyncDir ??
-      this.state.asyncJobs.get(request.targetRunId)?.asyncDir;
-    const status = asyncDir !== undefined && asyncDir.length > 0 ? readStatus(asyncDir) : null;
-    if (!status || status.state !== "running") {
-      return {
-        ok: false,
-        message: `Nested run ${request.targetRunId} is not active in this fanout child.`,
-      };
-    }
-    return request.action === "interrupt"
-      ? this.interruptControl(request)
-      : this.resumeControl(request, status);
-  }
-
-  private interruptControl(request: ReadonlyInput<NestedControlRequestRecord>): {
-    readonly ok: boolean;
-    readonly message: string;
-  } {
-    const receipt = interruptAsyncRun(this.state, request.targetRunId, request.index);
-    return {
-      ok: receipt !== null && receipt.isError !== true,
-      message:
-        receipt?.content.map((part) => (part.type === "text" ? part.text : "")).join("\n") ??
-        "Nested run is not interruptible.",
-    };
-  }
-
-  private async resumeControl(
-    request: ReadonlyInput<NestedControlRequestRecord>,
-    status: ReadonlyInput<AsyncStatus>,
-  ): Promise<{ readonly ok: boolean; readonly message: string }> {
-    const message = request.message?.trim() ?? "";
-    if (message.length === 0) {
-      return { ok: false, message: "Nested resume requires message." };
-    }
-    const { index, agent } = this.activeMessageRoute(request.index, status);
-    if (agent === undefined || agent.length === 0) {
-      return {
-        ok: false,
-        message: `Nested run ${request.targetRunId} has no active child message route.`,
-      };
-    }
-    return this.deliverFollowUp(request.targetRunId, agent, index, message);
-  }
-
-  private activeMessageRoute(
-    requestedIndex: number | undefined,
-    status: ReadonlyInput<AsyncStatus>,
-  ): { readonly index: number; readonly agent?: string } {
-    const index =
-      requestedIndex ?? status.steps?.findIndex((step) => step.status === "running") ?? -1;
-    const step = status.steps?.[index];
-    return { index, agent: step?.status === "running" ? step.agent : undefined };
-  }
-
-  private async deliverFollowUp(
-    runId: string,
-    agent: string,
-    index: number,
-    message: string,
-  ): Promise<{ readonly ok: boolean; readonly message: string }> {
-    const target = resolveSubagentIntercomTarget(runId, agent, index);
-    const ok = await deliverSubagentIntercomMessageEvent(
-      this.pi.events,
-      target,
-      `Follow-up for nested run ${runId} (${agent}):\n\n${message}`,
-      500,
-      { source: "nested-resume", runId, agent, index },
-    );
-    return {
-      ok,
-      message: ok
-        ? `Delivered follow-up to live nested run ${runId}.`
-        : `Nested child intercom target is not registered: ${target}`,
-    };
-  }
-
-  private startInbox(): void {
-    let route;
-    try {
-      route = resolveNestedRouteFromEnv();
-    } catch {
-      return;
-    }
-    if (!route) {
-      return;
-    }
-    const parsed = Number(process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV]);
-    this.inbox = new NestedControlInbox({
-      route,
-      childIndex: Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined,
-      restoring: () => this.sessionReset !== undefined,
-      owns: (id) => this.state.ownedRuns?.has(id) === true || this.state.asyncJobs.has(id),
-      execute: (request) => this.executeControl(request),
-    });
-  }
-
-  register(): void {
-    this.pi.on("session_start", async (_event, ctx) => {
-      await this.ensureSessionState(ctx);
-    });
-    this.registerTools();
-    this.startInbox();
-    setSharedRuntimeValue(CHILD_CLEANUP_KEY, this.cleanup);
-    this.pi.on("session_shutdown", () => this.shutdown());
-  }
-
-  private async shutdown(): Promise<void> {
-    this.inbox?.stop();
-    await this.sessionReset;
-    await this.inbox?.stopAndJoin();
-    await this.completionDelivery.stopAndJoin({ preservePending: true });
-    await Promise.all(this.checks);
-    await closeRunHistory(this.state);
-    removeSharedRuntimeValue(CHILD_CLEANUP_KEY, this.cleanup);
-  }
-}