@narumitw/pi-subagents 2.1.4 → 3.0.0

package/dist/chunks/chunk-2LMJU25E.ts

@@ -1,1641 +0,0 @@
-// @generated by scripts/build-runtime.mjs; do not edit.
-// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
-import {
-  grammarSafeToolObject
-} from "./chunk-TZ34IQ3M.ts";
-import {
-  MAX_SPAWN_IDEMPOTENCY_KEY_LENGTH,
-  assertSpawnIdempotencyKey
-} from "./chunk-ILEQ27AL.ts";
-import {
-  assertCurrentSpawn,
-  waitForOwnedSpawn
-} from "./chunk-P7OH4XMF.ts";
-import {
-  MAX_TASK_NAME_LENGTH
-} from "./chunk-N7BLVXKK.ts";
-import {
-  MAX_SUBAGENT_TOOL_CALLS,
-  MAX_SUBAGENT_TURNS
-} from "./chunk-ONDTY4EL.ts";
-import {
-  confirmProjectAgent
-} from "./chunk-TM2R67J3.ts";
-import {
-  SUBAGENT_RESULT_FORMATS
-} from "./chunk-RSUXZD6S.ts";
-import {
-  DEFAULT_DELEGATION_CWD_POLICY,
-  readSubagentSettings
-} from "./chunk-TMZRHIIK.ts";
-import {
-  resolveStatefulLimits
-} from "./chunk-VDG7LTYE.ts";
-import {
-  THINKING_LEVELS,
-  isThinkingLevel
-} from "./chunk-4AQSF7AS.ts";
-import {
-  COLLAPSED_LIST_LIMIT,
-  expansionHint,
-  recordList,
-  recordValue,
-  renderFallbackResult,
-  safeBlock,
-  safeLine,
-  statusBadge,
-  stringValue,
-  textResult,
-  toolHeader
-} from "./chunk-BFK2Z4ZF.ts";
-import {
-  CompletionRequirementModeSchema,
-  completionRequirementsFromBranch
-} from "./chunk-NLT67IZS.ts";
-import {
-  DelegationContractSchema
-} from "./chunk-JSZIP73U.ts";
-import {
-  DEFAULT_MAX_CONTEXT_BYTES,
-  MAX_SUBAGENT_TIMEOUT_MS,
-  MAX_TOOL_MESSAGE_BYTES,
-  truncateUtf8
-} from "./chunk-H3FP6DLR.ts";
-
-// src/stateful-agent-view.ts
-function formatStatefulAgentLine(agent, now = Date.now()) {
-  const elapsedSeconds = Math.max(0, Math.floor((now - agent.updatedAt) / 1e3));
-  const task = agent.currentTask ? ` \u2014 ${sanitizeStatusLine(agent.currentTask, 80)}` : "";
-  const unread = agent.mailbox.filter((message) => !message.readAt).length;
-  const indent = "  ".repeat(agent.depth);
-  return `${indent}${sanitizeStatusLine(agent.taskPath ?? agent.id, 256)} \xB7 ${sanitizeStatusLine(agent.agent, 128)} \xB7 ${agentStateLabel(agent.state)} \xB7 updated ${elapsedSeconds}s ago \xB7 ${unread} unread${task}`;
-}
-function summarizeStatefulAgent(agent) {
-  return {
-    id: agent.id,
-    taskName: agent.taskName,
-    taskPath: agent.taskPath,
-    agent: agent.agent,
-    parentId: agent.parentId,
-    rootId: agent.rootId,
-    depth: agent.depth,
-    children: [...agent.children],
-    state: agent.state,
-    createdAt: agent.createdAt,
-    updatedAt: agent.updatedAt,
-    cwd: agent.cwd,
-    workspaceMode: agent.workspaceMode ?? "shared",
-    thinkingLevel: agent.thinkingLevel,
-    timeoutMs: agent.timeoutMs,
-    currentTimeoutMs: agent.currentTimeoutMs,
-    idleTimeoutMs: agent.idleTimeoutMs,
-    currentIdleTimeoutMs: agent.currentIdleTimeoutMs,
-    maxTurns: agent.maxTurns,
-    currentMaxTurns: agent.currentMaxTurns,
-    maxToolCalls: agent.maxToolCalls,
-    currentMaxToolCalls: agent.currentMaxToolCalls,
-    currentTask: agent.currentTask ? truncateUtf8(agent.currentTask, MAX_TOOL_MESSAGE_BYTES).text : void 0,
-    historyCount: agent.history.length,
-    unreadMessages: agent.mailbox.filter((message) => !message.readAt).length,
-    context: {
-      turns: agent.contextTurns ?? 0,
-      sources: agent.contextSourceIds?.length ?? 0,
-      bytes: agent.contextBytes ?? 0,
-      truncated: agent.contextTruncated === true
-    },
-    resultFormat: agent.resultFormat ?? "text",
-    completionRequirements: (agent.completionRequirements ?? []).map((record) => ({
-      ...record
-    })),
-    structuredResult: agent.structuredResult,
-    termination: agent.termination,
-    outcome: agent.outcome,
-    executionPlan: agent.executionPlan,
-    capabilityGrant: agent.capabilityGrant,
-    semanticCompatibility: agent.semanticCompatibility,
-    semanticSnapshotDigest: agent.semanticSnapshot?.digest,
-    telemetry: agent.telemetry,
-    error: agent.error ? truncateUtf8(agent.error, MAX_TOOL_MESSAGE_BYTES).text : void 0,
-    target: agent.target,
-    policy: agent.policy
-  };
-}
-function agentStateLabel(state) {
-  switch (state) {
-    case "running":
-      return "working";
-    case "completed":
-      return "finished";
-    default:
-      return state;
-  }
-}
-function sanitizeStatusLine(value, maxLength) {
-  return value.slice(0, maxLength).replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\s+/gu, " ").trim();
-}
-
-// src/stateful-config.ts
-function resolveStatefulTransportKind(value) {
-  return value ?? "subprocess";
-}
-function resolveCompletionDelivery(value) {
-  return value ?? "next-turn";
-}
-
-// src/stateful-registration.ts
-import { randomUUID } from "node:crypto";
-import { StringEnum as StringEnum2 } from "@earendil-works/pi-ai";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type as Type2 } from "typebox";
-
-// src/stateful-guidance.ts
-function createSpawnPromptGuidelines(blockingEnabled = true) {
-  return [
-    "Do not use subagent_spawn for simple or critical-path work that the main agent can perform directly. The main agent retains overall planning, immediate critical-path work, integration, final verification, and the final answer.",
-    "Before one ordinary subagent_spawn, identify concrete useful non-overlapping main-agent work you can start immediately and a supported completion integration path. If none exists, perform the task directly instead of calling subagent_spawn.",
-    "Give subagent_spawn a concise unique taskName using lowercase letters, digits, and underscores so the retained agent has a stable canonical task path.",
-    "Set subagent_spawn thinkingLevel to the lowest sufficient thinking level for the delegated task: use off or minimal for extraction, formatting, or mechanical work; low for straightforward bounded work; medium for ordinary multi-step research or implementation; high for complex debugging, design, review, or cross-file analysis; xhigh for highly ambiguous, cross-system, or high-risk analysis; and max only for the hardest tasks when quality clearly outweighs latency and cost. Omit subagent_spawn thinkingLevel only to preserve the agent or child default.",
-    "Set subagent_spawn timeoutMs to the shortest realistic work deadline for the task difficulty; use idleTimeoutMs for stalled work and maxTurns or maxToolCalls to stop repeated work without progress. Scope the task to the smallest named files or questions. When setting subagent_spawn maxTurns or maxToolCalls, leave sufficient headroom for discovery, evidence reads, and final synthesis; otherwise omit them instead of guessing speculative tight values. Split oversized tasks instead of extending budgets merely to compensate for broad scope.",
-    "For an ordinary subagent_spawn, omit contract; use a delegation contract only when explicit acceptance, authority, evidence, or admission semantics are required.",
-    "Do not set subagent_spawn contract enforcement to enforce with requestedAuthority readPaths, writePaths, network, or secrets; those guarantees are unsupported and reject before child launch, while capabilities and tools remain enforceable.",
-    "If subagent_spawn rejects an unsupported guarantee, retry once with those fields removed or enforcement set to audit only when they were advisory; when any field is a required security boundary, stop instead of weakening it.",
-    "Read the current pi-subagents session-guidance message before choosing detached completion behavior. With next-turn delivery, use subagent_spawn only when the current response does not depend on its result unless useful overlap ends with an intentional subagent_await. With auto-resume delivery, final-answer-dependent detached work may continue asynchronously.",
-    'Track every final-answer-dependent subagent_spawn by setting completionRequirement to "required" and retaining its returned agentId or taskPath; treat interim output as progress, and synthesize only after every corresponding completion message is visible or terminal.',
-    "Keep ordinary review in the main agent with a review skill and deterministic checks; use subagent_spawn for detached review only when consequential independent verification has concrete parallel value.",
-    "Use a single subagent_spawn for a bounded implementation slice with clear ownership only when it can run beside the identified main-agent work.",
-    "Use a single subagent_spawn without concurrent main-agent work only for an explicit user-requested specialist model, tool profile, or isolation boundary.",
-    ...blockingEnabled ? [
-      "The subagent tool is deprecated; do not select it merely because synchronous output is required. Prefer subagent_spawn with supported completion delivery, and use subagent_await only after useful overlapping main-agent work is complete and an intentional join is required.",
-      "Use deprecated subagent instead of subagent_spawn only for an existing caller or an explicit user request whose blocking chain, fan-in, panel, or workflow semantics do not yet have a detached replacement; queued steering cannot be processed until it returns."
-    ] : [],
-    "Add another subagent_spawn only for truly independent work with safe workspace concurrency and disjoint write ownership; shared workspaces permit concurrent writes by default, so use workspaceMode worktree when repository isolation is required. The main agent still owns integration.",
-    "After subagent_spawn returns, immediately continue the identified local task; do not merely announce the spawn, wait, poll, or end the response while useful local work remains.",
-    "When completionRequirement required subagent_spawn work remains active after local work is exhausted, emit at most one brief progress sentence and end the turn; do not repeat waiting updates or use the requested final format, verdict, or conclusion until every required completion is visible or terminal. Current Pi versions do not enforce a hard pre-display barrier.",
-    "Do not duplicate assigned work from subagent_spawn while its retained agent is running; use a bounded parent fallback only after its completion reports failure or insufficient evidence.",
-    'Consume and synthesize available subagent_spawn completion messages; use subagent_manage with action "interrupt" or "close" for agents that are no longer needed.',
-    'Completion from subagent_spawn is delivered automatically. Do not poll with subagent_inspect or subagent_mailbox action "read", repeatedly check progress, or duplicate the delegated work.'
-  ];
-}
-
-// src/stateful-render.ts
-import { Text } from "@earendil-works/pi-tui";
-function createStatefulToolRenderer(tool) {
-  return {
-    renderCall(args, theme) {
-      return renderStatefulCall(tool, recordValue(args) ?? {}, theme);
-    },
-    renderResult(result2, options, theme, context) {
-      return renderStatefulResult(tool, result2, options, theme, context);
-    }
-  };
-}
-function renderStatefulCall(tool, args, theme) {
-  if (tool === "spawn") {
-    const metadata2 = [
-      `[${safeLine(args.agentScope, "user", 64)}]`,
-      "detached",
-      safeLine(args.workspaceMode, "shared", 64)
-    ];
-    if (typeof args.thinkingLevel === "string") metadata2.push(`thinking:${args.thinkingLevel}`);
-    if (typeof args.timeoutMs === "number") metadata2.push(`timeout:${args.timeoutMs}ms`);
-    if (typeof args.idleTimeoutMs === "number") metadata2.push(`idle:${args.idleTimeoutMs}ms`);
-    if (typeof args.maxTurns === "number") metadata2.push(`turns:${args.maxTurns}`);
-    if (typeof args.maxToolCalls === "number") metadata2.push(`tools:${args.maxToolCalls}`);
-    return new Text(
-      [
-        toolHeader(theme, "subagent_spawn", args.agent, metadata2),
-        `  ${theme.fg("dim", safeLine(args.task, "...", 2 * 1024))}`
-      ].join("\n"),
-      0,
-      0
-    );
-  }
-  if (tool === "send") {
-    const metadata2 = ["follow-up"];
-    if (typeof args.timeoutMs === "number") metadata2.push(`timeout:${args.timeoutMs}ms`);
-    if (typeof args.idleTimeoutMs === "number") metadata2.push(`idle:${args.idleTimeoutMs}ms`);
-    if (typeof args.maxTurns === "number") metadata2.push(`turns:${args.maxTurns}`);
-    if (typeof args.maxToolCalls === "number") metadata2.push(`tools:${args.maxToolCalls}`);
-    return new Text(
-      [
-        toolHeader(theme, "subagent_send", args.agentId, metadata2),
-        `  ${theme.fg("dim", safeLine(args.task, "...", 2 * 1024))}`
-      ].join("\n"),
-      0,
-      0
-    );
-  }
-  if (tool === "await") {
-    const metadata2 = ["blocking"];
-    if (typeof args.timeoutMs === "number") metadata2.push(`timeout:${args.timeoutMs}ms`);
-    return new Text(toolHeader(theme, "subagent_await", args.agentId, metadata2), 0, 0);
-  }
-  if (tool === "manage") {
-    const metadata2 = [];
-    if (typeof args.agentId === "string") metadata2.push(`id:${safeLine(args.agentId, "", 256)}`);
-    if (args.subtree === true) metadata2.push("subtree");
-    return new Text(toolHeader(theme, "subagent_manage", args.action, metadata2), 0, 0);
-  }
-  const metadata = [`id:${safeLine(args.agentId, "...", 256)}`];
-  if (args.action === "read") {
-    metadata.push(args.acknowledge === false ? "leave unread" : "acknowledge");
-  }
-  const lines = [toolHeader(theme, "subagent_mailbox", args.action, metadata)];
-  if (args.action === "send") {
-    lines.push(`  ${theme.fg("dim", safeLine(args.message, "...", 2 * 1024))}`);
-  }
-  return new Text(lines.join("\n"), 0, 0);
-}
-function renderStatefulResult(tool, result2, options, theme, context) {
-  const details = recordValue(result2.details);
-  const args = recordValue(context.args) ?? {};
-  if (!details) return renderFallbackResult(result2, options, theme, context.isError);
-  if (tool === "spawn" || tool === "send" || tool === "await") {
-    const agent = recordValue(details.agent);
-    if (!agent) return renderFallbackResult(result2, options, theme, context.isError);
-    if (tool === "await" && details.timedOut === true) {
-      return new Text(renderAwaitTimeout(agent, result2, options.expanded, theme), 0, 0);
-    }
-    return new Text(renderAgentResult(agent, result2, options.expanded, theme), 0, 0);
-  }
-  if (tool === "manage") {
-    return new Text(renderManageResult(args, details, result2, options.expanded, theme), 0, 0);
-  }
-  return new Text(renderMailboxResult(args, details, options.expanded, theme), 0, 0);
-}
-function renderAgentResult(agent, result2, expanded, theme) {
-  const state = safeLine(agent.state, "unknown", 128);
-  const lines = [
-    `${statusBadge(theme, lifecycleStatus(state))} \xB7 ${theme.fg("accent", safeLine(agent.id, "agent", 256))} \xB7 ${theme.fg("toolOutput", safeLine(agent.agent, "subagent", 256))} \xB7 ${theme.fg("muted", state)}`
-  ];
-  const thinking = stringValue(agent.thinkingLevel);
-  const timeout = typeof agent.currentTimeoutMs === "number" ? agent.currentTimeoutMs : typeof agent.timeoutMs === "number" ? agent.timeoutMs : 0;
-  const idleTimeout = typeof agent.currentIdleTimeoutMs === "number" ? agent.currentIdleTimeoutMs : typeof agent.idleTimeoutMs === "number" ? agent.idleTimeoutMs : 0;
-  const maxTurns = typeof agent.currentMaxTurns === "number" ? agent.currentMaxTurns : typeof agent.maxTurns === "number" ? agent.maxTurns : 0;
-  const maxToolCalls = typeof agent.currentMaxToolCalls === "number" ? agent.currentMaxToolCalls : typeof agent.maxToolCalls === "number" ? agent.maxToolCalls : 0;
-  const unread = typeof agent.unreadMessages === "number" ? agent.unreadMessages : 0;
-  if (thinking || timeout || idleTimeout || maxTurns || maxToolCalls || unread > 0) {
-    lines.push(
-      theme.fg(
-        "dim",
-        [
-          thinking && `thinking:${safeLine(thinking, "", 128)}`,
-          timeout && `timeout:${timeout}ms`,
-          idleTimeout && `idle:${idleTimeout}ms`,
-          maxTurns && `turns:${maxTurns}`,
-          maxToolCalls && `tools:${maxToolCalls}`,
-          unread > 0 && `unread:${unread}`
-        ].filter(Boolean).join(" \xB7 ")
-      )
-    );
-  }
-  if (expanded) {
-    const task = safeBlock(agent.currentTask, "", 2 * 1024).trim();
-    const error = safeBlock(agent.error, "", 2 * 1024).trim();
-    if (task) lines.push(theme.fg("dim", `task: ${task}`));
-    if (error) lines.push(theme.fg("error", `error: ${error}`));
-    const content = safeBlock(textResult(result2), "", 8 * 1024).trim();
-    if (content) lines.push(theme.fg("toolOutput", content));
-  } else lines.push(expansionHint());
-  return lines.join("\n");
-}
-function renderAwaitTimeout(agent, result2, expanded, theme) {
-  const lines = [
-    `${statusBadge(theme, "running")} \xB7 ${theme.fg("accent", safeLine(agent.id, "agent", 256))} \xB7 ${theme.fg("warning", "wait timed out")} \xB7 ${theme.fg("muted", safeLine(agent.state, "unknown", 128))}`
-  ];
-  if (expanded) {
-    const content = safeBlock(textResult(result2), "", 8 * 1024).trim();
-    if (content) lines.push(theme.fg("toolOutput", content));
-  } else lines.push(expansionHint());
-  return lines.join("\n");
-}
-function renderManageResult(args, details, result2, expanded, theme) {
-  const action = safeLine(args.action, "action", 128);
-  const agents = recordList(details.agents);
-  const primary = recordValue(details.agent);
-  if (action === "list") {
-    const lines2 = [
-      `${statusBadge(theme, "completed")} \xB7 list \xB7 ${agents.length} agent${agents.length === 1 ? "" : "s"}`
-    ];
-    const selected2 = expanded ? agents : agents.slice(0, COLLAPSED_LIST_LIMIT);
-    for (const agent of selected2) lines2.push(formatAgentLine(agent, theme, expanded));
-    if (agents.length === 0) lines2.push(theme.fg("muted", "(no retained agents)"));
-    if (agents.length > selected2.length)
-      lines2.push(theme.fg("muted", `\u2026 ${agents.length - selected2.length} omitted`));
-    if (!expanded && agents.length > 0) lines2.push(expansionHint());
-    return lines2.join("\n");
-  }
-  const subtree = args.subtree === true;
-  const affected = subtree ? agents.length : agents.length > 0 ? agents.length : primary ? 1 : 0;
-  const status = action === "interrupt" ? "interrupted" : "closed";
-  const lines = [
-    `${statusBadge(theme, status)} \xB7 ${affected} agent${affected === 1 ? "" : "s"}${subtree ? theme.fg("muted", " \xB7 subtree") : ""}`
-  ];
-  const selected = agents.length > 0 ? agents : !subtree && primary ? [primary] : [];
-  for (const agent of expanded ? selected : selected.slice(0, COLLAPSED_LIST_LIMIT)) {
-    lines.push(formatAgentLine(agent, theme, expanded));
-  }
-  if (selected.length === 0) {
-    const content = safeBlock(textResult(result2), "(no output)", 8 * 1024);
-    lines.push(theme.fg("toolOutput", content));
-  }
-  if (!expanded && selected.length > 0) lines.push(expansionHint());
-  return lines.join("\n");
-}
-function renderMailboxResult(args, details, expanded, theme) {
-  const action = safeLine(args.action, "action", 64);
-  if (action === "send") {
-    const message = recordValue(details.message);
-    if (!message) return `${statusBadge(theme, "completed")} \xB7 Queued message`;
-    const lines2 = [
-      `${theme.fg("success", "\u2713")} ${theme.fg("success", "Queued")} \xB7 ${theme.fg("accent", safeLine(message.id, "message", 256))} \xB7 ${theme.fg("muted", `to ${safeLine(message.recipientId, safeLine(args.agentId), 256)}`)}`
-    ];
-    if (expanded) {
-      lines2.push(theme.fg("toolOutput", safeBlock(message.content, "(empty message)", 2 * 1024)));
-    } else lines2.push(expansionHint());
-    return lines2.join("\n");
-  }
-  const messages = recordList(details.messages);
-  const acknowledged = args.acknowledge === false ? "left unread" : "acknowledged";
-  const lines = [
-    `${statusBadge(theme, "completed")} \xB7 ${messages.length} message${messages.length === 1 ? "" : "s"} \xB7 ${acknowledged}`
-  ];
-  const selected = expanded ? messages : messages.slice(0, COLLAPSED_LIST_LIMIT);
-  for (const message of selected) {
-    const content = expanded ? safeBlock(message.content, "(empty message)", 2 * 1024) : safeLine(message.content, "(empty message)", 512);
-    lines.push(
-      `${theme.fg("muted", "\u2022 ")}${theme.fg("accent", safeLine(message.id, "message", 256))} ${theme.fg("muted", `from ${safeLine(message.senderId, "unknown", 256)}: `)}${theme.fg("toolOutput", content)}`
-    );
-  }
-  if (messages.length === 0) lines.push(theme.fg("muted", "(no unread messages)"));
-  if (messages.length > selected.length)
-    lines.push(theme.fg("muted", `\u2026 ${messages.length - selected.length} omitted`));
-  if (!expanded && messages.length > 0) lines.push(expansionHint());
-  return lines.join("\n");
-}
-function formatAgentLine(agent, theme, expanded) {
-  const unread = typeof agent.unreadMessages === "number" ? agent.unreadMessages : 0;
-  const lines = [
-    `${theme.fg("muted", "\u2022 ")}${theme.fg("accent", safeLine(agent.id, "agent", 256))} ${theme.fg("toolOutput", safeLine(agent.agent, "subagent", 256))} ${theme.fg("muted", safeLine(agent.state, "unknown", 128))}${unread > 0 ? theme.fg("warning", ` \xB7 unread:${unread}`) : ""}`
-  ];
-  if (expanded) {
-    const task = safeBlock(agent.currentTask, "", 2 * 1024).trim();
-    const error = safeBlock(agent.error, "", 2 * 1024).trim();
-    if (task) lines.push(`  ${theme.fg("dim", `task: ${task}`)}`);
-    if (error) lines.push(`  ${theme.fg("error", `error: ${error}`)}`);
-  }
-  return lines.join("\n");
-}
-function lifecycleStatus(state) {
-  switch (state) {
-    case "starting":
-      return "starting";
-    case "running":
-      return "running";
-    case "idle":
-      return "idle";
-    case "partial":
-    case "blocked":
-    case "needs-input":
-    case "abstained":
-    case "stale":
-      return "warning";
-    case "failed":
-      return "failed";
-    case "interrupted":
-      return "interrupted";
-    case "closed":
-      return "closed";
-    default:
-      return "completed";
-  }
-}
-
-// src/stateful-tool-params.ts
-import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "typebox";
-var MANAGE_ACTIONS = ["interrupt", "close"];
-var MAILBOX_ACTIONS = ["send", "read"];
-var MAX_MAILBOX_MESSAGE_LENGTH = 16 * 1024;
-var ManageParamsSchema = Type.Object(
-  {
-    action: StringEnum(MANAGE_ACTIONS, {
-      description: "Interrupt active work or close an agent and release its resources."
-    }),
-    agentId: Type.Optional(
-      Type.String({
-        minLength: 1,
-        description: "Required agent ID or canonical task path for interrupt and close."
-      })
-    ),
-    subtree: Type.Optional(
-      Type.Boolean({
-        default: false,
-        description: "Interrupt or close the target and all descendants child-first."
-      })
-    )
-  },
-  { additionalProperties: false }
-);
-var MailboxParamsSchema = Type.Object(
-  {
-    action: StringEnum(MAILBOX_ACTIONS, {
-      description: "Use send for queue-only delivery or read to inspect unread mailbox messages."
-    }),
-    agentId: Type.String({
-      minLength: 1,
-      description: "Mailbox owner or recipient agent ID or canonical task path."
-    }),
-    message: Type.Optional(
-      Type.String({
-        minLength: 1,
-        maxLength: MAX_MAILBOX_MESSAGE_LENGTH,
-        description: "Message content required by send; sending does not start a turn."
-      })
-    ),
-    senderId: Type.Optional(
-      Type.String({ description: "Optional sender agent ID or canonical task path." })
-    ),
-    deduplicationKey: Type.Optional(
-      Type.String({ maxLength: 256, description: "Optional idempotency key for send." })
-    ),
-    acknowledge: Type.Optional(
-      Type.Boolean({ default: true, description: "Mark returned read messages as acknowledged." })
-    ),
-    limit: Type.Optional(
-      Type.Number({ minimum: 1, maximum: 20, default: 20, description: "Maximum messages." })
-    )
-  },
-  { additionalProperties: false }
-);
-function validateManageParams(params) {
-  const values = parameterRecord(params, "subagent_manage");
-  assertKnownKeys("subagent_manage", values, ["action", "agentId", "subtree"]);
-  const action = values.action;
-  if (action === "list") {
-    throw new Error(
-      'subagent_manage no longer supports "list"; use subagent_inspect action "list_runs"'
-    );
-  }
-  if (typeof action !== "string" || !MANAGE_ACTIONS.includes(action)) {
-    throw new Error(`subagent_manage action must be one of: ${MANAGE_ACTIONS.join(", ")}`);
-  }
-  assertRequiredString("subagent_manage", action, values, "agentId");
-  assertOptionalBoolean("subagent_manage", action, values, "subtree");
-  return {
-    action,
-    agentId: values.agentId,
-    ...values.subtree === void 0 ? {} : { subtree: values.subtree }
-  };
-}
-function validateMailboxParams(params) {
-  const values = parameterRecord(params, "subagent_mailbox");
-  assertKnownKeys("subagent_mailbox", values, [
-    "action",
-    "agentId",
-    "message",
-    "senderId",
-    "deduplicationKey",
-    "acknowledge",
-    "limit"
-  ]);
-  const action = values.action;
-  if (typeof action !== "string" || !MAILBOX_ACTIONS.includes(action)) {
-    throw new Error(`subagent_mailbox action must be one of: ${MAILBOX_ACTIONS.join(", ")}`);
-  }
-  if (action === "send") {
-    assertRequiredString("subagent_mailbox", action, values, "agentId");
-    assertRequiredString("subagent_mailbox", action, values, "message");
-    const message = values.message;
-    if (message.length > MAX_MAILBOX_MESSAGE_LENGTH) {
-      throw new Error(
-        `subagent_mailbox action "send" requires message at most ${MAX_MAILBOX_MESSAGE_LENGTH} characters`
-      );
-    }
-    assertOptionalString("subagent_mailbox", action, values, "senderId");
-    assertOptionalString("subagent_mailbox", action, values, "deduplicationKey");
-    if (typeof values.deduplicationKey === "string" && values.deduplicationKey.length > 256) {
-      throw new Error(
-        'subagent_mailbox action "send" requires deduplicationKey at most 256 characters'
-      );
-    }
-    return {
-      action,
-      agentId: values.agentId,
-      message,
-      ...values.senderId === void 0 ? {} : { senderId: values.senderId },
-      ...values.deduplicationKey === void 0 ? {} : { deduplicationKey: values.deduplicationKey }
-    };
-  }
-  assertRequiredString("subagent_mailbox", action, values, "agentId");
-  assertOptionalBoolean("subagent_mailbox", action, values, "acknowledge");
-  if (values.limit !== void 0 && (typeof values.limit !== "number" || !Number.isFinite(values.limit) || values.limit < 1 || values.limit > 20)) {
-    throw new Error('subagent_mailbox action "read" requires limit between 1 and 20');
-  }
-  return {
-    action,
-    agentId: values.agentId,
-    ...values.acknowledge === void 0 ? {} : { acknowledge: values.acknowledge },
-    ...values.limit === void 0 ? {} : { limit: values.limit }
-  };
-}
-function parameterRecord(params, toolName) {
-  if (!params || typeof params !== "object" || Array.isArray(params)) {
-    throw new Error(`${toolName} parameters must be an object`);
-  }
-  return params;
-}
-function assertKnownKeys(toolName, values, allowed) {
-  const unexpected = Object.keys(values).find(
-    (key) => values[key] !== void 0 && !allowed.includes(key)
-  );
-  if (unexpected) throw new Error(`${toolName} does not accept ${unexpected}`);
-}
-function assertRequiredString(toolName, action, values, key) {
-  const value = values[key];
-  if (value === void 0) throw new Error(`${toolName} action "${action}" requires ${key}`);
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`${toolName} action "${action}" requires ${key} to be a non-empty string`);
-  }
-}
-function assertOptionalString(toolName, action, values, key) {
-  if (values[key] !== void 0 && typeof values[key] !== "string") {
-    throw new Error(`${toolName} action "${action}" requires ${key} to be a string`);
-  }
-}
-function assertOptionalBoolean(toolName, action, values, key) {
-  if (values[key] !== void 0 && typeof values[key] !== "boolean") {
-    throw new Error(`${toolName} action "${action}" requires ${key} to be a boolean`);
-  }
-}
-
-// src/stateful-registration.ts
-var statefulSessionModules;
-var statefulSpawnModules;
-var workspaceModule;
-function loadStatefulSessionModules() {
-  statefulSessionModules ??= Promise.all([
-    import("./completion-delivery-RSJU6BXL.ts"),
-    import("./peer-communication-KL36Z6CO.ts"),
-    import("./context-QDKLVQXE.ts"),
-    import("./create-stateful-transport-JWC2EFYL.ts"),
-    import("./cwd-policy-NB6XZ5GF.ts"),
-    import("./persistence-UY3PY6E5.ts"),
-    import("./registry-BT54L6CY.ts"),
-    import("./stateful-lifecycle-JAR6K55H.ts")
-  ]).then(
-    ([
-      broker,
-      peerCommunication,
-      context,
-      transport,
-      cwdPolicy,
-      persistence,
-      registry,
-      lifecycle
-    ]) => ({
-      broker,
-      peerCommunication,
-      context,
-      transport,
-      cwdPolicy,
-      persistence,
-      registry,
-      lifecycle
-    })
-  ).catch((error) => {
-    statefulSessionModules = void 0;
-    throw error;
-  });
-  return statefulSessionModules;
-}
-function loadStatefulSpawnModules() {
-  statefulSpawnModules ??= Promise.all([
-    import("./discovery-MIFB2U4Y.ts"),
-    import("./capability-grant-PR72SWWS.ts"),
-    import("./context-QDKLVQXE.ts"),
-    import("./cwd-policy-NB6XZ5GF.ts"),
-    import("./delegation-contract-LA56I5DT.ts"),
-    import("./runtime-policy-5YELCOVC.ts"),
-    import("./retained-semantic-state-GM75FZGE.ts"),
-    import("./semantic-snapshot-WPJ3UAFW.ts"),
-    import("./spawn-idempotency-BNHOSMZW.ts")
-  ]).then(
-    ([
-      agents,
-      capabilityGrant,
-      context,
-      cwdPolicy,
-      delegationContract,
-      runtimePolicy,
-      retainedSemanticState,
-      semanticSnapshot,
-      spawnIdempotency
-    ]) => ({
-      agents,
-      capabilityGrant,
-      context,
-      cwdPolicy,
-      delegationContract,
-      runtimePolicy,
-      retainedSemanticState,
-      semanticSnapshot,
-      spawnIdempotency
-    })
-  ).catch((error) => {
-    statefulSpawnModules = void 0;
-    throw error;
-  });
-  return statefulSpawnModules;
-}
-async function loadWorkspaceModule() {
-  workspaceModule ??= import("./workspace-WDKLN72J.ts").catch((error) => {
-    workspaceModule = void 0;
-    throw error;
-  });
-  return workspaceModule;
-}
-var ContextModeSchema = Type2.Union([
-  StringEnum2(["none", "all", "summary"]),
-  Type2.Number({ minimum: 1, description: "Include the most recent N user turns." })
-]);
-var ScopeSchema = StringEnum2(["user", "project", "both"], {
-  description: 'Per-invocation custom agent scope for this spawn. Default: "user". Use "project" for project-local agents or "both" for user and project agents; the selected scope is retained for follow-ups.',
-  default: "user"
-});
-var StatefulThinkingLevelSchema = StringEnum2(THINKING_LEVELS, {
-  description: "Optional requested Pi thinking level selected for this task difficulty; retained for every turn of the spawned agent."
-});
-var StatefulTimeoutSchema = Type2.Integer({
-  minimum: 1,
-  maximum: MAX_SUBAGENT_TIMEOUT_MS,
-  description: "Work deadline in milliseconds selected for the task difficulty. On expiry, Pi aborts the work and makes one separately bounded summary attempt. Retained as the agent default."
-});
-var DEFAULT_SUBAGENT_AWAIT_TIMEOUT_MS = 3e4;
-var SubagentAwaitParams = Type2.Object({
-  agentId: Type2.String({
-    minLength: 1,
-    description: "Retained agent ID or canonical task path."
-  }),
-  timeoutMs: Type2.Optional(
-    Type2.Integer({
-      minimum: 1,
-      maximum: MAX_SUBAGENT_TIMEOUT_MS,
-      description: "Maximum time to wait in milliseconds. A wait timeout stops only this tool call and does not interrupt or close the subagent. Defaults to 30000."
-    })
-  )
-});
-var StatefulTurnLimitFields = {
-  idleTimeoutMs: Type2.Optional(
-    Type2.Integer({
-      minimum: 1,
-      maximum: MAX_SUBAGENT_TIMEOUT_MS,
-      description: "Maximum milliseconds without a completed assistant turn or tool result; retained as the agent default."
-    })
-  ),
-  maxTurns: Type2.Optional(
-    Type2.Integer({
-      minimum: 1,
-      maximum: MAX_SUBAGENT_TURNS,
-      description: "Maximum unfinished assistant turns; retained as the agent default. Omit rather than guessing a tight bound."
-    })
-  ),
-  maxToolCalls: Type2.Optional(
-    Type2.Integer({
-      minimum: 1,
-      maximum: MAX_SUBAGENT_TOOL_CALLS,
-      description: "Maximum tool calls; retained as the agent default. Omit rather than guessing a tight bound."
-    })
-  )
-};
-function registerStatefulSubagents(pi, dependencies = {}) {
-  const settings = Object.hasOwn(dependencies, "settings") ? dependencies.settings ?? {} : readSubagentSettings()?.stateful ?? {};
-  const blockingEnabled = dependencies.blockingEnabled !== false;
-  const enabled = settings.enabled !== false;
-  const transportKind = resolveStatefulTransportKind(settings.transport);
-  let completionDelivery = resolveCompletionDelivery(settings.completionDelivery);
-  let runtimeLimits = resolveStatefulLimits(settings);
-  let completionBroker;
-  let peerBroker;
-  let registry;
-  let persistence;
-  let sweepTimer;
-  let runtimeGeneration = 0;
-  let runtimeTransition = Promise.resolve();
-  let workspaceManager = dependencies.workspaceManager;
-  const getWorkspaceManager = async () => {
-    if (workspaceManager) return workspaceManager;
-    const { WorkspaceManager } = await loadWorkspaceModule();
-    workspaceManager = new WorkspaceManager();
-    return workspaceManager;
-  };
-  const isolatedAgents = /* @__PURE__ */ new Map();
-  const seenMessageIds = /* @__PURE__ */ new Set();
-  const pendingIdempotentSpawns = /* @__PURE__ */ new Map();
-  const parentRuntime = { model: void 0, thinkingLevel: "off" };
-  const getCurrentSettings = () => dependencies.getSettings ? dependencies.getSettings() : readSubagentSettings();
-  const getCurrentStatefulSettings = () => dependencies.getSettings ? dependencies.getSettings()?.stateful ?? {} : settings;
-  const clearAgents = async () => {
-    const generation = runtimeGeneration;
-    const currentRegistry = registry;
-    const currentPersistence = persistence;
-    if (!currentRegistry) return 0;
-    const currentWorkspaceManager = await getWorkspaceManager();
-    const count = currentRegistry.list().length;
-    const clear = async () => {
-      await currentRegistry.closeAll();
-      if (generation !== runtimeGeneration) return;
-      await currentWorkspaceManager.cleanupAll();
-      isolatedAgents.clear();
-      seenMessageIds.clear();
-      await currentPersistence?.delete();
-    };
-    const transition = runtimeTransition.then(clear, clear);
-    runtimeTransition = transition.catch(() => void 0);
-    await transition;
-    return count;
-  };
-  const controller = {
-    getCompletionDelivery() {
-      return completionDelivery;
-    },
-    setCompletionDelivery(value) {
-      completionDelivery = value;
-      completionBroker?.setDelivery(value);
-    },
-    getRuntimeStatus() {
-      const counts = registry?.inspectionCounts() ?? { activeAgents: 0, retainedAgents: 0 };
-      return {
-        enabled,
-        initialized: registry !== void 0,
-        transport: transportKind,
-        completionDelivery,
-        limits: { ...runtimeLimits },
-        ...counts
-      };
-    },
-    listAgents(includeClosed = false) {
-      return registry?.list(includeClosed) ?? [];
-    },
-    listRunInspection(includeClosed = false) {
-      return registry?.listInspection(includeClosed) ?? [];
-    },
-    getRunInspection(agentId) {
-      return registry?.getInspection(agentId);
-    },
-    clearAgents
-  };
-  if (!enabled) return controller;
-  const requireRegistry = () => {
-    if (!registry) throw new Error("Stateful subagents are not initialized for this session");
-    return registry;
-  };
-  pi.on("session_start", async (event, ctx) => {
-    const generation = ++runtimeGeneration;
-    completionBroker?.close();
-    completionBroker = void 0;
-    const previousPeerBroker = peerBroker;
-    peerBroker = void 0;
-    if (sweepTimer) clearInterval(sweepTimer);
-    sweepTimer = void 0;
-    const previousRegistry = registry;
-    registry = void 0;
-    persistence = void 0;
-    isolatedAgents.clear();
-    seenMessageIds.clear();
-    pendingIdempotentSpawns.clear();
-    const initialize = async () => {
-      await previousPeerBroker?.close();
-      const currentWorkspaceManager = await getWorkspaceManager();
-      const modules = await loadStatefulSessionModules();
-      const cleanupErrors = await modules.lifecycle.disposeStatefulRuntime(
-        previousRegistry,
-        currentWorkspaceManager
-      );
-      if (generation !== runtimeGeneration) return;
-      if (cleanupErrors.length > 0 && ctx.hasUI) {
-        ctx.ui.notify(
-          `Previous subagent runtime cleanup reported ${cleanupErrors.length} error(s).`,
-          "warning"
-        );
-      }
-      parentRuntime.model = ctx.model;
-      parentRuntime.thinkingLevel = normalizeRuntimeThinkingLevel(pi.getThinkingLevel());
-      const sessionSettings = getCurrentStatefulSettings();
-      const nextLimits = resolveStatefulLimits(sessionSettings);
-      const owner = ctx.sessionManager.getSessionId?.() ?? ctx.sessionManager.getSessionFile?.() ?? `ephemeral:${ctx.cwd}`;
-      const sessionPersistence = new modules.persistence.AgentPersistence(owner, {
-        retentionDays: sessionSettings.retentionDays,
-        maxStoredAgents: nextLimits.maxStoredAgents
-      });
-      let nextRegistry;
-      let transport;
-      const sessionBroker = new modules.broker.CompletionDeliveryBroker(
-        pi,
-        ctx,
-        completionDelivery,
-        {
-          onDeliveryError: (error) => {
-            if (!ctx.hasUI) return;
-            const reason = error instanceof Error ? error.message : String(error);
-            ctx.ui.notify(`Subagent completion delivery failed: ${reason}`, "warning");
-          },
-          onDeliveryAttempt: (completions, input) => {
-            if (generation !== runtimeGeneration) return;
-            for (const completion of completions) {
-              dependencies.usageRecording?.recordCompletionDeliveryAttempt(completion, input);
-            }
-          },
-          onAcknowledged: (completions, deliveredAt) => {
-            if (generation !== runtimeGeneration) return;
-            for (const completion of completions) {
-              dependencies.usageRecording?.recordCompletionVisible(completion);
-              void nextRegistry.markCompletionDelivered(completion.completionId, deliveredAt).catch((error) => {
-                if (!ctx.hasUI || generation !== runtimeGeneration) return;
-                const reason = error instanceof Error ? error.message : String(error);
-                ctx.ui.notify(`Subagent completion acknowledgement failed: ${reason}`, "warning");
-              });
-            }
-          }
-        }
-      );
-      const sessionPeerBroker = new modules.peerCommunication.PeerCommunicationBroker({
-        getRegistry: () => nextRegistry,
-        sendRoot: ({ message, senderPath }) => {
-          pi.appendEntry("pi-subagent-peer-message", {
-            messageId: message.id,
-            senderId: message.senderId,
-            senderPath,
-            content: modules.context.redactPrivateText(message.content)
-          });
-          pi.sendMessage(
-            {
-              customType: "pi-subagent-peer-message",
-              content: [
-                "Message Type: SUBAGENT_PEER_MESSAGE",
-                "Protocol: pi-subagents:v1",
-                `Message ID: ${message.id}`,
-                `Sender ID: ${message.senderId}`,
-                `Sender Path: ${senderPath}`,
-                "Payload:",
-                message.content
-              ].join("\n"),
-              display: true,
-              details: { ...message, senderPath }
-            },
-            { deliverAs: "steer", triggerTurn: false }
-          );
-        },
-        dispatch: (recipient, message) => transport.deliverMessage?.(recipient, message) ?? false
-      });
-      transport = modules.transport.createStatefulTransport({
-        kind: transportKind,
-        modelRegistry: ctx.modelRegistry,
-        getParentRuntime: () => ({ ...parentRuntime }),
-        getSettings: getCurrentSettings,
-        createInProcessSession: dependencies.createInProcessSession,
-        peerRuntime: sessionPeerBroker,
-        loadTransport: dependencies.loadTransport
-      });
-      nextRegistry = new modules.registry.AgentRegistry(transport, {
-        maxAgents: nextLimits.maxAgents,
-        maxActiveTurns: nextLimits.maxActiveTurns,
-        maxDepth: nextLimits.maxDepth,
-        maxChildrenPerAgent: nextLimits.maxChildrenPerAgent,
-        maxMailboxMessages: sessionSettings.maxMailboxMessages,
-        maxMailboxMessageBytes: sessionSettings.maxMailboxMessageBytes,
-        idleTtlMs: sessionSettings.idleTtlMs,
-        onChange: async (agents) => {
-          if (generation !== runtimeGeneration) return;
-          await sessionPersistence.save(agents);
-          if (generation !== runtimeGeneration) return;
-          dependencies.usageRecording?.observeAgents(agents);
-          for (const agent of agents) {
-            for (const message of agent.mailbox) {
-              if (seenMessageIds.has(message.id)) continue;
-              seenMessageIds.add(message.id);
-              pi.appendEntry("pi-subagent-message", {
-                senderId: message.senderId,
-                recipientId: message.recipientId,
-                content: modules.context.redactPrivateText(message.content).slice(0, 160)
-              });
-              if (agent.state === "running" && message.deduplicationKey?.startsWith("completion:")) {
-                try {
-                  await transport.deliverMessage?.(agent, {
-                    ...message,
-                    content: modules.context.redactPrivateText(message.content)
-                  });
-                } catch {
-                }
-                if (generation !== runtimeGeneration) return;
-              }
-            }
-          }
-        },
-        onTurnComplete: (completion) => {
-          if (generation !== runtimeGeneration) return;
-          dependencies.usageRecording?.recordChildCompletion(completion);
-          if (completion.recipientId === "root") sessionBroker.enqueue(completion);
-        }
-      });
-      const persisted = sessionPersistence.load();
-      const orphanCleanupFailures = await modules.lifecycle.cleanupPersistedWorkspaces(
-        persisted,
-        currentWorkspaceManager
-      );
-      if (generation !== runtimeGeneration) {
-        sessionBroker.close();
-        await sessionPeerBroker.close();
-        await modules.lifecycle.disposeStatefulRuntime(nextRegistry, currentWorkspaceManager);
-        return;
-      }
-      if (ctx.hasUI && orphanCleanupFailures > 0) {
-        ctx.ui.notify("Some orphaned subagent worktrees could not be cleaned", "warning");
-      }
-      const restored = persisted.filter(
-        (agent) => agent.workspaceMode !== "worktree" && (agent.agentScope !== "project" && agent.agentScope !== "both" || ctx.isProjectTrusted())
-      ).flatMap((agent) => {
-        try {
-          const target = modules.cwdPolicy.resolveSubagentTarget({
-            workspace: ctx.cwd,
-            requestedCwd: agent.cwd,
-            currentProjectTrusted: ctx.isProjectTrusted()
-          });
-          return [
-            { ...agent, cwd: target.cwd, target: modules.cwdPolicy.targetPolicyAudit(target) }
-          ];
-        } catch {
-          return [];
-        }
-      });
-      for (const agent of restored) {
-        for (const message of agent.mailbox) seenMessageIds.add(message.id);
-      }
-      nextRegistry.restore(restored);
-      const branchRequirements = completionRequirementsFromBranch(ctx.sessionManager.getBranch());
-      const branchOwnsRequirementState = branchRequirements.observedState || event.reason === "fork" || event.reason === "new";
-      nextRegistry.reconcileCompletionRequirements(
-        branchRequirements.records,
-        branchOwnsRequirementState
-      );
-      if (branchOwnsRequirementState) {
-        try {
-          await sessionPersistence.save(nextRegistry.list(true));
-        } catch (error) {
-          if (generation === runtimeGeneration && ctx.hasUI) {
-            const reason = error instanceof Error ? error.message : String(error);
-            ctx.ui.notify(
-              `Subagent requirement reconciliation could not be persisted yet: ${reason}`,
-              "warning"
-            );
-          }
-        }
-      }
-      if (generation !== runtimeGeneration) {
-        sessionBroker.close();
-        await sessionPeerBroker.close();
-        await modules.lifecycle.disposeStatefulRuntime(nextRegistry, currentWorkspaceManager);
-        return;
-      }
-      registry = nextRegistry;
-      persistence = sessionPersistence;
-      completionBroker = sessionBroker;
-      peerBroker = sessionPeerBroker;
-      for (const completion of nextRegistry.listPendingCompletions()) {
-        if (completion.recipientId === "root") sessionBroker.enqueue(completion);
-      }
-      runtimeLimits = nextLimits;
-      const sweepEveryMs = Math.max(
-        1e3,
-        Math.min(sessionSettings.idleTtlMs ?? 60 * 60 * 1e3, 6e4)
-      );
-      sweepTimer = setInterval(() => {
-        void nextRegistry.sweepExpired().catch((error) => {
-          if (!ctx.hasUI || generation !== runtimeGeneration) return;
-          const reason = error instanceof Error ? error.message : String(error);
-          ctx.ui.notify(`Subagent expiry cleanup failed: ${reason}`, "warning");
-        });
-      }, sweepEveryMs);
-      sweepTimer.unref();
-    };
-    const transition = runtimeTransition.then(initialize, initialize);
-    runtimeTransition = transition.catch(() => void 0);
-    await transition;
-  });
-  pi.on("agent_start", () => {
-    completionBroker?.onParentTurnStart();
-  });
-  pi.on("context", (event) => {
-    completionBroker?.onParentContext(event.messages);
-  });
-  pi.on("agent_settled", () => {
-    completionBroker?.onParentSettled();
-  });
-  pi.on("model_select", (event) => {
-    parentRuntime.model = event.model;
-  });
-  pi.on("thinking_level_select", (event) => {
-    parentRuntime.thinkingLevel = normalizeRuntimeThinkingLevel(event.level);
-  });
-  pi.on("session_shutdown", async (_event, ctx) => {
-    runtimeGeneration++;
-    completionBroker?.close();
-    completionBroker = void 0;
-    const previousPeerBroker = peerBroker;
-    peerBroker = void 0;
-    if (sweepTimer) clearInterval(sweepTimer);
-    sweepTimer = void 0;
-    const previousRegistry = registry;
-    registry = void 0;
-    persistence = void 0;
-    isolatedAgents.clear();
-    seenMessageIds.clear();
-    pendingIdempotentSpawns.clear();
-    const shutdown = async () => {
-      await previousPeerBroker?.close();
-      const currentWorkspaceManager = await getWorkspaceManager();
-      const { disposeStatefulRuntime } = await import("./stateful-lifecycle-JAR6K55H.ts");
-      const errors = await disposeStatefulRuntime(previousRegistry, currentWorkspaceManager);
-      if (errors.length > 0 && ctx.hasUI) {
-        ctx.ui.notify(`Subagent shutdown cleanup reported ${errors.length} error(s).`, "warning");
-      }
-    };
-    const transition = runtimeTransition.then(shutdown, shutdown);
-    runtimeTransition = transition.catch(() => void 0);
-    await transition;
-  });
-  const spawnTool = defineTool({
-    name: "subagent_spawn",
-    label: "Spawn Subagent",
-    description: "Start an addressable background subagent with an opaque agentId and canonical taskPath, an optional thinking level and execution budgets chosen for the task difficulty, and asynchronous completion delivery. The current bounded capacity, completion policy, working-directory policy, and available agent definitions are published in the pi-subagents session-guidance message. Working-directory policy controls launch targets and protected project resources, not filesystem access or sandboxing.",
-    promptSnippet: "Start a reusable detached subagent; completion is delivered asynchronously",
-    promptGuidelines: createSpawnPromptGuidelines(blockingEnabled),
-    parameters: grammarSafeToolObject({
-      agent: Type2.String({ minLength: 1 }),
-      taskName: Type2.Optional(
-        Type2.String({
-          minLength: 1,
-          maxLength: MAX_TASK_NAME_LENGTH,
-          pattern: "^[a-z0-9_]+$",
-          description: "Canonical path segment for this task; use lowercase letters, digits, and underscores."
-        })
-      ),
-      task: Type2.String({ minLength: 1, maxLength: DEFAULT_MAX_CONTEXT_BYTES }),
-      thinkingLevel: Type2.Optional(StatefulThinkingLevelSchema),
-      timeoutMs: Type2.Optional(StatefulTimeoutSchema),
-      ...StatefulTurnLimitFields,
-      cwd: Type2.Optional(Type2.String()),
-      agentScope: Type2.Optional(ScopeSchema),
-      confirmProjectAgents: Type2.Optional(Type2.Boolean({ default: true })),
-      context: Type2.Optional(ContextModeSchema),
-      contextEntryIds: Type2.Optional(
-        Type2.Array(Type2.String(), { description: "Optional selected session entry IDs." })
-      ),
-      parentId: Type2.Optional(
-        Type2.String({ description: "Optional parent agent ID or canonical task path." })
-      ),
-      allowConcurrentWrites: Type2.Optional(
-        Type2.Boolean({
-          description: "Deprecated compatibility field; shared-workspace concurrency is allowed by default."
-        })
-      ),
-      workspaceMode: Type2.Optional(
-        StringEnum2(["shared", "worktree"], {
-          description: "Use the shared workspace (default) or an opt-in disposable Git worktree."
-        })
-      ),
-      contract: Type2.Optional(DelegationContractSchema),
-      idempotencyKey: Type2.Optional(
-        Type2.String({
-          minLength: 1,
-          maxLength: MAX_SPAWN_IDEMPOTENCY_KEY_LENGTH,
-          description: "Reuse the same retained agent for an exact accepted spawn retry."
-        })
-      ),
-      resultFormat: Type2.Optional(
-        StringEnum2(SUBAGENT_RESULT_FORMATS, {
-          description: "Use text (default), structured-v1, or the evidence-preserving structured-v2 completion contract."
-        })
-      ),
-      completionRequirement: Type2.Optional(CompletionRequirementModeSchema)
-    }),
-    ...createStatefulToolRenderer("spawn"),
-    async execute(_id, params, signal, _update, ctx) {
-      const generation = runtimeGeneration;
-      const capturedRegistry = registry;
-      let modules;
-      try {
-        modules = await loadStatefulSpawnModules();
-      } catch (error) {
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        throw error;
-      }
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      let currentWorkspaceManager;
-      try {
-        currentWorkspaceManager = await getWorkspaceManager();
-      } catch (error) {
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        throw error;
-      }
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const scope = params.agentScope ?? "user";
-      const resultFormat = params.resultFormat ?? "text";
-      const contract = modules.delegationContract.normalizeDelegationContract(params.contract);
-      if (params.contract !== void 0 && !contract) {
-        throw new Error(
-          "subagent_spawn contract must be a valid pi-subagents:delegation:v2 object"
-        );
-      }
-      modules.runtimePolicy.assertSubagentDepthAllowed();
-      assertSpawnIdempotencyKey(params.idempotencyKey);
-      const currentSettings = getCurrentSettings();
-      const target = modules.cwdPolicy.resolveSubagentTarget({
-        workspace: ctx.cwd,
-        requestedCwd: params.cwd,
-        currentProjectTrusted: ctx.isProjectTrusted()
-      });
-      modules.cwdPolicy.assertDelegationTargetAllowed(
-        target,
-        currentSettings?.cwdPolicy?.delegation ?? DEFAULT_DELEGATION_CWD_POLICY
-      );
-      const cwd = target.cwd;
-      const mode = resolveSpawnContextMode(params.context, params.contextEntryIds);
-      const snapshot = modules.context.buildContextSnapshot(
-        ctx.sessionManager.getBranch(),
-        mode,
-        DEFAULT_MAX_CONTEXT_BYTES,
-        params.contextEntryIds
-      );
-      if ((scope === "project" || scope === "both") && !ctx.isProjectTrusted()) {
-        throw new Error("Project-local subagent definitions require a trusted project");
-      }
-      const resolvedAgents = modules.agents.discoverAgents(cwd, scope, currentSettings).agents;
-      const resolvedAgent = resolvedAgents.find((agent) => agent.name === params.agent);
-      if (!resolvedAgent) {
-        const available = resolvedAgents.map((agent) => agent.name).join(", ") || "none";
-        throw new Error(`Unknown subagent ${params.agent}. Available agents: ${available}`);
-      }
-      const targetSnapshot = modules.cwdPolicy.targetPolicyAudit(target);
-      const { executionPlan, semanticSnapshot } = await modules.retainedSemanticState.buildRetainedSemanticState({
-        agent: resolvedAgent,
-        contract,
-        target: targetSnapshot,
-        cwd,
-        workspaceMode: params.workspaceMode === "worktree" ? "worktree" : "shared",
-        transport: transportKind,
-        resultFormat,
-        thinkingLevel: params.thinkingLevel,
-        timeoutMs: params.timeoutMs,
-        taskGeneration: 1
-      });
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const requestHash = modules.spawnIdempotency.hashSpawnRequest({
-        agent: params.agent,
-        taskName: params.taskName,
-        task: params.task,
-        cwd,
-        agentScope: scope,
-        thinkingLevel: params.thinkingLevel,
-        timeoutMs: params.timeoutMs,
-        idleTimeoutMs: params.idleTimeoutMs,
-        maxTurns: params.maxTurns,
-        maxToolCalls: params.maxToolCalls,
-        parentId: params.parentId,
-        context: snapshot.text || void 0,
-        contextSourceIds: snapshot.sourceIds,
-        workspaceMode: params.workspaceMode ?? "shared",
-        allowConcurrentWrites: params.allowConcurrentWrites ?? false,
-        contract,
-        resultFormat,
-        completionRequirement: params.completionRequirement ?? "background"
-      });
-      if (!capturedRegistry) {
-        throw new Error("Stateful subagents are not initialized for this session");
-      }
-      const ownedRegistry = capturedRegistry;
-      const retained = ownedRegistry.findBySpawnIdempotencyKey(params.idempotencyKey, requestHash);
-      if (retained) return result(retained, `Reused ${retained.agent} as ${retained.id}.`);
-      const foundPending = params.idempotencyKey ? pendingIdempotentSpawns.get(params.idempotencyKey) : void 0;
-      if (params.idempotencyKey && foundPending && foundPending.generation !== generation && pendingIdempotentSpawns.get(params.idempotencyKey) === foundPending) {
-        pendingIdempotentSpawns.delete(params.idempotencyKey);
-      }
-      const pending = foundPending?.generation === generation ? foundPending : void 0;
-      if (pending) {
-        if (pending.requestHash !== requestHash) {
-          throw new Error("The subagent_spawn idempotencyKey is pending with different parameters");
-        }
-        const agent = await waitForOwnedSpawn(pending.promise, signal);
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        return result(agent, `Reused ${agent.agent} as ${agent.id}.`);
-      }
-      let resolvePending;
-      let rejectPending;
-      let ownedPending;
-      if (params.idempotencyKey) {
-        const promise = new Promise((resolve, reject) => {
-          resolvePending = resolve;
-          rejectPending = reject;
-        });
-        void promise.catch(() => void 0);
-        ownedPending = { generation, requestHash, promise };
-        pendingIdempotentSpawns.set(params.idempotencyKey, ownedPending);
-      }
-      try {
-        await confirmProjectAgent(
-          params.agent,
-          scope,
-          params.confirmProjectAgents ?? true,
-          ctx,
-          cwd,
-          currentSettings
-        );
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        if (params.workspaceMode === "worktree" && resolvedAgent.source === "project") {
-          throw new Error("Project-local subagent definitions cannot run in a detached worktree");
-        }
-        const requestedCwd = cwd;
-        const workspaceOwner = `pending-${randomUUID()}`;
-        const workspace = params.workspaceMode === "worktree" ? await currentWorkspaceManager.create(workspaceOwner, requestedCwd) : void 0;
-        try {
-          assertCurrentSpawn(signal, generation, runtimeGeneration);
-        } catch (error) {
-          if (workspace) await currentWorkspaceManager.cleanup(workspaceOwner);
-          throw error;
-        }
-        let agent;
-        try {
-          const capabilityGrant = modules.capabilityGrant.issueCapabilityGrant(
-            executionPlan,
-            Date.now(),
-            Math.max(1, (params.timeoutMs ?? resolvedAgent.timeoutMs ?? 6e5) + 6e4)
-          );
-          agent = await ownedRegistry.spawn({
-            agent: params.agent,
-            taskName: params.taskName,
-            task: params.task,
-            cwd: workspace?.path ?? requestedCwd,
-            agentScope: scope,
-            thinkingLevel: params.thinkingLevel,
-            timeoutMs: params.timeoutMs,
-            idleTimeoutMs: params.idleTimeoutMs,
-            maxTurns: params.maxTurns,
-            maxToolCalls: params.maxToolCalls,
-            parentId: params.parentId,
-            context: snapshot.text || void 0,
-            contextSourceIds: snapshot.sourceIds,
-            contextTruncated: snapshot.truncated,
-            contextTurns: snapshot.turns,
-            contextBytes: Buffer.byteLength(snapshot.text, "utf8"),
-            workspaceMode: workspace ? "worktree" : void 0,
-            spawnIdempotencyKey: params.idempotencyKey,
-            spawnRequestHash: params.idempotencyKey ? requestHash : void 0,
-            contract,
-            resultFormat: resultFormat === "text" ? void 0 : resultFormat,
-            completionRequirement: params.completionRequirement ?? "background",
-            executionPlan,
-            capabilityGrant,
-            semanticSnapshot,
-            semanticCompatibility: { status: "compatible", changedComponents: [] },
-            target: targetSnapshot
-          });
-          assertCurrentSpawn(signal, generation, runtimeGeneration);
-        } catch (error) {
-          if (agent) await ownedRegistry.closeTree(agent.id).catch(() => void 0);
-          if (workspace) await currentWorkspaceManager.cleanup(workspaceOwner);
-          throw error;
-        }
-        if (!agent) throw new Error("Subagent spawn completed without a retained agent");
-        if (workspace && agent.cwd === workspace.path) isolatedAgents.set(agent.id, workspaceOwner);
-        else if (workspace) await currentWorkspaceManager.cleanup(workspaceOwner);
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        resolvePending?.(agent);
-        const deliveryNote = completionDelivery === "auto-resume" ? "Auto-resume steers completions into active parent work or requests synthesis when idle. Treat this response as progress, not final synthesis, until every final-answer-required completion message is visible. If local work is exhausted while required children remain active, emit at most one brief progress sentence and end the turn; do not repeat waiting updates or use the requested final format, verdict, or conclusion. Do not redo a running child's assigned work." : "The current response must not depend on the result because next-turn delivery will not wake an idle root.";
-        const requirementNote = params.completionRequirement === "required" ? "This exact run is runtime-tracked as required until its completion becomes visible or reaches an explicit terminal state. Current Pi versions still cannot prevent already-streamed premature output." : "This run is background work and does not block the parent final answer.";
-        return result(
-          agent,
-          `Spawned ${agent.agent} as ${agent.taskPath ?? agent.id} (${agent.id}). ${requirementNote} Continue the identified non-overlapping local work immediately; do not merely announce the spawn or end while useful local work remains. Only an explicit user-requested specialist model, tool-profile, or isolation exception may lack concurrent local work. ${deliveryNote} Do not poll for progress.`
-        );
-      } catch (error) {
-        rejectPending?.(error);
-        throw error;
-      } finally {
-        if (params.idempotencyKey && ownedPending && pendingIdempotentSpawns.get(params.idempotencyKey) === ownedPending) {
-          pendingIdempotentSpawns.delete(params.idempotencyKey);
-        }
-      }
-    }
-  });
-  pi.registerTool(spawnTool);
-  pi.registerTool({
-    name: "subagent_send",
-    label: "Send Subagent Follow-up",
-    description: "Send follow-up work to a reusable retained subagent and start a new turn. Semantic resource skew requires explicit revalidation. Use subagent_mailbox for queue-only messages.",
-    promptSnippet: "Start a new detached follow-up turn on a retained subagent",
-    parameters: Type2.Object({
-      agentId: Type2.String({ description: "Retained agent ID or canonical task path." }),
-      task: Type2.String({ minLength: 1, maxLength: DEFAULT_MAX_CONTEXT_BYTES }),
-      timeoutMs: Type2.Optional(
-        Type2.Integer({
-          minimum: 1,
-          maximum: MAX_SUBAGENT_TIMEOUT_MS,
-          description: "Optional work deadline for this follow-up turn. On expiry, Pi aborts the work and makes one separately bounded summary attempt."
-        })
-      ),
-      ...StatefulTurnLimitFields,
-      completionRequirement: Type2.Optional(CompletionRequirementModeSchema),
-      revalidate: Type2.Optional(
-        Type2.Boolean({
-          description: "Accept the current semantic resource snapshot after a reported mismatch before starting this follow-up."
-        })
-      ),
-      allowConcurrentWrites: Type2.Optional(
-        Type2.Boolean({
-          description: "Deprecated compatibility field; shared-workspace concurrency is allowed by default."
-        })
-      )
-    }),
-    ...createStatefulToolRenderer("send"),
-    async execute(_id, params, signal, _update, ctx) {
-      const generation = runtimeGeneration;
-      const ownedRegistry = requireRegistry();
-      let modules;
-      try {
-        modules = await loadStatefulSpawnModules();
-      } catch (error) {
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        throw error;
-      }
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const currentSettings = getCurrentSettings();
-      const existing = ownedRegistry.get(params.agentId);
-      if (!existing) throw new Error(`Unknown subagent: ${params.agentId}`);
-      const currentAgent = modules.agents.discoverAgents(existing.cwd, existing.agentScope ?? "user", currentSettings).agents.find((agent2) => agent2.name === existing.agent);
-      if (!currentAgent) throw new Error(`Unknown retained subagent definition: ${existing.agent}`);
-      const resolvedFollowUpTarget = existing.workspaceMode === "worktree" ? void 0 : modules.cwdPolicy.resolveSubagentTarget({
-        workspace: ctx.cwd,
-        requestedCwd: existing.cwd,
-        currentProjectTrusted: ctx.isProjectTrusted()
-      });
-      if (resolvedFollowUpTarget) {
-        modules.cwdPolicy.assertDelegationTargetAllowed(
-          resolvedFollowUpTarget,
-          currentSettings?.cwdPolicy?.delegation ?? DEFAULT_DELEGATION_CWD_POLICY
-        );
-      }
-      if (existing.workspaceMode === "worktree" && !existing.target) {
-        throw new Error("Retained worktree is missing its trusted target snapshot");
-      }
-      const currentTarget = existing.workspaceMode === "worktree" && existing.target ? existing.target : modules.cwdPolicy.targetPolicyAudit(
-        resolvedFollowUpTarget
-      );
-      const { executionPlan: currentPlan, semanticSnapshot: currentSnapshot } = await modules.retainedSemanticState.buildRetainedSemanticState({
-        agent: currentAgent,
-        contract: existing.contract,
-        target: currentTarget,
-        cwd: existing.cwd,
-        workspaceMode: existing.workspaceMode === "worktree" ? "worktree" : "shared",
-        transport: transportKind,
-        resultFormat: existing.resultFormat ?? "text",
-        thinkingLevel: existing.thinkingLevel,
-        timeoutMs: params.timeoutMs ?? existing.timeoutMs,
-        taskGeneration: (existing.executionPlan?.taskGeneration ?? 0) + 1,
-        cancellationLineage: [
-          ...existing.executionPlan?.cancellationLineage ?? [],
-          ...existing.state === "interrupted" && existing.executionPlan?.id ? [existing.executionPlan.id] : []
-        ]
-      });
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const compatibility = existing.semanticSnapshot ? modules.semanticSnapshot.evaluateSemanticCompatibility(
-        existing.semanticSnapshot,
-        currentSnapshot
-      ) : { status: "warning", changedComponents: ["legacy-missing-snapshot"] };
-      if ((compatibility.status === "needs-revalidation" || compatibility.status === "rejected") && params.revalidate !== true) {
-        throw new Error(
-          `Subagent semantic resources changed; retry with revalidate: true after reviewing: ${compatibility.changedComponents.join(", ")}`
-        );
-      }
-      await confirmProjectAgent(
-        existing.agent,
-        existing.agentScope ?? "user",
-        false,
-        ctx,
-        existing.cwd,
-        currentSettings
-      );
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const currentGrant = modules.capabilityGrant.issueCapabilityGrant(
-        currentPlan,
-        Date.now(),
-        Math.max(1, (params.timeoutMs ?? existing.timeoutMs ?? 6e5) + 6e4)
-      );
-      await ownedRegistry.updateSemanticState(
-        existing.id,
-        currentPlan,
-        currentGrant,
-        currentSnapshot,
-        params.revalidate === true && compatibility.status !== "compatible" ? { status: "warning", changedComponents: compatibility.changedComponents } : compatibility
-      );
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const agent = await ownedRegistry.followUp(params.agentId, params.task, {
-        timeoutMs: params.timeoutMs,
-        idleTimeoutMs: params.idleTimeoutMs,
-        maxTurns: params.maxTurns,
-        maxToolCalls: params.maxToolCalls,
-        completionRequirement: params.completionRequirement ?? "background"
-      });
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      return result(agent, `Started follow-up for ${agent.id}.`);
-    }
-  });
-  if (blockingEnabled) {
-    pi.registerTool({
-      name: "subagent_await",
-      label: "Await Subagent",
-      description: "Wait for one retained subagent's current turn to settle and return its latest bounded output. This blocks Pi from processing queued steering until the wait finishes. A wait timeout or caller cancellation stops only the wait and never interrupts or closes the subagent; use subagent_manage for lifecycle changes. Automatic completion delivery remains active and may later repeat the same at-least-once completion.",
-      promptSnippet: "Intentionally block until one retained subagent settles or the wait times out",
-      promptGuidelines: [
-        "Use subagent_await only when the retained result is required before the next action, useful overlapping main-agent work is complete, and blocking Pi is intentional.",
-        "Do not repeatedly call subagent_await after a timeout; the subagent keeps running and completion delivery remains active. Use subagent_manage only when the user wants to interrupt or close it."
-      ],
-      parameters: SubagentAwaitParams,
-      ...createStatefulToolRenderer("await"),
-      async execute(_id, params, signal) {
-        const generation = runtimeGeneration;
-        const timeoutMs = params.timeoutMs ?? DEFAULT_SUBAGENT_AWAIT_TIMEOUT_MS;
-        const waited = await requireRegistry().wait(params.agentId, timeoutMs, signal);
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        return awaitResult(waited.agent, waited.timedOut, timeoutMs);
-      }
-    });
-  }
-  pi.registerTool({
-    name: "subagent_manage",
-    label: "Manage Subagents",
-    description: "Interrupt active work while keeping an agent reusable, or close agents and release their resources. Use subagent_inspect for every read-only list, detail, status, and diagnostic operation.",
-    promptSnippet: "Interrupt or close retained detached subagents",
-    parameters: ManageParamsSchema,
-    ...createStatefulToolRenderer("manage"),
-    async execute(_id, params, signal) {
-      const generation = runtimeGeneration;
-      const ownedRegistry = requireRegistry();
-      let currentWorkspaceManager;
-      try {
-        currentWorkspaceManager = await getWorkspaceManager();
-      } catch (error) {
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        throw error;
-      }
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const ownedAgent = (agentId2) => {
-        const value = ownedRegistry.get(agentId2);
-        if (!value) throw new Error(`Unknown subagent: ${agentId2}`);
-        return value;
-      };
-      const operation = validateManageParams(params);
-      const agentId = operation.agentId;
-      if (operation.action === "interrupt") {
-        if (operation.subtree) {
-          const agents = await ownedRegistry.interruptTree(agentId);
-          assertCurrentSpawn(signal, generation, runtimeGeneration);
-          return {
-            content: [{ type: "text", text: `Interrupted ${agents.length} active agent(s).` }],
-            details: {
-              agent: summarizeStatefulAgent(ownedAgent(agentId)),
-              agents: agents.map(summarizeStatefulAgent)
-            }
-          };
-        }
-        const agent2 = await ownedRegistry.interrupt(agentId);
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        return result(agent2, `Interrupted ${agent2.id}; it remains reusable.`);
-      }
-      const existing = ownedRegistry.get(agentId);
-      if (existing?.state === "closed" && !operation.subtree) {
-        const pendingOwner = isolatedAgents.get(existing.id);
-        if (pendingOwner) await currentWorkspaceManager.cleanup(pendingOwner);
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        isolatedAgents.delete(existing.id);
-        return result(existing, `Closed ${existing.id}.`);
-      }
-      if (operation.subtree) {
-        let agents;
-        try {
-          agents = await ownedRegistry.closeTree(agentId);
-        } finally {
-          await cleanupClosedWorkspaces(ownedRegistry, isolatedAgents, currentWorkspaceManager);
-        }
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        return {
-          content: [{ type: "text", text: `Closed ${agents.length} agent(s).` }],
-          details: {
-            agent: summarizeStatefulAgent(ownedAgent(agentId)),
-            agents: agents.map(summarizeStatefulAgent)
-          }
-        };
-      }
-      let agent;
-      try {
-        agent = await ownedRegistry.close(agentId);
-      } finally {
-        await cleanupClosedWorkspaces(ownedRegistry, isolatedAgents, currentWorkspaceManager);
-      }
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      return result(agent, `Closed ${agent.id}.`);
-    }
-  });
-  pi.registerTool({
-    name: "subagent_mailbox",
-    label: "Subagent Mailbox",
-    description: "Queue a bounded message without starting a turn, or read unread mailbox messages. Read acknowledges returned messages by default; use subagent_inspect for metadata-only unread counts.",
-    promptSnippet: "Send or read queue-only detached-subagent mailbox messages",
-    parameters: MailboxParamsSchema,
-    ...createStatefulToolRenderer("mailbox"),
-    async execute(_id, params, signal) {
-      const generation = runtimeGeneration;
-      const ownedRegistry = requireRegistry();
-      const operation = validateMailboxParams(params);
-      if (operation.action === "send") {
-        const message = await ownedRegistry.sendMessage(
-          operation.agentId,
-          operation.message,
-          operation.senderId,
-          operation.deduplicationKey
-        );
-        assertCurrentSpawn(signal, generation, runtimeGeneration);
-        return {
-          content: [{ type: "text", text: `Queued ${message.id} for ${message.recipientId}.` }],
-          details: { message }
-        };
-      }
-      const messages = await ownedRegistry.readMessages(
-        operation.agentId,
-        operation.acknowledge,
-        operation.limit
-      );
-      assertCurrentSpawn(signal, generation, runtimeGeneration);
-      const summaries = messages.map((message) => ({
-        ...message,
-        content: truncateUtf8(message.content, MAX_TOOL_MESSAGE_BYTES).text
-      }));
-      const text = summaries.length ? summaries.map((message) => `${message.id} from ${message.senderId}: ${message.content}`).join("\n") : "No unread messages.";
-      return {
-        content: [{ type: "text", text: truncateUtf8(text, DEFAULT_MAX_CONTEXT_BYTES).text }],
-        details: { messages: summaries }
-      };
-    }
-  });
-  return controller;
-}
-function normalizeContextMode(value) {
-  if (value === void 0) return "none";
-  if (value === "none" || value === "all" || value === "summary") return value;
-  return Math.max(1, Math.floor(value));
-}
-function resolveSpawnContextMode(value, contextEntryIds) {
-  if (value === void 0 && contextEntryIds !== void 0) return "all";
-  return normalizeContextMode(value);
-}
-async function cleanupClosedWorkspaces(registry, isolatedAgents, workspaceManager) {
-  for (const [agentId, owner] of [...isolatedAgents]) {
-    if (registry.get(agentId)?.state !== "closed") continue;
-    await workspaceManager.cleanup(owner);
-    isolatedAgents.delete(agentId);
-  }
-}
-function result(agent, text) {
-  return {
-    content: [{ type: "text", text }],
-    details: { agent: summarizeStatefulAgent(agent) }
-  };
-}
-function awaitResult(agent, timedOut, timeoutMs) {
-  const latestTurn = agent.history.at(-1);
-  const output = timedOut ? "" : truncateUtf8(latestTurn?.output ?? "", DEFAULT_MAX_CONTEXT_BYTES).text;
-  const error = timedOut ? "" : truncateUtf8(agent.error ?? "", MAX_TOOL_MESSAGE_BYTES).text;
-  const text = timedOut ? `Stopped waiting for ${agent.taskPath ?? agent.id} after ${timeoutMs}ms; it remains ${agent.state}. The wait did not interrupt or close the subagent.` : [`Subagent ${agent.taskPath ?? agent.id} settled as ${agent.state}.`, output || error].filter(Boolean).join("\n\n");
-  return {
-    content: [
-      {
-        type: "text",
-        text: truncateUtf8(text, DEFAULT_MAX_CONTEXT_BYTES).text
-      }
-    ],
-    details: {
-      agent: summarizeStatefulAgent(agent),
-      timedOut,
-      timeoutMs,
-      ...output ? { output } : {},
-      ...error ? { error } : {}
-    }
-  };
-}
-function normalizeRuntimeThinkingLevel(value) {
-  return isThinkingLevel(value) ? value : "off";
-}
-
-export {
-  formatStatefulAgentLine,
-  registerStatefulSubagents
-};
-//# sourceMappingURL=chunk-2LMJU25E.ts.map