@narumitw/pi-subagents 2.1.4 → 3.0.0

package/dist/chunks/registry-BT54L6CY.ts

@@ -1,1445 +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 {
-  classifyStructuredOutcome
-} from "./chunk-47SK2QYC.ts";
-import {
-  isCapabilityGrantActive,
-  revokeCapabilityGrant
-} from "./chunk-YPJEN6NU.ts";
-import {
-  copyExecutionPlan,
-  rotateExecutionPlanGeneration
-} from "./chunk-7AAJEUSL.ts";
-import {
-  ROOT_TASK_PATH,
-  deriveTaskName,
-  joinTaskPath,
-  resolveTaskPath,
-  validateTaskName,
-  validateTaskPath
-} from "./chunk-N7BLVXKK.ts";
-import {
-  copyTurnTerminationReport
-} from "./chunk-RTCVYIZA.ts";
-import {
-  validateTurnLimits
-} from "./chunk-ONDTY4EL.ts";
-import {
-  parseAnyStructuredSubagentResult
-} from "./chunk-RSUXZD6S.ts";
-import {
-  projectAgentRecords
-} from "./chunk-KMGKCEO4.ts";
-import {
-  resolveStatefulLimits
-} from "./chunk-VDG7LTYE.ts";
-import "./chunk-4AQSF7AS.ts";
-import {
-  MAX_UNRESOLVED_REQUIRED_COMPLETIONS,
-  beginCompletionRequirement,
-  cancelPendingCompletionRequirements,
-  completionRequirementKey,
-  makeCompletionAvailable,
-  makeCompletionVisible,
-  pendingRequiredCompletionCount
-} from "./chunk-NLT67IZS.ts";
-import {
-  safeTerminalLine
-} from "./chunk-SWGQLFSD.ts";
-import {
-  DEFAULT_MAX_CONTEXT_BYTES,
-  DEFAULT_MAX_OUTPUT_BYTES,
-  MAX_SUBAGENT_TIMEOUT_MS,
-  MAX_TOOL_MESSAGE_BYTES,
-  truncateUtf8
-} from "./chunk-H3FP6DLR.ts";
-
-// src/registry.ts
-import { randomUUID } from "node:crypto";
-
-// src/completion-routing.ts
-function resolveCompletionRecipient(agent, getAgent) {
-  const visited = /* @__PURE__ */ new Set([agent.id]);
-  let parentId = agent.parentId;
-  while (parentId && !visited.has(parentId)) {
-    visited.add(parentId);
-    const parent = getAgent(parentId);
-    if (!parent) break;
-    if (parent.state !== "closed") {
-      return { recipientId: parent.id, recipientPath: parent.taskPath ?? parent.id };
-    }
-    parentId = parent.parentId;
-  }
-  return { recipientId: "root", recipientPath: ROOT_TASK_PATH };
-}
-
-// src/transport.ts
-var FunctionTransport = class {
-  constructor(runner) {
-    this.runner = runner;
-  }
-  runner;
-  kind = "fake";
-  runTurn(agent, task, signal, onProgress) {
-    return this.runner(agent, task, signal, onProgress);
-  }
-};
-function normalizeTransport(transport) {
-  return typeof transport === "function" ? new FunctionTransport(transport) : transport;
-}
-
-// src/registry.ts
-var DEFAULT_STATEFUL_LIMITS = resolveStatefulLimits();
-var MAX_PENDING_COMPLETIONS_PER_AGENT = 20;
-var INITIAL_PERSISTENCE_RETRY_DELAY_MS = 25;
-var MAX_PERSISTENCE_RETRY_DELAY_MS = 1e3;
-function positiveInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new Error(`${label} must be a positive safe integer`);
-  }
-  return value;
-}
-function nonNegativeInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative safe integer`);
-  }
-  return value;
-}
-function validateTurnTimeout(value) {
-  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_SUBAGENT_TIMEOUT_MS) {
-    throw new Error(`Subagent timeoutMs must be between 1 and ${MAX_SUBAGENT_TIMEOUT_MS}`);
-  }
-  return value;
-}
-function clearCurrentTurn(agent) {
-  agent.currentTask = void 0;
-  agent.currentRunId = void 0;
-  agent.currentTurnGeneration = void 0;
-  agent.currentTimeoutMs = void 0;
-  agent.currentIdleTimeoutMs = void 0;
-  agent.currentMaxTurns = void 0;
-  agent.currentMaxToolCalls = void 0;
-  agent.currentMailboxMessageIds = void 0;
-}
-function waitAbortError() {
-  const error = new Error("Subagent wait was aborted");
-  error.name = "AbortError";
-  return error;
-}
-function waitForPersistenceRetry(milliseconds, signal) {
-  if (signal.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, milliseconds);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var AgentRegistry = class {
-  constructor(transport, options = {}) {
-    this.options = options;
-    this.transport = normalizeTransport(transport);
-    this.maxAgents = positiveInteger(
-      options.maxAgents ?? DEFAULT_STATEFUL_LIMITS.maxAgents,
-      "maxAgents"
-    );
-    this.maxActiveTurns = positiveInteger(
-      options.maxActiveTurns ?? DEFAULT_STATEFUL_LIMITS.maxActiveTurns,
-      "maxActiveTurns"
-    );
-    this.maxHistoryTurns = positiveInteger(options.maxHistoryTurns ?? 20, "maxHistoryTurns");
-    this.maxDepth = nonNegativeInteger(
-      options.maxDepth ?? DEFAULT_STATEFUL_LIMITS.maxDepth,
-      "maxDepth"
-    );
-    this.maxChildrenPerAgent = positiveInteger(
-      options.maxChildrenPerAgent ?? DEFAULT_STATEFUL_LIMITS.maxChildrenPerAgent,
-      "maxChildrenPerAgent"
-    );
-    this.maxMailboxMessages = positiveInteger(
-      options.maxMailboxMessages ?? 100,
-      "maxMailboxMessages"
-    );
-    this.maxMailboxMessageBytes = positiveInteger(
-      options.maxMailboxMessageBytes ?? 16 * 1024,
-      "maxMailboxMessageBytes"
-    );
-    this.maxTaskBytes = positiveInteger(
-      options.maxTaskBytes ?? DEFAULT_MAX_CONTEXT_BYTES,
-      "maxTaskBytes"
-    );
-    this.maxTurnOutputBytes = positiveInteger(
-      options.maxTurnOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
-      "maxTurnOutputBytes"
-    );
-    this.idleTtlMs = positiveInteger(options.idleTtlMs ?? 60 * 60 * 1e3, "idleTtlMs");
-    this.now = options.now ?? Date.now;
-  }
-  options;
-  agents = /* @__PURE__ */ new Map();
-  controllers = /* @__PURE__ */ new Map();
-  running = /* @__PURE__ */ new Map();
-  queue = [];
-  changeQueue = Promise.resolve();
-  shutdownController = new AbortController();
-  maxAgents;
-  maxActiveTurns;
-  maxHistoryTurns;
-  maxDepth;
-  maxChildrenPerAgent;
-  maxMailboxMessages;
-  maxMailboxMessageBytes;
-  maxTaskBytes;
-  maxTurnOutputBytes;
-  idleTtlMs;
-  transport;
-  now;
-  lastCompletionAt = 0;
-  restore(records) {
-    const candidates = new Map(
-      projectAgentRecords(
-        records.filter((record) => record.id && record.state !== "closed"),
-        { maxAgents: this.maxAgents, maxDepth: this.maxDepth }
-      ).map((record) => [record.id, record])
-    );
-    const restorable = [];
-    for (const record of candidates.values()) {
-      if (record.parentId && !candidates.has(record.parentId)) continue;
-      if (record.parentId === record.id) continue;
-      const seen = /* @__PURE__ */ new Set([record.id]);
-      let parentId = record.parentId;
-      let rootId = record.id;
-      let cyclic = false;
-      while (parentId) {
-        if (seen.has(parentId)) {
-          cyclic = true;
-          break;
-        }
-        seen.add(parentId);
-        rootId = parentId;
-        parentId = candidates.get(parentId)?.parentId;
-      }
-      const depth = seen.size - 1;
-      if (!cyclic && depth <= this.maxDepth) restorable.push({ record, rootId, depth });
-    }
-    restorable.sort(
-      (left, right) => left.depth - right.depth || left.record.createdAt - right.record.createdAt || left.record.id.localeCompare(right.record.id)
-    );
-    const reservedPaths = new Set(
-      [...this.agents.values()].flatMap(
-        (agent) => agent.state !== "closed" && agent.taskPath ? [agent.taskPath] : []
-      )
-    );
-    for (const { record, rootId, depth } of restorable) {
-      const parentPath = record.parentId ? this.agents.get(record.parentId)?.taskPath : ROOT_TASK_PATH;
-      if (!parentPath) continue;
-      const identity = this.reserveRestoredIdentity(record, parentPath, reservedPaths);
-      for (const completion of record.pendingCompletions ?? []) {
-        this.lastCompletionAt = Math.max(this.lastCompletionAt, completion.createdAt);
-      }
-      this.agents.set(record.id, {
-        ...record,
-        ...identity,
-        state: record.state === "running" || record.state === "starting" ? "interrupted" : record.state,
-        rootId,
-        depth,
-        currentTask: void 0,
-        turnGeneration: record.turnGeneration ?? 0,
-        currentRunId: void 0,
-        currentTurnGeneration: void 0,
-        pendingCompletions: (record.pendingCompletions ?? []).map((completion) => ({
-          ...completion
-        })),
-        currentTimeoutMs: void 0,
-        currentIdleTimeoutMs: void 0,
-        currentMaxTurns: void 0,
-        currentMaxToolCalls: void 0,
-        currentMailboxMessageIds: void 0,
-        children: [],
-        contextSourceIds: [...record.contextSourceIds ?? []],
-        capabilityGrant: record.capabilityGrant?.state === "active" ? revokeCapabilityGrant(record.capabilityGrant, "restore-boundary", this.now()) : record.capabilityGrant,
-        mailbox: (record.mailbox ?? []).slice(-this.maxMailboxMessages).map((message) => ({ ...message, recipientId: record.id })),
-        completionRequirements: (record.completionRequirements ?? []).map((item) => ({
-          ...item
-        })),
-        history: record.history.slice(-this.maxHistoryTurns).map((turn) => ({ ...turn }))
-      });
-      const restored = this.agents.get(record.id);
-      if (restored && restored.state !== "running" && restored.state !== "starting") {
-        restored.completionRequirements = cancelPendingCompletionRequirements(
-          restored.completionRequirements,
-          restored.state,
-          this.now()
-        );
-      }
-    }
-    for (const agent of this.agents.values()) {
-      if (agent.parentId) {
-        const parent = this.agents.get(agent.parentId);
-        if (parent && !parent.children.includes(agent.id)) parent.children.push(agent.id);
-      }
-      for (const completion of agent.pendingCompletions ?? []) {
-        if (!completion.recipientId || !completion.recipientPath) {
-          Object.assign(completion, this.completionRecipient(agent));
-        }
-        this.enqueueCompletionMessage(
-          agent,
-          completion,
-          completion.output || completion.error || "(no output)"
-        );
-      }
-    }
-  }
-  async spawn(input) {
-    if (!input.task.trim()) throw new Error("Subagent tasks cannot be empty");
-    if (input.timeoutMs !== void 0) validateTurnTimeout(input.timeoutMs);
-    validateTurnLimits(input);
-    const existing = this.findBySpawnIdempotencyKey(
-      input.spawnIdempotencyKey,
-      input.spawnRequestHash
-    );
-    if (existing) return existing;
-    this.assertRequiredCompletionCapacity(input.completionRequirement);
-    const task = truncateUtf8(input.task, this.maxTaskBytes).text;
-    const expired = this.evictExpired();
-    let expiryReleaseError;
-    try {
-      await this.releaseAgents(expired);
-    } catch (error) {
-      expiryReleaseError = error;
-    }
-    if (expired.length > 0) await this.changed();
-    if (expiryReleaseError) throw expiryReleaseError;
-    if (this.retainedCount() >= this.maxAgents) {
-      throw new Error(`Subagent capacity reached (${this.maxAgents})`);
-    }
-    const parent = input.parentId ? this.require(input.parentId) : void 0;
-    if (parent?.state === "closed") throw new Error(`Cannot spawn under closed agent ${parent.id}`);
-    if (parent && parent.children.length >= this.maxChildrenPerAgent) {
-      throw new Error(`Agent ${parent.id} child capacity reached (${this.maxChildrenPerAgent})`);
-    }
-    const depth = parent ? parent.depth + 1 : 0;
-    if (depth > this.maxDepth) throw new Error(`Subagent depth limit reached (${this.maxDepth})`);
-    const now = this.now();
-    const id = `sa_${randomUUID()}`;
-    const taskName = input.taskName ? validateTaskName(input.taskName) : deriveTaskName(id);
-    const taskPath = joinTaskPath(parent?.taskPath ?? ROOT_TASK_PATH, taskName);
-    if (this.findByTaskPath(taskPath)) {
-      throw new Error(`Canonical subagent task path is already retained: ${taskPath}`);
-    }
-    const record = {
-      id,
-      taskName,
-      taskPath,
-      agent: input.agent,
-      parentId: parent?.id,
-      rootId: parent?.rootId ?? id,
-      depth,
-      children: [],
-      state: "starting",
-      createdAt: now,
-      updatedAt: now,
-      cwd: input.cwd,
-      agentScope: input.agentScope,
-      thinkingLevel: input.thinkingLevel,
-      timeoutMs: input.timeoutMs,
-      currentTimeoutMs: input.timeoutMs,
-      idleTimeoutMs: input.idleTimeoutMs,
-      currentIdleTimeoutMs: input.idleTimeoutMs,
-      maxTurns: input.maxTurns,
-      currentMaxTurns: input.maxTurns,
-      maxToolCalls: input.maxToolCalls,
-      currentMaxToolCalls: input.maxToolCalls,
-      currentTask: task,
-      turnGeneration: 0,
-      pendingCompletions: [],
-      completionRequirements: [],
-      history: [],
-      mailbox: [],
-      context: input.context,
-      contextSourceIds: input.contextSourceIds,
-      contextTruncated: input.contextTruncated,
-      contextTurns: input.contextTurns,
-      contextBytes: input.contextBytes,
-      workspaceMode: input.workspaceMode,
-      spawnIdempotencyKey: input.spawnIdempotencyKey,
-      spawnRequestHash: input.spawnRequestHash,
-      contract: input.contract,
-      resultFormat: input.resultFormat,
-      executionPlan: input.executionPlan,
-      capabilityGrant: input.capabilityGrant,
-      semanticSnapshot: input.semanticSnapshot,
-      semanticCompatibility: input.semanticCompatibility,
-      target: input.target
-    };
-    this.agents.set(record.id, record);
-    if (parent) {
-      parent.children.push(record.id);
-      parent.updatedAt = now;
-    }
-    await this.changed();
-    this.startTurn(record, task, input, input.completionRequirement);
-    return this.copy(record);
-  }
-  findBySpawnIdempotencyKey(key, requestHash) {
-    if (!key) return void 0;
-    const existing = [...this.agents.values()].find(
-      (agent) => agent.state !== "closed" && agent.spawnIdempotencyKey === key
-    );
-    if (!existing) return void 0;
-    if (!requestHash || existing.spawnRequestHash !== requestHash) {
-      throw new Error(
-        "The subagent_spawn idempotencyKey was already used with different parameters"
-      );
-    }
-    return this.copy(existing);
-  }
-  async followUp(id, task, options = {}) {
-    if (!task.trim()) throw new Error("Subagent tasks cannot be empty");
-    if (options.timeoutMs !== void 0) validateTurnTimeout(options.timeoutMs);
-    validateTurnLimits(options);
-    const boundedTask = truncateUtf8(task, this.maxTaskBytes).text;
-    const agent = this.require(id);
-    if (![
-      "idle",
-      "completed",
-      "partial",
-      "blocked",
-      "needs-input",
-      "abstained",
-      "stale",
-      "interrupted",
-      "failed"
-    ].includes(agent.state)) {
-      throw new Error(`Agent ${id} cannot accept follow-up while ${agent.state}`);
-    }
-    this.assertRequiredCompletionCapacity(options.completionRequirement);
-    const unread = agent.mailbox.filter((message) => !message.readAt).slice(-20);
-    agent.currentMailboxMessageIds = unread.map((message) => message.id);
-    this.startTurn(agent, boundedTask, options, options.completionRequirement);
-    return this.copy(agent);
-  }
-  async updateSemanticState(id, executionPlan, capabilityGrant, snapshot, compatibility) {
-    const agent = this.require(id);
-    if (agent.state === "running" || agent.state === "starting" || agent.state === "closed") {
-      throw new Error(`Agent ${id} cannot update semantic state while ${agent.state}`);
-    }
-    agent.executionPlan = copyExecutionPlan(executionPlan);
-    agent.capabilityGrant = structuredClone(capabilityGrant);
-    agent.semanticSnapshot = structuredClone(snapshot);
-    agent.semanticCompatibility = structuredClone(compatibility);
-    agent.updatedAt = this.now();
-    await this.changed();
-    return this.copy(agent);
-  }
-  async sendMessage(recipientId, content, senderId = "root", deduplicationKey) {
-    if (!content.trim()) throw new Error("Subagent mailbox messages cannot be empty");
-    if (deduplicationKey && deduplicationKey.length > 256) {
-      throw new Error("Subagent mailbox deduplication keys cannot exceed 256 characters");
-    }
-    const sender = senderId === "root" ? void 0 : this.require(senderId);
-    if (sender?.state === "closed")
-      throw new Error(`Closed agent ${sender.id} cannot send messages`);
-    const recipient = this.require(recipientId, sender?.id);
-    if (recipient.state === "closed")
-      throw new Error(`Cannot message closed agent ${recipient.id}`);
-    const message = this.enqueueMessage(recipient, content, sender?.id ?? "root", deduplicationKey);
-    await this.changed();
-    return { ...message };
-  }
-  async readMessages(id, acknowledge = true, limit = this.maxMailboxMessages) {
-    if (!Number.isSafeInteger(limit) || limit < 1) {
-      throw new Error("Subagent mailbox read limit must be a positive safe integer");
-    }
-    const agent = this.require(id);
-    const unread = agent.mailbox.filter((message) => !message.readAt).slice(0, limit);
-    if (acknowledge && unread.length > 0) {
-      const readAt = this.now();
-      for (const message of unread) message.readAt = readAt;
-      await this.changed();
-    }
-    return unread.map((message) => ({ ...message }));
-  }
-  async acknowledgeVisibleMessages(id, messageIds, completionIds = [], visibleAt = this.now()) {
-    const agent = this.require(id);
-    const visibleMessageIds = new Set(messageIds);
-    const visibleCompletionIds = new Set(completionIds);
-    const changedMessages = [];
-    const removedCompletions = [];
-    for (const message of agent.mailbox) {
-      if (message.readAt === void 0 && visibleMessageIds.has(message.id)) {
-        message.readAt = visibleAt;
-        changedMessages.push(message);
-      }
-      if (message.completionId && visibleMessageIds.has(message.id)) {
-        visibleCompletionIds.add(message.completionId);
-      }
-    }
-    for (const owner of this.agents.values()) {
-      for (const completion of owner.pendingCompletions ?? []) {
-        if (!visibleCompletionIds.has(completion.completionId)) continue;
-        if (completion.recipientId !== agent.id && completion.recipientPath !== agent.taskPath) {
-          continue;
-        }
-        removedCompletions.push({ owner, completion });
-      }
-    }
-    if (changedMessages.length === 0 && removedCompletions.length === 0) return;
-    for (const { owner, completion } of removedCompletions) {
-      owner.pendingCompletions = (owner.pendingCompletions ?? []).filter(
-        (candidate) => candidate.completionId !== completion.completionId
-      );
-    }
-    agent.updatedAt = Math.max(agent.updatedAt, visibleAt);
-    try {
-      await this.changed(true);
-    } catch (error) {
-      for (const message of changedMessages) message.readAt = void 0;
-      for (const { owner, completion } of removedCompletions) {
-        owner.pendingCompletions = [...owner.pendingCompletions ?? [], completion].sort(
-          (left, right) => left.createdAt - right.createdAt || left.generation - right.generation
-        );
-      }
-      throw error;
-    }
-  }
-  async wait(id, timeoutMs = 3e4, signal) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
-      throw new Error("Subagent wait timeout must be a positive finite number");
-    }
-    if (signal?.aborted) throw waitAbortError();
-    const agent = this.require(id);
-    const agentId = agent.id;
-    const running = this.running.get(agentId);
-    if (!running) return { timedOut: false, agent: this.copy(agent) };
-    let timer;
-    let onAbort;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("timeout"), Math.max(1, timeoutMs));
-    });
-    const aborted = new Promise((resolve) => {
-      onAbort = () => resolve("aborted");
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-    const result = await Promise.race([running, timeout, aborted]);
-    if (timer) clearTimeout(timer);
-    if (onAbort) signal?.removeEventListener("abort", onAbort);
-    if (result === "aborted") throw waitAbortError();
-    return result === "timeout" ? { timedOut: true, agent: this.copy(this.require(agentId)) } : { timedOut: false, agent: this.copy(result) };
-  }
-  async interruptTree(id) {
-    const results = [];
-    for (const target of this.descendants(id).reverse()) {
-      const agent = this.require(target);
-      if (agent.state === "running" || agent.state === "starting") {
-        results.push(await this.interrupt(target));
-      }
-    }
-    return results;
-  }
-  async interrupt(id) {
-    const agent = this.require(id);
-    const agentId = agent.id;
-    if (agent.state !== "running" && agent.state !== "starting")
-      throw new Error(`Agent ${id} is not running`);
-    if (agent.capabilityGrant?.state === "active") {
-      agent.capabilityGrant = revokeCapabilityGrant(
-        agent.capabilityGrant,
-        "interrupted",
-        this.now()
-      );
-    }
-    if (agent.executionPlan) {
-      agent.executionPlan = rotateExecutionPlanGeneration(agent.executionPlan);
-    }
-    if (agent.state === "starting") {
-      const index = this.queue.findIndex((entry) => entry.agent.id === agentId);
-      if (index >= 0) {
-        const [entry] = this.queue.splice(index, 1);
-        const recipient = this.completionRecipient(agent);
-        const persistedCompletion = {
-          completionId: `completion:${agent.id}:${randomUUID()}`,
-          ...recipient,
-          runId: agent.currentRunId ?? `run:${agent.id}:${randomUUID()}`,
-          generation: agent.currentTurnGeneration ?? agent.turnGeneration ?? 1,
-          task: truncateUtf8(entry.task, 256).text,
-          output: "",
-          error: "Interrupted before execution",
-          createdAt: this.completionCreatedAt()
-        };
-        agent.state = "interrupted";
-        agent.completionRequirements = makeCompletionAvailable(agent.completionRequirements, {
-          runId: persistedCompletion.runId,
-          generation: persistedCompletion.generation,
-          completionId: persistedCompletion.completionId,
-          terminalState: agent.state,
-          updatedAt: persistedCompletion.createdAt
-        });
-        agent.pendingCompletions = [...agent.pendingCompletions ?? [], persistedCompletion];
-        this.enqueueCompletionMessage(agent, persistedCompletion, persistedCompletion.error);
-        clearCurrentTurn(agent);
-        agent.updatedAt = this.now();
-        const persisted = await this.persistTerminalState().then(
-          () => true,
-          () => false
-        );
-        const completion = {
-          ...persistedCompletion,
-          agent: this.copy(agent)
-        };
-        entry.resolve(agent);
-        this.running.delete(agentId);
-        if (persisted) await this.notifyTurnComplete(completion);
-        return this.copy(agent);
-      }
-    }
-    this.controllers.get(agentId)?.abort();
-    await this.running.get(agentId);
-    return this.copy(this.require(agentId));
-  }
-  async closeTree(id) {
-    const results = [];
-    const failures = [];
-    for (const target of this.descendants(id).reverse()) {
-      const agent = this.require(target);
-      if (agent.state === "closed") continue;
-      try {
-        results.push(await this.close(target));
-      } catch (error) {
-        failures.push(error);
-        const closed = this.get(target);
-        if (closed?.state === "closed") results.push(closed);
-      }
-    }
-    if (failures.length > 0) {
-      throw new AggregateError(failures, `Failed to release ${failures.length} subagent(s)`);
-    }
-    return results;
-  }
-  async close(id) {
-    const agent = this.require(id);
-    const agentId = agent.id;
-    if (agent.state === "closed") throw new Error(`Agent ${id} is already closed`);
-    if (agent.children.some((childId) => this.agents.get(childId)?.state !== "closed")) {
-      throw new Error(`Agent ${id} has active descendants; close the subtree instead`);
-    }
-    if (agent.state === "starting" || agent.state === "running") {
-      if (agent.capabilityGrant?.state === "active") {
-        agent.capabilityGrant = revokeCapabilityGrant(agent.capabilityGrant, "closed", this.now());
-      }
-      if (agent.executionPlan) {
-        agent.executionPlan = rotateExecutionPlanGeneration(agent.executionPlan);
-      }
-    }
-    if (agent.state === "starting") {
-      const index = this.queue.findIndex((entry) => entry.agent.id === agentId);
-      if (index >= 0) {
-        const [entry] = this.queue.splice(index, 1);
-        entry.resolve(agent);
-        this.running.delete(agentId);
-      }
-    }
-    this.controllers.get(agentId)?.abort();
-    await this.running.get(agentId)?.catch(() => void 0);
-    agent.state = "closed";
-    agent.updatedAt = this.now();
-    agent.completionRequirements = cancelPendingCompletionRequirements(
-      agent.completionRequirements,
-      agent.state,
-      agent.updatedAt
-    );
-    if (agent.parentId) {
-      const parent = this.agents.get(agent.parentId);
-      if (parent) parent.children = parent.children.filter((childId) => childId !== agentId);
-    }
-    clearCurrentTurn(agent);
-    let releaseError;
-    try {
-      await this.transport.release?.(this.copy(agent));
-    } catch (error) {
-      releaseError = error;
-    }
-    this.pruneClosedAgents();
-    await this.changed();
-    if (releaseError) throw releaseError;
-    return this.copy(agent);
-  }
-  async closeAll() {
-    const roots = [...this.agents.values()].filter((agent) => agent.state !== "closed" && !agent.parentId).map((agent) => agent.id);
-    const results = await Promise.allSettled(roots.map((id) => this.closeTree(id)));
-    const failures = results.flatMap(
-      (result) => result.status === "rejected" ? [result.reason] : []
-    );
-    if (failures.length > 0) {
-      throw new AggregateError(failures, `Failed to close ${failures.length} subagent tree(s)`);
-    }
-  }
-  async shutdown() {
-    this.shutdownController.abort(new Error("Subagent registry is shutting down"));
-    for (const entry of this.queue.splice(0)) {
-      if (entry.agent.capabilityGrant?.state === "active") {
-        entry.agent.capabilityGrant = revokeCapabilityGrant(
-          entry.agent.capabilityGrant,
-          "shutdown",
-          this.now()
-        );
-      }
-      if (entry.agent.executionPlan) {
-        entry.agent.executionPlan = rotateExecutionPlanGeneration(entry.agent.executionPlan);
-      }
-      entry.agent.state = "interrupted";
-      clearCurrentTurn(entry.agent);
-      entry.resolve(entry.agent);
-      this.running.delete(entry.agent.id);
-    }
-    for (const id of this.controllers.keys()) {
-      const agent = this.agents.get(id);
-      if (agent?.capabilityGrant?.state === "active") {
-        agent.capabilityGrant = revokeCapabilityGrant(
-          agent.capabilityGrant,
-          "shutdown",
-          this.now()
-        );
-      }
-      if (agent?.executionPlan) {
-        agent.executionPlan = rotateExecutionPlanGeneration(agent.executionPlan);
-      }
-    }
-    for (const controller of this.controllers.values()) controller.abort();
-    await Promise.all([...this.running.values()].map((turn) => turn.catch(() => void 0)));
-    for (const agent of this.agents.values()) {
-      if (agent.state !== "closed") {
-        if (agent.state === "running" || agent.state === "starting") {
-          agent.state = "interrupted";
-        }
-        agent.completionRequirements = cancelPendingCompletionRequirements(
-          agent.completionRequirements,
-          agent.state,
-          this.now()
-        );
-        clearCurrentTurn(agent);
-      }
-    }
-    let shutdownError;
-    try {
-      await this.transport.shutdown?.();
-    } catch (error) {
-      shutdownError = error;
-    }
-    await this.changed(true);
-    if (shutdownError) throw shutdownError;
-  }
-  inspectionCounts() {
-    let activeAgents = 0;
-    let retainedAgents = 0;
-    for (const agent of this.agents.values()) {
-      if (agent.state === "starting" || agent.state === "running") activeAgents++;
-      if (agent.state !== "closed") retainedAgents++;
-    }
-    return { activeAgents, retainedAgents };
-  }
-  listInspection(includeClosed = false) {
-    return [...this.agents.values()].filter((agent) => includeClosed || agent.state !== "closed").sort((left, right) => left.createdAt - right.createdAt).map((agent) => this.inspectSummary(agent));
-  }
-  getInspection(id) {
-    const agent = this.findReference(id);
-    if (!agent) return void 0;
-    return {
-      ...this.inspectSummary(agent),
-      cwd: agent.cwd,
-      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,
-      currentRunId: agent.currentRunId,
-      currentTurnGeneration: agent.currentTurnGeneration,
-      completionRequirements: (agent.completionRequirements ?? []).map((record) => ({
-        ...record
-      })),
-      error: agent.error,
-      workspaceMode: agent.workspaceMode,
-      contextTurns: agent.contextTurns,
-      contextBytes: agent.contextBytes,
-      contextSources: agent.contextSourceIds?.length,
-      contextTruncated: agent.contextTruncated,
-      contract: agent.contract ? structuredClone(agent.contract) : void 0,
-      resultFormat: agent.resultFormat,
-      target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : void 0,
-      policy: agent.policy ? {
-        inherited: [...agent.policy.inherited],
-        overridden: [...agent.policy.overridden],
-        unsupported: [...agent.policy.unsupported]
-      } : void 0,
-      structuredResult: agent.structuredResult ? copyStructuredResult(agent.structuredResult) : void 0,
-      termination: agent.termination ? copyTurnTerminationReport(agent.termination) : void 0,
-      outcome: agent.outcome ? structuredClone(agent.outcome) : void 0,
-      executionPlan: agent.executionPlan ? copyExecutionPlan(agent.executionPlan) : void 0,
-      capabilityGrant: agent.capabilityGrant ? structuredClone(agent.capabilityGrant) : void 0,
-      semanticSnapshot: agent.semanticSnapshot ? structuredClone(agent.semanticSnapshot) : void 0,
-      semanticCompatibility: agent.semanticCompatibility ? structuredClone(agent.semanticCompatibility) : void 0,
-      telemetry: agent.telemetry ? copyTelemetry(agent.telemetry) : void 0
-    };
-  }
-  list(includeClosed = false, rootId) {
-    return [...this.agents.values()].filter((agent) => !rootId || agent.rootId === rootId).filter((agent) => includeClosed || agent.state !== "closed").sort((a, b) => a.createdAt - b.createdAt).map((agent) => this.copy(agent));
-  }
-  get(reference) {
-    return this.resolveAgent(reference);
-  }
-  resolveAgent(reference, senderId = "root") {
-    const agent = this.findReference(reference, senderId);
-    return agent ? this.copy(agent) : void 0;
-  }
-  reconcileCompletionRequirements(activeRecords, observedState) {
-    if (!observedState) return;
-    for (const agent of this.agents.values()) {
-      agent.completionRequirements = (agent.completionRequirements ?? []).flatMap((record) => {
-        const restored = activeRecords.get(completionRequirementKey(record));
-        if (!restored) return [];
-        if (restored.state === "pending" && agent.state !== "running" && agent.state !== "starting") {
-          return [
-            {
-              ...restored,
-              state: "cancelled",
-              terminalState: "interrupted",
-              updatedAt: Math.max(restored.updatedAt, this.now())
-            }
-          ];
-        }
-        return [{ ...restored }];
-      });
-    }
-  }
-  listPendingCompletions() {
-    return [...this.agents.values()].flatMap(
-      (agent) => (agent.pendingCompletions ?? []).map((completion) => ({
-        ...completion,
-        agent: this.copy(agent)
-      }))
-    ).sort(
-      (left, right) => left.createdAt - right.createdAt || left.generation - right.generation || left.completionId.localeCompare(right.completionId)
-    );
-  }
-  async markCompletionDelivered(completionId, deliveredAt) {
-    const agent = [...this.agents.values()].find(
-      (candidate) => candidate.pendingCompletions?.some((completion) => completion.completionId === completionId)
-    );
-    if (!agent) return;
-    const acknowledged = (agent.pendingCompletions ?? []).find(
-      (completion) => completion.completionId === completionId
-    );
-    if (!acknowledged) return;
-    agent.completionRequirements = makeCompletionVisible(
-      agent.completionRequirements,
-      completionId,
-      deliveredAt
-    );
-    agent.pendingCompletions = (agent.pendingCompletions ?? []).filter(
-      (completion) => completion.completionId !== completionId
-    );
-    if (agent.telemetry) {
-      agent.telemetry = {
-        ...agent.telemetry,
-        updatedAt: deliveredAt,
-        timing: { ...agent.telemetry.timing, completionDeliveredAt: deliveredAt }
-      };
-    }
-    agent.updatedAt = Math.max(agent.updatedAt, deliveredAt);
-    try {
-      await this.changed(true);
-    } catch (error) {
-      agent.completionRequirements = (agent.completionRequirements ?? []).map(
-        (record) => record.completionId === completionId && record.state === "visible" ? { ...record, state: "available", updatedAt: acknowledged.createdAt } : record
-      );
-      if (!agent.pendingCompletions?.some(
-        (completion) => completion.completionId === acknowledged.completionId
-      )) {
-        agent.pendingCompletions = [...agent.pendingCompletions ?? [], acknowledged].sort(
-          (left, right) => left.createdAt - right.createdAt || left.generation - right.generation
-        );
-      }
-      if (agent.telemetry?.timing.completionDeliveredAt === deliveredAt) {
-        const { completionDeliveredAt: _discarded, ...timing } = agent.telemetry.timing;
-        agent.telemetry = { ...agent.telemetry, timing };
-      }
-      throw error;
-    }
-  }
-  async sweepExpired() {
-    const removed = this.evictExpired();
-    let releaseError;
-    try {
-      await this.releaseAgents(removed);
-    } catch (error) {
-      releaseError = error;
-    }
-    if (removed.length > 0) await this.changed();
-    if (releaseError) throw releaseError;
-    return removed.length;
-  }
-  startTurn(agent, task, limits = {}, completionRequirement = "background") {
-    if ((agent.pendingCompletions?.length ?? 0) >= MAX_PENDING_COMPLETIONS_PER_AGENT) {
-      throw new Error(
-        `Agent ${agent.id} has ${MAX_PENDING_COMPLETIONS_PER_AGENT} undelivered completions; wait for delivery before another turn`
-      );
-    }
-    agent.turnGeneration = (agent.turnGeneration ?? 0) + 1;
-    agent.currentTurnGeneration = agent.turnGeneration;
-    agent.currentRunId = `run:${agent.id}:${randomUUID()}`;
-    if (completionRequirement === "required") {
-      agent.completionRequirements = beginCompletionRequirement(agent.completionRequirements, {
-        runId: agent.currentRunId,
-        generation: agent.currentTurnGeneration,
-        createdAt: this.now()
-      });
-    }
-    agent.state = "starting";
-    agent.error = void 0;
-    agent.currentTask = task;
-    agent.currentTimeoutMs = limits.timeoutMs ?? agent.timeoutMs;
-    agent.currentIdleTimeoutMs = limits.idleTimeoutMs ?? agent.idleTimeoutMs;
-    agent.currentMaxTurns = limits.maxTurns ?? agent.maxTurns;
-    agent.currentMaxToolCalls = limits.maxToolCalls ?? agent.maxToolCalls;
-    agent.structuredResult = void 0;
-    agent.termination = void 0;
-    agent.outcome = void 0;
-    agent.updatedAt = this.now();
-    agent.telemetry = {
-      phase: "queued",
-      queuePosition: this.queue.length + 1,
-      updatedAt: agent.updatedAt,
-      timing: { queuedAt: agent.updatedAt },
-      budgetSource: {
-        timeout: agent.currentTimeoutMs === void 0 ? "runtime" : "explicit",
-        idleTimeout: agent.currentIdleTimeoutMs === void 0 ? "runtime" : "explicit",
-        turnLimit: agent.currentMaxTurns === void 0 ? "runtime" : "explicit",
-        toolCallLimit: agent.currentMaxToolCalls === void 0 ? "runtime" : "explicit"
-      }
-    };
-    let resolveQueued;
-    const completion = new Promise((resolve) => {
-      resolveQueued = resolve;
-    });
-    this.running.set(agent.id, completion);
-    this.queue.push({ agent, task, resolve: resolveQueued });
-    this.updateQueuePositions();
-    void this.changed();
-    this.pumpQueue();
-  }
-  pumpQueue() {
-    while (this.controllers.size < this.maxActiveTurns && this.queue.length > 0) {
-      const next = this.queue.shift();
-      if (!next) return;
-      this.runQueuedTurn(next.agent, next.task, next.resolve);
-      this.updateQueuePositions();
-    }
-  }
-  runQueuedTurn(agent, task, resolveQueued) {
-    if (agent.capabilityGrant && agent.executionPlan && !isCapabilityGrantActive(agent.capabilityGrant, agent.executionPlan, this.now())) {
-      agent.state = "failed";
-      agent.error = "Capability grant expired or no longer matches the accepted plan";
-      agent.outcome = classifyStructuredOutcome("failed", "capability-grant-invalid");
-      const recipient = this.completionRecipient(agent);
-      const persistedCompletion = {
-        completionId: `completion:${agent.id}:${randomUUID()}`,
-        ...recipient,
-        runId: agent.currentRunId ?? `run:${agent.id}:${randomUUID()}`,
-        generation: agent.currentTurnGeneration ?? agent.turnGeneration ?? 1,
-        task: truncateUtf8(task, 256).text,
-        output: "",
-        error: truncateUtf8(agent.error, 512).text,
-        createdAt: this.completionCreatedAt()
-      };
-      agent.completionRequirements = makeCompletionAvailable(agent.completionRequirements, {
-        runId: persistedCompletion.runId,
-        generation: persistedCompletion.generation,
-        completionId: persistedCompletion.completionId,
-        terminalState: agent.state,
-        updatedAt: persistedCompletion.createdAt
-      });
-      agent.pendingCompletions = [...agent.pendingCompletions ?? [], persistedCompletion];
-      this.enqueueCompletionMessage(agent, persistedCompletion, persistedCompletion.error ?? "");
-      clearCurrentTurn(agent);
-      agent.updatedAt = this.now();
-      void this.persistTerminalState().then(
-        () => this.notifyTurnComplete({
-          ...persistedCompletion,
-          agent: this.copy(agent)
-        })
-      ).catch(() => void 0).finally(() => {
-        resolveQueued(agent);
-        this.running.delete(agent.id);
-      });
-      return;
-    }
-    const controller = new AbortController();
-    this.controllers.set(agent.id, controller);
-    agent.state = "running";
-    agent.updatedAt = this.now();
-    const startedAt = this.now();
-    const runId = agent.currentRunId ?? `run:${agent.id}:${randomUUID()}`;
-    const turnGeneration = agent.currentTurnGeneration ?? agent.turnGeneration ?? 1;
-    const completionKey = `completion:${agent.id}:${randomUUID()}`;
-    const acceptedPlanId = agent.executionPlan?.id;
-    let completionContent = "";
-    let completionOutput = "";
-    let completionError;
-    const visibleMailboxMessageIds = [...agent.currentMailboxMessageIds ?? []];
-    void this.transport.runTurn(this.copy(agent), task, controller.signal, (progress) => {
-      agent.telemetry = {
-        ...progress,
-        queuePosition: void 0,
-        timing: {
-          queuedAt: agent.telemetry?.timing.queuedAt,
-          ...progress.timing
-        }
-      };
-    }).then(async (outcome) => {
-      if (visibleMailboxMessageIds.length > 0) {
-        await this.acknowledgeVisibleMessages(
-          agent.id,
-          visibleMailboxMessageIds,
-          [],
-          this.now()
-        ).catch(() => void 0);
-      }
-      const output = truncateUtf8(outcome.output, this.maxTurnOutputBytes).text;
-      const error = outcome.error ? truncateUtf8(outcome.error, this.maxTurnOutputBytes).text : void 0;
-      agent.history.push({
-        runId,
-        generation: turnGeneration,
-        task,
-        output,
-        startedAt,
-        completedAt: this.now(),
-        exitCode: outcome.exitCode,
-        truncated: outcome.truncated,
-        termination: outcome.termination ? copyTurnTerminationReport(outcome.termination) : void 0
-      });
-      agent.history = agent.history.slice(-this.maxHistoryTurns);
-      agent.structuredResult = outcome.structuredResult ?? parseAnyStructuredSubagentResult(output, agent.resultFormat);
-      const malformedStructuredResult = agent.resultFormat !== void 0 && agent.resultFormat !== "text" && agent.structuredResult === void 0;
-      const finalizedPartial = outcome.termination?.finalization.status === "completed" && output.trim().length > 0;
-      agent.outcome = outcome.aborted ? classifyStructuredOutcome("interrupted", "transport-aborted") : malformedStructuredResult ? classifyStructuredOutcome("contract-invalid", "malformed-structured-result") : finalizedPartial ? classifyStructuredOutcome("partial", outcome.termination?.reason) : outcome.outcome ?? (agent.structuredResult?.version === "pi-subagents:result:v2" ? classifyStructuredOutcome(
-        agent.structuredResult.status,
-        agent.structuredResult.reasonCode
-      ) : void 0);
-      const staleGeneration = Boolean(
-        acceptedPlanId && agent.executionPlan?.id !== acceptedPlanId
-      );
-      if (staleGeneration) {
-        agent.outcome = classifyStructuredOutcome("stale", "cancelled-generation");
-      }
-      agent.state = staleGeneration ? "stale" : outcome.aborted ? "interrupted" : outcome.exitCode !== 0 && agent.outcome?.status !== "partial" ? "failed" : lifecycleStateForOutcome(agent.outcome?.status);
-      agent.error = error;
-      if (agent.capabilityGrant?.state === "active") {
-        agent.capabilityGrant = revokeCapabilityGrant(
-          agent.capabilityGrant,
-          "turn-settled",
-          this.now()
-        );
-      }
-      agent.policy = outcome.policy;
-      agent.telemetry = outcome.telemetry ? {
-        ...outcome.telemetry,
-        timing: {
-          queuedAt: agent.telemetry?.timing.queuedAt,
-          ...outcome.telemetry.timing
-        },
-        budgetSource: outcome.telemetry.budgetSource ?? agent.telemetry?.budgetSource
-      } : agent.telemetry;
-      agent.termination = outcome.termination ? copyTurnTerminationReport(outcome.termination) : void 0;
-      completionOutput = output;
-      completionError = error;
-      completionContent = output || error || `${agent.id} ${agent.state}`;
-      return agent;
-    }).catch((error) => {
-      const staleGeneration = Boolean(
-        acceptedPlanId && agent.executionPlan?.id !== acceptedPlanId
-      );
-      agent.state = staleGeneration ? "stale" : controller.signal.aborted ? "interrupted" : "failed";
-      agent.outcome = classifyStructuredOutcome(
-        staleGeneration ? "stale" : controller.signal.aborted ? "interrupted" : "failed",
-        staleGeneration ? "cancelled-generation" : controller.signal.aborted ? "transport-aborted" : "transport-error"
-      );
-      if (agent.capabilityGrant?.state === "active") {
-        agent.capabilityGrant = revokeCapabilityGrant(
-          agent.capabilityGrant,
-          "turn-failed",
-          this.now()
-        );
-      }
-      agent.error = truncateUtf8(
-        error instanceof Error ? error.message : String(error),
-        this.maxTurnOutputBytes
-      ).text;
-      agent.history.push({
-        runId,
-        generation: turnGeneration,
-        task,
-        output: "",
-        startedAt,
-        completedAt: this.now(),
-        exitCode: controller.signal.aborted ? 130 : 1
-      });
-      agent.history = agent.history.slice(-this.maxHistoryTurns);
-      agent.telemetry = {
-        ...agent.telemetry ?? {
-          phase: "failed",
-          updatedAt: this.now(),
-          timing: { queuedAt: startedAt }
-        },
-        phase: controller.signal.aborted ? "interrupted" : "failed",
-        failurePhase: agent.telemetry?.phase ?? "running",
-        updatedAt: this.now()
-      };
-      completionError = agent.error;
-      completionContent = agent.error;
-      return agent;
-    }).finally(async () => {
-      const recipient = this.completionRecipient(agent);
-      const persistedCompletion = {
-        completionId: completionKey,
-        ...recipient,
-        runId,
-        generation: turnGeneration,
-        task: truncateUtf8(task, 256).text,
-        output: truncateUtf8(completionOutput, MAX_TOOL_MESSAGE_BYTES).text,
-        error: completionError ? truncateUtf8(completionError, 512).text : void 0,
-        createdAt: this.completionCreatedAt()
-      };
-      agent.completionRequirements = makeCompletionAvailable(agent.completionRequirements, {
-        runId,
-        generation: turnGeneration,
-        completionId: persistedCompletion.completionId,
-        terminalState: agent.state,
-        updatedAt: persistedCompletion.createdAt
-      });
-      agent.pendingCompletions = [...agent.pendingCompletions ?? [], persistedCompletion];
-      this.enqueueCompletionMessage(agent, persistedCompletion, completionContent);
-      clearCurrentTurn(agent);
-      agent.updatedAt = this.now();
-      const persisted = await this.persistTerminalState().then(
-        () => true,
-        () => false
-      );
-      this.controllers.delete(agent.id);
-      const turnCompletion = {
-        ...persistedCompletion,
-        agent: this.copy(agent)
-      };
-      this.running.delete(agent.id);
-      resolveQueued(agent);
-      this.pumpQueue();
-      if (persisted) await this.notifyTurnComplete(turnCompletion);
-    });
-  }
-  updateQueuePositions() {
-    for (const [index, entry] of this.queue.entries()) {
-      if (!entry.agent.telemetry) continue;
-      entry.agent.telemetry = {
-        ...entry.agent.telemetry,
-        queuePosition: index + 1,
-        updatedAt: this.now()
-      };
-    }
-  }
-  completionRecipient(agent) {
-    return resolveCompletionRecipient(agent, (id) => this.agents.get(id));
-  }
-  enqueueCompletionMessage(agent, completion, content) {
-    if (!completion.recipientId || completion.recipientId === "root") return;
-    const recipient = this.agents.get(completion.recipientId);
-    if (!recipient || recipient.state === "closed") return;
-    this.enqueueMessage(
-      recipient,
-      content || "(no output)",
-      agent.id,
-      completion.completionId,
-      completion.completionId
-    );
-  }
-  enqueueMessage(recipient, content, senderId, deduplicationKey, completionId) {
-    if (deduplicationKey) {
-      const existing = recipient.mailbox.find(
-        (message2) => message2.deduplicationKey === deduplicationKey && message2.senderId === senderId
-      );
-      if (existing) return existing;
-    }
-    const bounded = truncateUtf8(content, this.maxMailboxMessageBytes);
-    const message = {
-      id: `msg_${randomUUID()}`,
-      senderId,
-      recipientId: recipient.id,
-      content: bounded.text,
-      createdAt: this.now(),
-      deduplicationKey,
-      completionId
-    };
-    recipient.mailbox.push(message);
-    recipient.mailbox = recipient.mailbox.slice(-this.maxMailboxMessages);
-    recipient.updatedAt = this.now();
-    return message;
-  }
-  descendants(id) {
-    const root = this.require(id);
-    const result = [];
-    const visit = (agent) => {
-      result.push(agent.id);
-      for (const childId of agent.children) {
-        const child = this.agents.get(childId);
-        if (child) visit(child);
-      }
-    };
-    visit(root);
-    return result;
-  }
-  require(reference, senderId = "root") {
-    const agent = this.findReference(reference, senderId);
-    if (!agent) throw new Error(`Unknown subagent: ${safeTerminalLine(reference, 256)}`);
-    return agent;
-  }
-  findReference(reference, senderId = "root") {
-    const direct = this.agents.get(reference);
-    if (direct) return direct;
-    const sender = senderId === "root" ? void 0 : this.agents.get(senderId) ?? this.findByTaskPath(senderId);
-    if (senderId !== "root" && !sender) return void 0;
-    let taskPath;
-    try {
-      taskPath = resolveTaskPath(sender?.taskPath ?? ROOT_TASK_PATH, reference);
-    } catch {
-      return void 0;
-    }
-    return this.findByTaskPath(taskPath);
-  }
-  findByTaskPath(taskPath) {
-    return [...this.agents.values()].find(
-      (agent) => agent.state !== "closed" && agent.taskPath === taskPath
-    );
-  }
-  reserveRestoredIdentity(record, parentPath, reservedPaths) {
-    let taskName;
-    try {
-      taskName = record.taskName ? validateTaskName(record.taskName) : void 0;
-    } catch {
-      taskName = void 0;
-    }
-    if (!taskName && record.taskPath) {
-      try {
-        const storedPath = validateTaskPath(record.taskPath);
-        const storedName = storedPath.slice(storedPath.lastIndexOf("/") + 1);
-        taskName = validateTaskName(storedName);
-      } catch {
-        taskName = void 0;
-      }
-    }
-    taskName ??= deriveTaskName(record.id);
-    let taskPath = joinTaskPath(parentPath, taskName);
-    if (reservedPaths.has(taskPath)) {
-      taskName = deriveTaskName(record.id);
-      taskPath = joinTaskPath(parentPath, taskName);
-    }
-    if (reservedPaths.has(taskPath)) {
-      throw new Error(`Cannot restore duplicate canonical subagent task path: ${taskPath}`);
-    }
-    reservedPaths.add(taskPath);
-    return { taskName, taskPath };
-  }
-  assertRequiredCompletionCapacity(mode) {
-    if (mode !== "required") return;
-    const unresolved = [...this.agents.values()].reduce(
-      (sum, agent) => sum + pendingRequiredCompletionCount(agent),
-      0
-    );
-    if (unresolved >= MAX_UNRESOLVED_REQUIRED_COMPLETIONS) {
-      throw new Error(
-        `Required subagent completion capacity reached (${MAX_UNRESOLVED_REQUIRED_COMPLETIONS}); wait for exact completion visibility or terminalize an existing requirement`
-      );
-    }
-  }
-  retainedCount() {
-    return [...this.agents.values()].filter((agent) => agent.state !== "closed").length;
-  }
-  completionCreatedAt() {
-    this.lastCompletionAt = Math.max(this.now(), this.lastCompletionAt + 1);
-    return this.lastCompletionAt;
-  }
-  evictExpired() {
-    const cutoff = this.now() - this.idleTtlMs;
-    const protectedIds = /* @__PURE__ */ new Set();
-    for (const agent of this.agents.values()) {
-      if (agent.state !== "running" && agent.state !== "starting" && (agent.pendingCompletions?.length ?? 0) === 0) {
-        continue;
-      }
-      let current = agent;
-      while (current) {
-        protectedIds.add(current.id);
-        current = current.parentId ? this.agents.get(current.parentId) : void 0;
-      }
-    }
-    const removed = [];
-    const candidates = [...this.agents.values()].sort((left, right) => right.depth - left.depth);
-    for (const agent of candidates) {
-      if (protectedIds.has(agent.id) || agent.updatedAt >= cutoff) continue;
-      if (agent.children.some((childId) => this.agents.get(childId)?.state !== "closed")) continue;
-      this.agents.delete(agent.id);
-      if (agent.parentId) {
-        const parent = this.agents.get(agent.parentId);
-        if (parent) parent.children = parent.children.filter((childId) => childId !== agent.id);
-      }
-      removed.push(this.copy(agent));
-    }
-    return removed;
-  }
-  async releaseAgents(agents) {
-    if (!this.transport.release || agents.length === 0) return;
-    const results = await Promise.allSettled(
-      agents.map((agent) => this.transport.release?.(agent))
-    );
-    const failures = results.flatMap(
-      (result) => result.status === "rejected" ? [result.reason] : []
-    );
-    if (failures.length > 0) {
-      throw new AggregateError(
-        failures,
-        `Failed to release ${failures.length} subagent transport session(s)`
-      );
-    }
-  }
-  pruneClosedAgents() {
-    const closed = [...this.agents.values()].filter((agent) => agent.state === "closed").sort((left, right) => right.updatedAt - left.updatedAt);
-    for (const agent of closed.slice(this.maxAgents)) this.agents.delete(agent.id);
-  }
-  async persistTerminalState() {
-    let failures = 0;
-    for (; ; ) {
-      try {
-        await this.changed(true);
-        return;
-      } catch (error) {
-        if (this.shutdownController.signal.aborted) throw error;
-        failures++;
-        if (failures === 1) continue;
-        const delay = Math.min(
-          INITIAL_PERSISTENCE_RETRY_DELAY_MS * 2 ** (failures - 2),
-          MAX_PERSISTENCE_RETRY_DELAY_MS
-        );
-        await waitForPersistenceRetry(delay, this.shutdownController.signal);
-      }
-    }
-  }
-  async notifyTurnComplete(completion) {
-    try {
-      await this.options.onTurnComplete?.(completion);
-    } catch {
-    }
-  }
-  changed(propagateError = false) {
-    const snapshot = this.list(true);
-    const next = this.changeQueue.then(async () => {
-      try {
-        await this.options.onChange?.(snapshot);
-      } catch (error) {
-        if (propagateError) throw error;
-      }
-    });
-    this.changeQueue = next.catch(() => void 0);
-    return next;
-  }
-  inspectSummary(agent) {
-    let unreadMessages = 0;
-    for (const message of agent.mailbox) {
-      if (message.readAt === void 0) unreadMessages++;
-    }
-    return {
-      id: agent.id,
-      taskName: agent.taskName,
-      taskPath: agent.taskPath,
-      agent: agent.agent,
-      state: agent.state,
-      createdAt: agent.createdAt,
-      updatedAt: agent.updatedAt,
-      historyCount: agent.history.length,
-      unreadMessages,
-      turnGeneration: agent.turnGeneration ?? 0,
-      pendingCompletionCount: agent.pendingCompletions?.length ?? 0,
-      pendingRequiredCompletionCount: pendingRequiredCompletionCount(agent)
-    };
-  }
-  copy(agent) {
-    return {
-      ...agent,
-      children: [...agent.children],
-      contextSourceIds: [...agent.contextSourceIds ?? []],
-      currentMailboxMessageIds: agent.currentMailboxMessageIds ? [...agent.currentMailboxMessageIds] : void 0,
-      pendingCompletions: (agent.pendingCompletions ?? []).map((completion) => ({
-        ...completion
-      })),
-      completionRequirements: (agent.completionRequirements ?? []).map((record) => ({
-        ...record
-      })),
-      history: agent.history.map((turn) => ({ ...turn })),
-      mailbox: agent.mailbox.map((message) => ({ ...message })),
-      contract: agent.contract ? structuredClone(agent.contract) : void 0,
-      target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : void 0,
-      policy: agent.policy ? {
-        inherited: [...agent.policy.inherited],
-        overridden: [...agent.policy.overridden],
-        unsupported: [...agent.policy.unsupported]
-      } : void 0,
-      structuredResult: agent.structuredResult ? copyStructuredResult(agent.structuredResult) : void 0,
-      termination: agent.termination ? copyTurnTerminationReport(agent.termination) : void 0,
-      outcome: agent.outcome ? structuredClone(agent.outcome) : void 0,
-      executionPlan: agent.executionPlan ? copyExecutionPlan(agent.executionPlan) : void 0,
-      capabilityGrant: agent.capabilityGrant ? structuredClone(agent.capabilityGrant) : void 0,
-      semanticSnapshot: agent.semanticSnapshot ? structuredClone(agent.semanticSnapshot) : void 0,
-      semanticCompatibility: agent.semanticCompatibility ? structuredClone(agent.semanticCompatibility) : void 0,
-      telemetry: agent.telemetry ? copyTelemetry(agent.telemetry) : void 0
-    };
-  }
-};
-function lifecycleStateForOutcome(status) {
-  switch (status) {
-    case "partial":
-      return "partial";
-    case "blocked":
-    case "needs-input":
-    case "abstained":
-    case "stale":
-      return status;
-    case "failed":
-    case "contract-invalid":
-      return "failed";
-    case "interrupted":
-      return "interrupted";
-    default:
-      return "completed";
-  }
-}
-function copyStructuredResult(value) {
-  return structuredClone(value);
-}
-function copyTelemetry(value) {
-  return {
-    ...value,
-    timing: { ...value.timing },
-    usage: value.usage ? { ...value.usage } : void 0,
-    budgetSource: value.budgetSource ? { ...value.budgetSource } : void 0
-  };
-}
-export {
-  AgentRegistry
-};
-//# sourceMappingURL=registry-BT54L6CY.ts.map