privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-2S5EEQPW.mjs

@@ -0,0 +1,1602 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  DEFAULT_WATCHDOG_CONFIG,
+  MainWatchdogRuntime,
+  WATCHDOG_DIFF_TOOL_NAME,
+  captureWatchdogDiffBaseline,
+  childSupervisorMetadata,
+  createMainWatchdogReview,
+  createWatchdogDiffTool,
+  createWatchdogWarningMessage,
+  drainOutstandingWork,
+  evaluateChildToolDiagnostic,
+  formatWatchdogCwdSection,
+  registerNativeSupervisorClient,
+  registerWaitTool,
+  resolveCurrentSessionId,
+  resolveWatchdogReviewModel,
+  startWatchdogDiffBaselineCapture
+} from "./c-UGERXVO2.mjs";
+import {
+  MODEL_ONLY_TOOL,
+  agentStreamOptions,
+  getProjectSubagentsDir,
+  inheritedNestedRouteOf,
+  opencodeSessionHeaders
+} from "./c-DTGPSB46.mjs";
+import {
+  CHILD_WATCHDOG_STATUS_EVENT,
+  INTERCOM_SESSION_IDENTITY_EVENT,
+  MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR,
+  SUBAGENT_WATCHDOG_WARNING_TYPE,
+  appendPermissionAudit,
+  createStructuredOutputToolParameters,
+  decodeChildWatchdogConfig,
+  discoverAgents,
+  formatUnknownAgentError,
+  getAgentDir,
+  permissionArgsPreview,
+  permissionDecision,
+  resolveAgentName,
+  shouldBlockToolForBudget,
+  toolBudgetBlockedMessage,
+  toolBudgetSoftNudge,
+  unknownAgentDiagnosticContext,
+  validateAcceptanceReport,
+  validateStructuredOutputValue
+} from "./c-V4RHQBPQ.mjs";
+import {
+  convertToLlm
+} from "./c-SKMK3PEE.mjs";
+import {
+  Agent
+} from "./c-UPBH5AXY.mjs";
+import {
+  typebox_exports
+} from "./c-RQJJ26T4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-subagents/src/agents/agent-refinements.js?ext=pi-subagents
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var REFINEMENT_FORMAT_VERSION = 1;
+var REFINEMENT_DIR = "refinements";
+var CURRENT_FENCE = "pi-subagents-refinement-current";
+var SNAPSHOTS_FENCE = "pi-subagents-refinement-snapshots-json";
+var MAX_EVIDENCE_ITEMS = 8;
+var MAX_AGE_DAYS = 14;
+var MAX_ITEM_BYTES = 2048;
+var MAX_PACKET_BYTES = 16384;
+var PROPOSAL_AGENT = "reviewer";
+function result(text2, isError = false) {
+  return {
+    content: [{ type: "text", text: text2 }],
+    ...isError ? { isError: true } : {},
+    details: { mode: "management", results: [] }
+  };
+}
+__name(result, "result");
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+__name(record, "record");
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+__name(text, "text");
+function textArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map(text).filter((entry) => entry !== null);
+}
+__name(textArray, "textArray");
+function isoTime(value) {
+  const numberValue = typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  if (numberValue !== void 0)
+    return new Date(numberValue).toISOString();
+  const stringValue = text(value);
+  if (!stringValue)
+    return void 0;
+  const parsed = Date.parse(stringValue);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : void 0;
+}
+__name(isoTime, "isoTime");
+function hashPrompt(systemPrompt) {
+  return createHash("sha256").update(systemPrompt).digest("hex");
+}
+__name(hashPrompt, "hashPrompt");
+function safeAgentFileName(agentName) {
+  const trimmed = agentName.trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) || trimmed.includes("..")) {
+    throw new Error(`Agent name '${agentName}' cannot be used as a refinement file name.`);
+  }
+  return `${trimmed}.md`;
+}
+__name(safeAgentFileName, "safeAgentFileName");
+function getAgentRefinementPath(cwd, agentName) {
+  const refinementRoot = path.join(getProjectSubagentsDir(cwd), REFINEMENT_DIR);
+  const resolvedRoot = path.resolve(refinementRoot);
+  const resolvedPath = path.resolve(refinementRoot, safeAgentFileName(agentName));
+  if (resolvedPath !== path.join(resolvedRoot, path.basename(resolvedPath))) {
+    throw new Error(`Agent name '${agentName}' cannot be used as a refinement file name.`);
+  }
+  return resolvedPath;
+}
+__name(getAgentRefinementPath, "getAgentRefinementPath");
+function readExisting(cwd, agentName) {
+  const filePath = getAgentRefinementPath(cwd, agentName);
+  if (!fs.existsSync(filePath))
+    return { path: filePath };
+  return { path: filePath, parsed: parseRefinementFile(fs.readFileSync(filePath, "utf-8"), filePath) };
+}
+__name(readExisting, "readExisting");
+function extractFence(markdown, fence) {
+  const escaped = fence.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = markdown.match(new RegExp("\\n```" + escaped + "\\n([\\s\\S]*?)\\n```", "m"));
+  return match?.[1] ?? null;
+}
+__name(extractFence, "extractFence");
+function parseRefinementFile(markdown, label = "refinement file") {
+  const metadataMatch = markdown.match(/^<!-- pi-subagents-refinement:v1\n([\s\S]*?)\n-->\n/);
+  if (!metadataMatch?.[1])
+    throw new Error(`${label} is missing refinement metadata.`);
+  const metadataValue = JSON.parse(metadataMatch[1]);
+  const metadataRecord = record(metadataValue);
+  if (!metadataRecord)
+    throw new Error(`${label} metadata must be an object.`);
+  const agent = text(metadataRecord.agent);
+  const revision = metadataRecord.revision;
+  const updatedAt = text(metadataRecord.updatedAt);
+  const base = record(metadataRecord.base);
+  const evidence = record(metadataRecord.evidence);
+  if (!agent || typeof revision !== "number" || !Number.isInteger(revision) || !updatedAt || !base || !evidence) {
+    throw new Error(`${label} metadata is invalid.`);
+  }
+  const source = text(base.source);
+  const filePath = text(base.filePath);
+  const systemPromptSha256 = text(base.systemPromptSha256);
+  if (source !== "builtin" && source !== "package" && source !== "user" && source !== "project")
+    throw new Error(`${label} base source is invalid.`);
+  if (!filePath || !systemPromptSha256)
+    throw new Error(`${label} base metadata is invalid.`);
+  const current = extractFence(markdown, CURRENT_FENCE);
+  if (current === null)
+    throw new Error(`${label} is missing current refinement block.`);
+  const snapshotsRaw = extractFence(markdown, SNAPSHOTS_FENCE) ?? "[]";
+  const snapshotsValue = JSON.parse(snapshotsRaw);
+  if (!Array.isArray(snapshotsValue))
+    throw new Error(`${label} snapshots must be an array.`);
+  const snapshots = snapshotsValue.map((entry, index) => {
+    const item = record(entry);
+    if (!item)
+      throw new Error(`${label} snapshot ${index} must be an object.`);
+    const action = text(item.action);
+    const before = typeof item.before === "string" ? item.before : null;
+    const after = typeof item.after === "string" ? item.after : null;
+    const at = text(item.at);
+    if (typeof item.revision !== "number" || !Number.isInteger(item.revision) || !at || action !== "refine" && action !== "rollback" || before === null || after === null) {
+      throw new Error(`${label} snapshot ${index} is invalid.`);
+    }
+    return {
+      revision: item.revision,
+      at,
+      action,
+      before,
+      after,
+      evidenceIds: textArray(item.evidenceIds),
+      ...text(item.proposalAgent) ? { proposalAgent: text(item.proposalAgent) } : {}
+    };
+  });
+  return {
+    metadata: {
+      agent,
+      revision,
+      updatedAt,
+      base: { source, filePath, systemPromptSha256 },
+      evidence: {
+        maxItems: typeof evidence.maxItems === "number" ? evidence.maxItems : MAX_EVIDENCE_ITEMS,
+        maxAgeDays: typeof evidence.maxAgeDays === "number" ? evidence.maxAgeDays : MAX_AGE_DAYS,
+        itemBytes: typeof evidence.itemBytes === "number" ? evidence.itemBytes : MAX_ITEM_BYTES,
+        totalBytes: typeof evidence.totalBytes === "number" ? evidence.totalBytes : MAX_PACKET_BYTES
+      }
+    },
+    current,
+    snapshots
+  };
+}
+__name(parseRefinementFile, "parseRefinementFile");
+function serializeRefinementFile(parsed) {
+  const metadata = JSON.stringify(parsed.metadata, null, 2);
+  const snapshots = JSON.stringify(parsed.snapshots, null, 2);
+  return [
+    `<!-- pi-subagents-refinement:v${REFINEMENT_FORMAT_VERSION}`,
+    metadata,
+    "-->",
+    "",
+    `# Current refinement for \`${parsed.metadata.agent}\``,
+    "",
+    `\`\`\`${CURRENT_FENCE}`,
+    parsed.current,
+    "```",
+    "",
+    "# Snapshots",
+    "",
+    `\`\`\`${SNAPSHOTS_FENCE}`,
+    snapshots,
+    "```",
+    ""
+  ].join("\n");
+}
+__name(serializeRefinementFile, "serializeRefinementFile");
+function writeRefinementFile(filePath, parsed) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  fs.writeFileSync(tmp, serializeRefinementFile(parsed), "utf-8");
+  fs.renameSync(tmp, filePath);
+}
+__name(writeRefinementFile, "writeRefinementFile");
+function baseMetadata(agent) {
+  return {
+    source: agent.source,
+    filePath: agent.filePath,
+    systemPromptSha256: hashPrompt(agent.systemPrompt)
+  };
+}
+__name(baseMetadata, "baseMetadata");
+function metadataFor(agent, revision, now) {
+  return {
+    agent: agent.name,
+    revision,
+    updatedAt: now,
+    base: baseMetadata(agent),
+    evidence: {
+      maxItems: MAX_EVIDENCE_ITEMS,
+      maxAgeDays: MAX_AGE_DAYS,
+      itemBytes: MAX_ITEM_BYTES,
+      totalBytes: MAX_PACKET_BYTES
+    }
+  };
+}
+__name(metadataFor, "metadataFor");
+function withinAge(at, now = Date.now()) {
+  if (!at)
+    return true;
+  const parsed = Date.parse(at);
+  return Number.isFinite(parsed) && now - parsed <= MAX_AGE_DAYS * 24 * 60 * 60 * 1e3;
+}
+__name(withinAge, "withinAge");
+function tailBytes(value, maxBytes) {
+  const buffer = Buffer.from(value, "utf-8");
+  if (buffer.byteLength <= maxBytes)
+    return value;
+  return buffer.subarray(buffer.byteLength - maxBytes).toString("utf-8");
+}
+__name(tailBytes, "tailBytes");
+function pushCapped(items, item) {
+  if (items.length >= MAX_EVIDENCE_ITEMS)
+    return;
+  items.push({ ...item, outputTail: item.outputTail ? tailBytes(item.outputTail, MAX_ITEM_BYTES) : void 0 });
+}
+__name(pushCapped, "pushCapped");
+function acceptanceFields(value) {
+  const ledger = record(value);
+  if (!ledger)
+    return {};
+  const childReport = record(ledger.childReport);
+  const reviewResult = record(ledger.reviewResult);
+  const reviewFindings = [
+    ...textArray(childReport?.reviewFindings),
+    ...Array.isArray(reviewResult?.findings) ? reviewResult.findings.map((finding) => text(record(finding)?.issue)).filter((entry) => entry !== null) : []
+  ];
+  const residualRisks = textArray(childReport?.residualRisks);
+  return {
+    ...text(ledger.status) ? { acceptanceStatus: text(ledger.status) } : {},
+    ...reviewFindings.length > 0 ? { reviewFindings } : {},
+    ...residualRisks.length > 0 ? { residualRisks } : {}
+  };
+}
+__name(acceptanceFields, "acceptanceFields");
+function controlSignals(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((entry) => {
+    const item = record(entry);
+    if (!item)
+      return null;
+    const message = text(item.message);
+    const reason = text(item.reason);
+    return message ? reason ? `${reason}: ${message}` : message : null;
+  }).filter((entry) => entry !== null);
+}
+__name(controlSignals, "controlSignals");
+function evidencePacket(items) {
+  const packet = [];
+  let bytes = 2;
+  for (const item of items) {
+    const encoded = Buffer.byteLength(JSON.stringify(item), "utf-8") + 1;
+    if (bytes + encoded > MAX_PACKET_BYTES)
+      break;
+    packet.push(item);
+    bytes += encoded;
+  }
+  return packet;
+}
+__name(evidencePacket, "evidencePacket");
+function collectBoundedRefinementEvidence(cwd, agentName, state) {
+  const items = [];
+  const jobs = [...state.asyncJobs.values()].filter((job) => !job.cwd || path.resolve(job.cwd) === path.resolve(cwd)).filter((job) => job.agents?.includes(agentName) || job.steps?.some((step) => step.agent === agentName)).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+  for (const job of jobs) {
+    const at = isoTime(job.updatedAt ?? job.startedAt);
+    if (!withinAge(at))
+      continue;
+    const matchingSteps = job.steps?.filter((step) => step.agent === agentName) ?? [];
+    if (matchingSteps.length === 0) {
+      pushCapped(items, {
+        id: `live:${job.asyncId}`,
+        source: "live-state",
+        runId: job.asyncId,
+        agent: agentName,
+        ...at ? { at } : {},
+        status: job.status,
+        refs: [job.asyncDir]
+      });
+      continue;
+    }
+    for (const [index, step] of matchingSteps.entries()) {
+      const stepRecord = step;
+      pushCapped(items, {
+        id: `live:${job.asyncId}:${index}`,
+        source: "live-state",
+        runId: job.asyncId,
+        agent: agentName,
+        ...at ? { at } : {},
+        status: step.status,
+        ...text(stepRecord.model) ? { model: text(stepRecord.model) } : {},
+        ...text(stepRecord.thinking) ? { thinking: text(stepRecord.thinking) } : {},
+        ...acceptanceFields(stepRecord.acceptance),
+        ...text(step.error) ? { errors: [text(step.error)] } : {},
+        ...text(stepRecord.recentOutput) ? { outputTail: text(stepRecord.recentOutput) } : {},
+        refs: [job.asyncDir]
+      });
+    }
+  }
+  const artifactsDir = path.join(getProjectSubagentsDir(cwd), "artifacts");
+  if (fs.existsSync(artifactsDir)) {
+    const files = fs.readdirSync(artifactsDir).filter((file) => file.endsWith("_meta.json")).map((file) => path.join(artifactsDir, file)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    for (const file of files) {
+      if (items.length >= MAX_EVIDENCE_ITEMS)
+        break;
+      let metadata = null;
+      try {
+        metadata = record(JSON.parse(fs.readFileSync(file, "utf-8")));
+      } catch {
+        metadata = null;
+      }
+      if (!metadata || text(metadata.agent) !== agentName)
+        continue;
+      const stat = fs.statSync(file);
+      const at = isoTime(metadata.timestamp ?? stat.mtimeMs);
+      if (!withinAge(at))
+        continue;
+      const outputPath = file.replace(/_meta\.json$/, "_output.md");
+      const outputTail = fs.existsSync(outputPath) ? tailBytes(fs.readFileSync(outputPath, "utf-8"), MAX_ITEM_BYTES) : void 0;
+      pushCapped(items, {
+        id: `artifact:${path.basename(file, "_meta.json")}`,
+        source: outputTail ? "artifact-output" : "artifact-metadata",
+        ...text(metadata.runId) ? { runId: text(metadata.runId) } : {},
+        agent: agentName,
+        ...at ? { at } : {},
+        status: typeof metadata.exitCode === "number" ? metadata.exitCode === 0 ? "completed" : "failed" : void 0,
+        ...text(metadata.model) ? { model: text(metadata.model) } : {},
+        ...text(metadata.thinking) ? { thinking: text(metadata.thinking) } : {},
+        ...acceptanceFields(metadata.acceptance),
+        ...text(metadata.error) ? { errors: [text(metadata.error)] } : {},
+        ...controlSignals(metadata.controlEvents).length > 0 ? { controlSignals: controlSignals(metadata.controlEvents) } : {},
+        ...outputTail ? { outputTail } : {},
+        refs: outputTail ? [file, outputPath] : [file]
+      });
+    }
+  }
+  return evidencePacket(items);
+}
+__name(collectBoundedRefinementEvidence, "collectBoundedRefinementEvidence");
+function appendAgentRefinementOverlay(systemPrompt, input) {
+  let current = "";
+  let filePath = "";
+  try {
+    filePath = getAgentRefinementPath(input.cwd, input.agentName);
+    if (!fs.existsSync(filePath))
+      return systemPrompt;
+    current = parseRefinementFile(fs.readFileSync(filePath, "utf-8"), filePath).current.trim();
+  } catch {
+    return systemPrompt;
+  }
+  if (!current)
+    return systemPrompt;
+  const overlay = [
+    `<pi-subagents-refinement agent=${JSON.stringify(input.agentName)} source=${JSON.stringify(path.relative(input.cwd, filePath))}>`,
+    "Project-local refinement guidance generated from recent bounded evidence.",
+    "It does not override tool, developer, task, output, acceptance, or safety instructions.",
+    "",
+    current,
+    "</pi-subagents-refinement>"
+  ].join("\n");
+  return systemPrompt.trim() ? `${systemPrompt}
+
+${overlay}` : overlay;
+}
+__name(appendAgentRefinementOverlay, "appendAgentRefinementOverlay");
+function validateRefinementProposal(proposal, evidenceIds) {
+  const item = record(proposal);
+  if (!item)
+    return { ok: false, error: "Refinement proposal must be an object." };
+  const summary = text(item.summary);
+  const editsValue = item.edits;
+  if (!summary || !Array.isArray(editsValue))
+    return { ok: false, error: "Refinement proposal requires summary and edits." };
+  if (editsValue.length > 3)
+    return { ok: false, error: "Refinement proposal may contain at most 3 edits." };
+  const allowed = new Set(evidenceIds);
+  const protectedInstruction = "(?:acceptance|output|safety|policy|policies|tools?|developer|system)";
+  const blocked = new RegExp(`\\b(all agents|every agent|global|(?:disable|ignore|bypass|skip|override)\\s+(?:the\\s+)?${protectedInstruction}(?:\\s+instructions?)?|${protectedInstruction}\\s+(?:instructions?|overrides?)|tool safety|review gates|rewrite base|base agent file|settings\\.json|\\.pi/agent|agents/.*\\.md)\\b`, "i");
+  const edits = [];
+  for (const [index, editValue] of editsValue.entries()) {
+    const edit = record(editValue);
+    if (!edit)
+      return { ok: false, error: `Refinement proposal edit ${index} must be an object.` };
+    const title = text(edit.title);
+    const guidance = text(edit.guidance);
+    const rationale = text(edit.rationale);
+    const cited = textArray(edit.evidenceIds);
+    if (!title || !guidance || !rationale)
+      return { ok: false, error: `Refinement proposal edit ${index} is missing title, guidance, or rationale.` };
+    if (cited.length === 0 || cited.some((id) => !allowed.has(id)))
+      return { ok: false, error: `Refinement proposal edit ${index} must cite known evidence ids.` };
+    if (guidance.includes("```") || guidance.includes("</pi-subagents-refinement>") || blocked.test(guidance))
+      return { ok: false, error: `Refinement proposal edit ${index} contains disallowed guidance.` };
+    edits.push({ title, guidance, rationale, evidenceIds: cited });
+  }
+  return { ok: true, proposal: { summary, edits, rejectedIdeas: textArray(item.rejectedIdeas), residualRisks: textArray(item.residualRisks) } };
+}
+__name(validateRefinementProposal, "validateRefinementProposal");
+function proposalSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["summary", "edits", "residualRisks"],
+    properties: {
+      summary: { type: "string" },
+      edits: {
+        type: "array",
+        maxItems: 3,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["title", "guidance", "evidenceIds", "rationale"],
+          properties: {
+            title: { type: "string" },
+            guidance: { type: "string" },
+            evidenceIds: { type: "array", items: { type: "string" }, minItems: 1 },
+            rationale: { type: "string" }
+          }
+        }
+      },
+      rejectedIdeas: { type: "array", items: { type: "string" } },
+      residualRisks: { type: "array", items: { type: "string" } }
+    }
+  };
+}
+__name(proposalSchema, "proposalSchema");
+function proposalFromChild(child) {
+  for (const entry of child.details?.results ?? []) {
+    if (entry.structuredOutput !== void 0)
+      return entry.structuredOutput;
+  }
+  const output = child.details?.results?.map((entry) => entry.finalOutput ?? "").find((entry) => entry.trim().length > 0) ?? child.content?.map((entry) => entry.text ?? "").find((entry) => entry.trim().length > 0) ?? "";
+  const jsonMatch = output.match(/```(?:json)?\n([\s\S]*?)\n```/) ?? output.match(/({[\s\S]*})/);
+  if (!jsonMatch?.[1])
+    return null;
+  try {
+    return JSON.parse(jsonMatch[1]);
+  } catch {
+    return null;
+  }
+}
+__name(proposalFromChild, "proposalFromChild");
+function proposalTask(agent, current, evidence) {
+  return [
+    `You are a fresh read-only proposal child for project-local refinement of one subagent: ${agent.name}.`,
+    "Do not read files. Do not use write, edit, or shell tools. Use only the evidence packet below.",
+    "Propose at most 2-3 minimal overlay guidance edits.",
+    "Each edit must cite one or more evidence ids from the packet.",
+    "Do not propose base agent file, settings, global, automatic, tool, safety, output, acceptance, developer, or system instruction changes.",
+    "Return only structured output that matches the schema.",
+    "",
+    "Agent metadata:",
+    JSON.stringify({ name: agent.name, source: agent.source, filePath: agent.filePath, basePromptSha256: hashPrompt(agent.systemPrompt) }, null, 2),
+    "",
+    "Current overlay:",
+    current.trim() || "(none)",
+    "",
+    "Evidence packet:",
+    JSON.stringify(evidence, null, 2)
+  ].join("\n");
+}
+__name(proposalTask, "proposalTask");
+function guidanceFromProposal(proposal) {
+  return proposal.edits.map((edit) => `- ${edit.guidance.trim()}`).join("\n");
+}
+__name(guidanceFromProposal, "guidanceFromProposal");
+function resolveOneAgent(cwd, agentName) {
+  const discovered = discoverAgents(cwd, "both");
+  const resolved = resolveAgentName(agentName, discovered.agents);
+  if (resolved.error)
+    return { ok: false, error: resolved.error };
+  if (!resolved.agent)
+    return { ok: false, error: formatUnknownAgentError(agentName, unknownAgentDiagnosticContext(discovered)) };
+  return { ok: true, agent: resolved.agent };
+}
+__name(resolveOneAgent, "resolveOneAgent");
+async function handleRefinementAction(action, params, ctx) {
+  const requestedAgent = params.agent?.trim();
+  if (!requestedAgent)
+    return result(`${action} requires agent. Use /subagents-refine <agent> or subagent({ action: "${action}", agent: "<agent>" }).`, true);
+  let resolved;
+  try {
+    resolved = resolveOneAgent(ctx.cwd, requestedAgent);
+  } catch (error) {
+    return result(error instanceof Error ? error.message : String(error), true);
+  }
+  if (!resolved.ok)
+    return result(resolved.error, true);
+  const agent = resolved.agent;
+  let existing;
+  try {
+    existing = readExisting(ctx.cwd, agent.name);
+  } catch (error) {
+    return result(error instanceof Error ? error.message : String(error), true);
+  }
+  if (action === "refine.show") {
+    if (!existing.parsed)
+      return result(`No refinement overlay exists for '${agent.name}'.`);
+    const currentDigest = hashPrompt(agent.systemPrompt);
+    const drift = existing.parsed.metadata.base.systemPromptSha256 === currentDigest ? "no" : "yes";
+    const history = existing.parsed.snapshots.slice(-5).map((snapshot2) => `- r${snapshot2.revision} ${snapshot2.action} at ${snapshot2.at} (${snapshot2.evidenceIds.length} evidence id${snapshot2.evidenceIds.length === 1 ? "" : "s"})`).join("\n") || "- none";
+    return result([
+      `Refinement overlay for '${agent.name}'`,
+      `Path: ${existing.path}`,
+      `Revision: ${existing.parsed.metadata.revision}`,
+      `Updated: ${existing.parsed.metadata.updatedAt}`,
+      `Base: ${existing.parsed.metadata.base.source} ${existing.parsed.metadata.base.filePath}`,
+      `Base prompt changed since overlay: ${drift}`,
+      "",
+      "Current guidance:",
+      existing.parsed.current.trim() || "(empty)",
+      "",
+      "Recent history:",
+      history
+    ].join("\n"));
+  }
+  if (action === "refine.rollback") {
+    if (!existing.parsed)
+      return result(`No refinement overlay exists for '${agent.name}'.`, true);
+    const latest = existing.parsed.snapshots.at(-1);
+    if (!latest)
+      return result(`No refinement snapshot exists for '${agent.name}'.`, true);
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const nextRevision2 = existing.parsed.metadata.revision + 1;
+    const next2 = {
+      metadata: metadataFor(agent, nextRevision2, now2),
+      current: latest.before,
+      snapshots: [...existing.parsed.snapshots, { revision: nextRevision2, at: now2, action: "rollback", before: existing.parsed.current, after: latest.before, evidenceIds: latest.evidenceIds }]
+    };
+    try {
+      writeRefinementFile(existing.path, next2);
+    } catch (error) {
+      return result(error instanceof Error ? error.message : String(error), true);
+    }
+    return result(`Rolled back refinement overlay for '${agent.name}' to revision ${nextRevision2}.
+Path: ${existing.path}`);
+  }
+  const evidence = collectBoundedRefinementEvidence(ctx.cwd, agent.name, ctx.state);
+  if (evidence.length === 0)
+    return result(`No bounded recent evidence was found for '${agent.name}'. No proposal child was launched and no overlay was written.`);
+  const current = existing.parsed?.current ?? "";
+  const child = await ctx.launchProposalChild(proposalTask(agent, current, evidence), proposalSchema(), ctx.signal);
+  if (child.isError)
+    return result(`Refinement proposal child failed. No overlay was written.`, true);
+  const validation = validateRefinementProposal(proposalFromChild(child), evidence.map((item) => item.id));
+  if (!validation.ok)
+    return result(`${validation.error} No overlay was written.`, true);
+  if (validation.proposal.edits.length === 0)
+    return result(`The proposal child returned no edits for '${agent.name}'. No overlay was written.`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nextRevision = (existing.parsed?.metadata.revision ?? 0) + 1;
+  const after = guidanceFromProposal(validation.proposal);
+  const snapshot = {
+    revision: nextRevision,
+    at: now,
+    action: "refine",
+    before: current,
+    after,
+    evidenceIds: [...new Set(validation.proposal.edits.flatMap((edit) => edit.evidenceIds))],
+    proposalAgent: PROPOSAL_AGENT
+  };
+  const next = {
+    metadata: metadataFor(agent, nextRevision, now),
+    current: after,
+    snapshots: [...existing.parsed?.snapshots ?? [], snapshot]
+  };
+  try {
+    writeRefinementFile(existing.path, next);
+  } catch (error) {
+    return result(error instanceof Error ? error.message : String(error), true);
+  }
+  return result([
+    `Wrote refinement overlay for '${agent.name}' at revision ${nextRevision}.`,
+    `Path: ${existing.path}`,
+    `Evidence items: ${evidence.length}`,
+    `Edits: ${validation.proposal.edits.length}`
+  ].join("\n"));
+}
+__name(handleRefinementAction, "handleRefinementAction");
+
+// node_modules/pi-subagents/src/runs/shared/subagent-prompt-runtime.js?ext=pi-subagents
+import { createHash as createHash2 } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// node_modules/pi-subagents/src/runs/shared/runtime-acknowledged-extensions.js?ext=pi-subagents
+var RUNTIME_EXTENSION_ACK_EVENT = "subagent:acknowledge-extension";
+var MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS = 32;
+var MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH = 128;
+function isRuntimeAcknowledgedExtensionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH && /^[A-Za-z0-9._:@+-]+$/.test(value) && !value.includes("..") && !value.includes("/") && !value.includes("\\");
+}
+__name(isRuntimeAcknowledgedExtensionId, "isRuntimeAcknowledgedExtensionId");
+function projectRuntimeAcknowledgedExtensions(ids) {
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!isRuntimeAcknowledgedExtensionId(id) || seen.has(id))
+      continue;
+    seen.add(id);
+    unique.push(id);
+  }
+  if (unique.length === 0)
+    return void 0;
+  return {
+    version: 1,
+    source: "child-runtime",
+    ids: unique.slice(0, MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
+    omitted: Math.max(0, unique.length - MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS)
+  };
+}
+__name(projectRuntimeAcknowledgedExtensions, "projectRuntimeAcknowledgedExtensions");
+
+// node_modules/pi-subagents/src/runs/shared/tool-availability.js?ext=pi-subagents
+function formatChildToolDiagnostic(diagnostic, options = {}) {
+  const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+  if (options.host === "parent") {
+    return [
+      `${subject} ran as a foreground child, which never loads the parent's ambient extensions, and these child tools were unavailable: ${diagnostic.missing.join(", ")}.`,
+      "The `tools` field is a strict allowlist; it does not load extension code.",
+      ...diagnostic.missingMcpDirectTools?.length ? [`MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}.`] : [],
+      "MCP tools require background children (`async: true`) because only they load ambient extensions.",
+      "For extension tools a foreground child can load, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`."
+    ].join("\n");
+  }
+  return [
+    `${subject} requested unavailable child tools: ${diagnostic.missing.join(", ")}.`,
+    "The `tools` field is a strict allowlist; it does not load extension code.",
+    ...diagnostic.missingMcpDirectTools?.length ? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. Resolved names must match what the host or pi-mcp-adapter registers; check the MCP direct-tool registration before treating this as a tool-call failure.`] : [],
+    "For extension tools, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
+    "For MCP tools, verify the MCP adapter configuration and selected tool names. For builtin tools, verify the name against the installed Pi version."
+  ].join("\n");
+}
+__name(formatChildToolDiagnostic, "formatChildToolDiagnostic");
+
+// node_modules/pi-subagents/src/watchdog/register-child.js?ext=pi-subagents
+function childResolvedConfig(config) {
+  return {
+    ...DEFAULT_WATCHDOG_CONFIG,
+    enabled: true,
+    agentEndTimeoutMs: config.agentEndTimeoutMs,
+    maxWarnings: config.maxWarnings,
+    main: {
+      enabled: true,
+      ...config.model ? { model: config.model } : {},
+      ...config.thinking !== void 0 ? { thinking: config.thinking } : {}
+    },
+    stalemateRepeats: config.stalemateRepeats,
+    cadence: { ...config.cadence },
+    children: {
+      ...DEFAULT_WATCHDOG_CONFIG.children,
+      watchdogTailTimeoutMs: config.watchdogTailTimeoutMs
+    },
+    lsp: { ...config.lsp }
+  };
+}
+__name(childResolvedConfig, "childResolvedConfig");
+function childWarningDetails(details, config) {
+  return {
+    ...details,
+    source: details.source === "lsp" ? "lsp" : "child",
+    ...config.agent ? { agent: config.agent } : {},
+    ...config.runId ? { runId: config.runId } : {}
+  };
+}
+__name(childWarningDetails, "childWarningDetails");
+function registerChildWatchdog(pi, childConfig, writeStatus, structuredTerminal) {
+  if (!childConfig)
+    return void 0;
+  if (!writeStatus)
+    throw new Error("Child watchdog status sink is missing; the host must pass ChildRuntimeConfig.watchdogStatus.");
+  let currentContext;
+  let diffBaseline;
+  let agentSettled = false;
+  let seq = 0;
+  const emitStatus = /* @__PURE__ */ __name((phase, reason, warning) => {
+    writeStatus({
+      type: CHILD_WATCHDOG_STATUS_EVENT,
+      ...childConfig.runId ? { runId: childConfig.runId } : {},
+      ...childConfig.agent ? { agent: childConfig.agent } : {},
+      ...childConfig.childIndex !== void 0 ? { childIndex: childConfig.childIndex, stepIndex: childConfig.childIndex } : {},
+      seq: ++seq,
+      phase,
+      ts: Date.now(),
+      ...reason ? { reason } : {},
+      ...warning ? { warning } : {}
+    });
+  }, "emitStatus");
+  const resolved = childResolvedConfig(childConfig);
+  const runtime = new MainWatchdogRuntime({
+    resolveConfig: /* @__PURE__ */ __name(() => ({ ok: true, config: resolved, errors: [], sources: [{ scope: "session", exists: true }] }), "resolveConfig"),
+    review: createMainWatchdogReview(() => currentContext, { getThinkingLevel: /* @__PURE__ */ __name(() => pi.getThinkingLevel(), "getThinkingLevel"), diffBaseline: /* @__PURE__ */ __name(() => diffBaseline, "diffBaseline") }),
+    reviewDescription: "child model review",
+    reviewChangesOnly: true,
+    displayWarning: /* @__PURE__ */ __name((details, options) => {
+      const childDetails = childWarningDetails(details, childConfig);
+      emitStatus("reviewing", void 0, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}, addressed: false, stalemate: childDetails.state === "stalemate" });
+      const message = createWatchdogWarningMessage(childDetails, { display: true, details: childDetails });
+      if (agentSettled)
+        pi.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, childDetails);
+      else
+        pi.sendMessage(message, options);
+    }, "displayWarning"),
+    displayUserWarning: /* @__PURE__ */ __name((details) => {
+      const childDetails = childWarningDetails(details, childConfig);
+      emitStatus("reviewing", void 0, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}, addressed: false, stalemate: childDetails.state === "stalemate" });
+      pi.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, childDetails);
+    }, "displayUserWarning")
+  });
+  const rememberContext = /* @__PURE__ */ __name((ctx) => {
+    currentContext = ctx;
+  }, "rememberContext");
+  const onRuntimeEvent = pi.on;
+  onRuntimeEvent("session_start", (_event, ctx) => {
+    rememberContext(ctx);
+    diffBaseline = startWatchdogDiffBaselineCapture(ctx.cwd);
+    runtime.bindSession(ctx);
+    emitStatus("idle");
+  });
+  onRuntimeEvent("before_agent_start", (event, ctx) => {
+    agentSettled = false;
+    rememberContext(ctx);
+    runtime.handleBeforeAgentStart(event, ctx);
+  });
+  onRuntimeEvent("turn_end", (event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleTurnEnd(event, ctx, structuredTerminal?.captured === true);
+  });
+  onRuntimeEvent("tool_result", (_event, ctx) => {
+    rememberContext(ctx);
+    runtime.handleToolResult(ctx);
+  });
+  onRuntimeEvent("agent_end", async (event, ctx) => {
+    rememberContext(ctx);
+    emitStatus("reviewing");
+    await runtime.handleAgentEnd(event, ctx);
+    const snapshot = runtime.getSnapshot(ctx.cwd);
+    if (snapshot.status === "failed")
+      emitStatus("failed", snapshot.lastError);
+    else if (snapshot.status === "stale")
+      emitStatus("stale", "review stale");
+    else
+      emitStatus("idle");
+  });
+  onRuntimeEvent("agent_settled", () => {
+    agentSettled = true;
+  });
+  onRuntimeEvent("session_shutdown", () => {
+    currentContext = void 0;
+    runtime.dispose();
+    emitStatus("idle");
+  });
+  return runtime;
+}
+__name(registerChildWatchdog, "registerChildWatchdog");
+
+// node_modules/pi-subagents/src/watchdog/permission-arbiter.js?ext=pi-subagents
+var PermissionDecisionParams = typebox_exports.Object({
+  decision: typebox_exports.String({ enum: ["approve", "deny"] }),
+  reason: typebox_exports.String({ description: "One concise reason for this exact decision." })
+}, { additionalProperties: false });
+function conciseReason(value) {
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 500) : "Watchdog returned an empty reason.";
+}
+__name(conciseReason, "conciseReason");
+function createWatchdogPermissionArbiter(options = {}) {
+  return async (request) => {
+    const preview = permissionArgsPreview(request.args);
+    const createdAt = Date.now();
+    const auditBase = { type: "permission.request", createdAt, toolName: request.toolName, preview, matchedRule: "ask", decisionSource: "watchdog" };
+    appendPermissionAudit(request.auditPath, auditBase);
+    let completed = false;
+    const finish = /* @__PURE__ */ __name((approved, reason, decision2) => {
+      const concise = conciseReason(reason);
+      if (completed)
+        return { approved, reason: concise, source: "watchdog" };
+      completed = true;
+      appendPermissionAudit(request.auditPath, {
+        type: "permission.decision",
+        createdAt: Date.now(),
+        requestCreatedAt: createdAt,
+        toolName: request.toolName,
+        decision: decision2,
+        approved,
+        decisionSource: "watchdog",
+        reason: concise
+      });
+      return { approved, reason: concise, source: "watchdog" };
+    }, "finish");
+    let childConfig;
+    try {
+      childConfig = decodeChildWatchdogConfig(request.rawWatchdogConfig);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return finish(false, `Watchdog permission arbiter configuration is invalid: ${reason}`, "unavailable");
+    }
+    if (!childConfig)
+      return finish(false, "Watchdog permission arbiter is unavailable because the child watchdog is disabled.", "unavailable");
+    if (request.signal?.aborted || request.ctx.signal?.aborted)
+      return finish(false, "Watchdog permission decision was cancelled.", "cancelled");
+    let decision;
+    const tool = {
+      name: "watchdog_permission_decision",
+      label: "Watchdog permission decision",
+      description: "Approve or deny this exact child tool call. Call exactly once.",
+      parameters: PermissionDecisionParams,
+      executionMode: "sequential",
+      async execute(_toolCallId, params) {
+        if (!decision)
+          decision = params;
+        return { content: [{ type: "text", text: "Permission decision recorded." }], details: { recorded: true } };
+      }
+    };
+    let timeout;
+    let agent;
+    let abort;
+    try {
+      const run = /* @__PURE__ */ __name(async () => {
+        const config = childResolvedConfig(childConfig);
+        const selection = await resolveWatchdogReviewModel(request.ctx, config);
+        const auth = selection.auth;
+        const sessionId = request.ctx.sessionManager.getSessionId();
+        const baseStreamFn = options.streamFn ?? ((model, context, streamOptions) => request.ctx.modelRegistry.streamSimple(model, context, streamOptions));
+        const streamFn = /* @__PURE__ */ __name((model, context, streamOptions) => baseStreamFn(model, context, {
+          ...streamOptions,
+          ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+          env: auth.env || streamOptions?.env ? { ...auth.env ?? {}, ...streamOptions?.env ?? {} } : void 0,
+          headers: { ...opencodeSessionHeaders(model, sessionId), ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
+        }), "streamFn");
+        const systemPrompt = [
+          "You are the pi-subagents watchdog permission arbiter.",
+          "Decide only whether this exact non-bash child tool call should proceed.",
+          "Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
+          "Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator.",
+          "",
+          formatWatchdogCwdSection(request.ctx.cwd)
+        ].join("\n");
+        const tools = [tool];
+        agent = new Agent({
+          initialState: {
+            systemPrompt,
+            model: selection.model,
+            thinkingLevel: selection.thinkingLevel,
+            tools
+          },
+          convertToLlm,
+          ...agentStreamOptions(streamFn),
+          getApiKey: /* @__PURE__ */ __name((providerName) => providerName === selection.model.provider ? auth.apiKey : void 0, "getApiKey"),
+          beforeToolCall: /* @__PURE__ */ __name(async ({ toolCall }) => toolCall.name === tool.name ? void 0 : { block: true, reason: `Permission arbiter tool '${toolCall.name}' is not allowed.` }, "beforeToolCall"),
+          toolExecution: "sequential"
+        });
+        await agent.prompt(`Tool: ${request.toolName}
+Redacted arguments: ${preview}`);
+        if (!decision)
+          return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
+        const approved = decision.decision === "approve";
+        return finish(approved, decision.reason, decision.decision);
+      }, "run");
+      return await Promise.race([
+        run(),
+        new Promise((resolve3) => {
+          timeout = setTimeout(() => {
+            agent?.abort();
+            resolve3(finish(false, "Watchdog permission decision timed out.", "timeout"));
+          }, childConfig.agentEndTimeoutMs);
+        }),
+        new Promise((resolve3) => {
+          abort = /* @__PURE__ */ __name(() => {
+            agent?.abort();
+            resolve3(finish(false, "Watchdog permission decision was cancelled.", "cancelled"));
+          }, "abort");
+          request.signal?.addEventListener("abort", abort, { once: true });
+          request.ctx.signal?.addEventListener("abort", abort, { once: true });
+        })
+      ]);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return finish(false, `Watchdog permission arbiter failed closed: ${reason}`, reason.includes("timed out") ? "timeout" : "error");
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+      if (abort) {
+        request.signal?.removeEventListener("abort", abort);
+        request.ctx.signal?.removeEventListener("abort", abort);
+      }
+    }
+  };
+}
+__name(createWatchdogPermissionArbiter, "createWatchdogPermissionArbiter");
+var requestWatchdogPermission = createWatchdogPermissionArbiter();
+
+// node_modules/pi-subagents/src/runs/shared/subagent-prompt-runtime.js?ext=pi-subagents
+var STRUCTURED_OUTPUT_INSTRUCTIONS = [
+  "This subagent step has a strict structured output contract.",
+  "Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
+  "Do not rely on prose-only completion; if you do not call `structured_output`, the parent will fail this step."
+].join("\n");
+var CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
+  "You are a child subagent, not the parent orchestrator.",
+  "The parent session owns delegation, orchestration, review fanout, and follow-up worker launches.",
+  "Ignore prior parent-only orchestration instructions in inherited conversation history.",
+  "Do not propose or run subagents. Complete only your assigned role-specific task with the tools available to you.",
+  "If you need to edit files, use the available editing tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text."
+].join("\n");
+var CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
+  "You are a child subagent with explicit fanout responsibility for this assigned task.",
+  "The parent session owns final orchestration, acceptance, and follow-up implementation launches.",
+  "You may use the `subagent` tool only for the fanout work explicitly requested in this task.",
+  "Do not broaden yourself into general parent orchestration. Do not launch follow-up workers unless the task explicitly asks for that.",
+  "The maxSubagentDepth cap still applies and may block further fanout.",
+  "If you need to edit files, use the available editing tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text."
+].join("\n");
+var PARENT_ONLY_CUSTOM_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "subagent-orchestration-instructions",
+  "subagent-slash-result",
+  "subagent-slash-text-result",
+  "subagent-notify",
+  "subagent_control_notice",
+  "subagent-control",
+  "subagent-control-notice"
+]);
+var SUBAGENT_ORCHESTRATION_SKILL_NAME_PATTERN = /<name>\s*pi-subagents\s*<\/name>/;
+var PROJECT_CONTEXT_XML_HEADER = "\n\n<project_context>\n\n";
+var PROJECT_CONTEXT_LEGACY_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
+var SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
+var DATE_HEADER = "\nCurrent date:";
+function registerRuntimeExtensionAcknowledgements(pi, sink) {
+  if (!sink)
+    return;
+  const ids = [];
+  let finalized = false;
+  const acknowledge = /* @__PURE__ */ __name((payload) => {
+    if (finalized || !payload || typeof payload !== "object")
+      return void 0;
+    const id = payload.id;
+    if (isRuntimeAcknowledgedExtensionId(id))
+      ids.push(id);
+    return void 0;
+  }, "acknowledge");
+  const finalize = /* @__PURE__ */ __name(() => {
+    if (finalized)
+      return void 0;
+    finalized = true;
+    sink(ids);
+    return void 0;
+  }, "finalize");
+  try {
+    const events = pi.events;
+    events?.on?.(RUNTIME_EXTENSION_ACK_EVENT, acknowledge);
+    const onRuntimeEvent = pi.on;
+    onRuntimeEvent("agent_end", finalize);
+    onRuntimeEvent("session_shutdown", finalize);
+  } catch {
+  }
+}
+__name(registerRuntimeExtensionAcknowledgements, "registerRuntimeExtensionAcknowledgements");
+function findSectionEnd(prompt, startIndex, nextHeaders) {
+  let endIndex = prompt.length;
+  for (const header of nextHeaders) {
+    const index = prompt.indexOf(header, startIndex);
+    if (index !== -1 && index < endIndex) {
+      endIndex = index;
+    }
+  }
+  return endIndex;
+}
+__name(findSectionEnd, "findSectionEnd");
+function stripProjectContext(prompt) {
+  const xmlStartIndex = prompt.indexOf(PROJECT_CONTEXT_XML_HEADER);
+  if (xmlStartIndex !== -1) {
+    const closingTag = "</project_context>";
+    const closingIndex = prompt.indexOf(closingTag, xmlStartIndex + PROJECT_CONTEXT_XML_HEADER.length);
+    if (closingIndex !== -1) {
+      return `${prompt.slice(0, xmlStartIndex)}${prompt.slice(closingIndex + closingTag.length)}`;
+    }
+  }
+  const legacyStartIndex = prompt.indexOf(PROJECT_CONTEXT_LEGACY_HEADER);
+  if (legacyStartIndex === -1)
+    return prompt;
+  const endIndex = findSectionEnd(prompt, legacyStartIndex + PROJECT_CONTEXT_LEGACY_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
+  return `${prompt.slice(0, legacyStartIndex)}${prompt.slice(endIndex)}`;
+}
+__name(stripProjectContext, "stripProjectContext");
+var GLOBAL_CONTEXT_FILE_NAMES = /* @__PURE__ */ new Set(["agents.md", "agents.override.md", "claude.md"]);
+function canonicalDirectory(dir) {
+  try {
+    return fs2.realpathSync(dir);
+  } catch {
+    return path2.resolve(dir);
+  }
+}
+__name(canonicalDirectory, "canonicalDirectory");
+function expandContextPath(filePath) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  return filePath === "~" ? home ?? filePath : /^~[\\/]/.test(filePath) ? path2.join(home ?? "~", filePath.slice(2)) : filePath;
+}
+__name(expandContextPath, "expandContextPath");
+function isContextFilePath(filePath) {
+  return GLOBAL_CONTEXT_FILE_NAMES.has(path2.basename(expandContextPath(filePath)).toLowerCase());
+}
+__name(isContextFilePath, "isContextFilePath");
+function isGlobalContextFile(filePath) {
+  const expanded = expandContextPath(filePath);
+  if (!isContextFilePath(filePath))
+    return false;
+  return canonicalDirectory(path2.dirname(expanded)) === canonicalDirectory(getAgentDir());
+}
+__name(isGlobalContextFile, "isGlobalContextFile");
+function stripGlobalInstructionsFromXmlContext(context) {
+  const block = /<project_instructions\s+path=(["'])(.*?)\1\s*>[\s\S]*?<\/project_instructions>\s*/gi;
+  return context.replace(block, (match, _quote, filePath) => isGlobalContextFile(filePath) ? "" : match);
+}
+__name(stripGlobalInstructionsFromXmlContext, "stripGlobalInstructionsFromXmlContext");
+function stripGlobalInstructionsFromLegacyContext(context) {
+  const sections = [...context.matchAll(/^## ([^\r\n]+)(?:\r?\n|$)/gm)].filter((match) => isContextFilePath(match[1].trim()));
+  let rewritten = "";
+  let cursor = 0;
+  for (let index = 0; index < sections.length; index++) {
+    const section = sections[index];
+    const start = section.index;
+    const end = sections[index + 1]?.index ?? context.length;
+    rewritten += context.slice(cursor, start);
+    if (!isGlobalContextFile(section[1].trim()))
+      rewritten += context.slice(start, end);
+    cursor = end;
+  }
+  return `${rewritten}${context.slice(cursor)}`;
+}
+__name(stripGlobalInstructionsFromLegacyContext, "stripGlobalInstructionsFromLegacyContext");
+function stripGlobalContext(prompt) {
+  const rewrittenXml = prompt.replace(/<project_context>[\s\S]*?<\/project_context>/gi, (context) => {
+    const rewritten = stripGlobalInstructionsFromXmlContext(context);
+    return /<project_instructions\b/i.test(rewritten) ? rewritten : "";
+  });
+  const legacyStartIndex = rewrittenXml.indexOf(PROJECT_CONTEXT_LEGACY_HEADER);
+  if (legacyStartIndex === -1)
+    return rewrittenXml;
+  const legacyEndIndex = findSectionEnd(rewrittenXml, legacyStartIndex + PROJECT_CONTEXT_LEGACY_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
+  const legacyContext = rewrittenXml.slice(legacyStartIndex, legacyEndIndex);
+  return `${rewrittenXml.slice(0, legacyStartIndex)}${stripGlobalInstructionsFromLegacyContext(legacyContext)}${rewrittenXml.slice(legacyEndIndex)}`;
+}
+__name(stripGlobalContext, "stripGlobalContext");
+function stripInheritedSkills(prompt) {
+  const startIndex = prompt.indexOf(SKILLS_HEADER);
+  if (startIndex === -1)
+    return prompt;
+  const endIndex = findSectionEnd(prompt, startIndex + SKILLS_HEADER.length, [DATE_HEADER]);
+  return `${prompt.slice(0, startIndex)}${prompt.slice(endIndex)}`;
+}
+__name(stripInheritedSkills, "stripInheritedSkills");
+function stripSubagentOrchestrationSkill(prompt) {
+  return prompt.replace(/\n{0,2}<skill\s+name=["']pi-subagents["'][^>]*>[\s\S]*?<\/skill>\n{0,2}/g, "\n\n").replace(/[ \t]*<skill>\s*[\s\S]*?<\/skill>\s*/g, (block) => SUBAGENT_ORCHESTRATION_SKILL_NAME_PATTERN.test(block) ? "" : block);
+}
+__name(stripSubagentOrchestrationSkill, "stripSubagentOrchestrationSkill");
+function stripChildBoundaryInstructions(prompt) {
+  let rewritten = prompt;
+  for (const instructions of [CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS, CHILD_FANOUT_BOUNDARY_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS]) {
+    rewritten = rewritten.split(`
+
+${instructions}`).join("").split(instructions).join("");
+  }
+  return rewritten.replace(/^(?:[ \t]*\r?\n)+/, "");
+}
+__name(stripChildBoundaryInstructions, "stripChildBoundaryInstructions");
+function stripInheritedPromptText(prompt, options) {
+  let rewritten = prompt;
+  if (!options.inheritProjectContext) {
+    rewritten = stripProjectContext(rewritten);
+  }
+  if (!options.inheritGlobalContext) {
+    rewritten = stripGlobalContext(rewritten);
+  }
+  if (!options.inheritSkills) {
+    rewritten = stripInheritedSkills(rewritten);
+  }
+  return stripChildBoundaryInstructions(stripSubagentOrchestrationSkill(rewritten));
+}
+__name(stripInheritedPromptText, "stripInheritedPromptText");
+function appendChildBoundary(prompt, options) {
+  const boundary = options.fanoutChild ? CHILD_FANOUT_BOUNDARY_INSTRUCTIONS : CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS;
+  const structured = options.structuredOutput ? `
+
+${STRUCTURED_OUTPUT_INSTRUCTIONS}` : "";
+  return `${stripChildBoundaryInstructions(prompt)}
+
+${boundary}${structured}`;
+}
+__name(appendChildBoundary, "appendChildBoundary");
+function rewriteSubagentPrompt(prompt, options) {
+  return appendChildBoundary(stripInheritedPromptText(prompt, options), options);
+}
+__name(rewriteSubagentPrompt, "rewriteSubagentPrompt");
+function filterChildPromptOptions(options, inherited) {
+  if (!inherited.inheritProjectContext)
+    options.contextFiles = [];
+  else if (!inherited.inheritGlobalContext)
+    options.contextFiles = options.contextFiles.filter((file) => !isGlobalContextFile(file.path));
+  options.skills = inherited.inheritSkills ? options.skills.filter((skill) => skill.name !== "pi-subagents") : [];
+  if (options.customPrompt)
+    options.customPrompt = stripInheritedPromptText(options.customPrompt, inherited);
+  if (options.appendSystemPrompt)
+    options.appendSystemPrompt = stripInheritedPromptText(options.appendSystemPrompt, inherited);
+}
+__name(filterChildPromptOptions, "filterChildPromptOptions");
+function rewritesChildPrompt(config) {
+  return config.inheritProjectContext !== void 0 || config.inheritGlobalContext !== void 0 || config.inheritSkills !== void 0 || Boolean(config.fanoutChild);
+}
+__name(rewritesChildPrompt, "rewritesChildPrompt");
+function registerSubagentPromptBoundary(pi, config) {
+  if (!rewritesChildPrompt(config))
+    return;
+  pi.on("before_agent_start", (event) => {
+    const finalized = appendChildBoundary(event.systemPrompt, { fanoutChild: config.fanoutChild, structuredOutput: Boolean(config.structuredOutput) });
+    return finalized === event.systemPrompt ? void 0 : { systemPrompt: finalized };
+  });
+}
+__name(registerSubagentPromptBoundary, "registerSubagentPromptBoundary");
+function isParentOnlySubagentMessage(message) {
+  const m = message;
+  if (m?.role !== "custom" || typeof m.customType !== "string")
+    return false;
+  if (m.customType === SUBAGENT_WATCHDOG_WARNING_TYPE)
+    return true;
+  return PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
+}
+__name(isParentOnlySubagentMessage, "isParentOnlySubagentMessage");
+function isSubagentToolResultMessage(message) {
+  const m = message;
+  return m?.role === "toolResult" && m.toolName === "subagent";
+}
+__name(isSubagentToolResultMessage, "isSubagentToolResultMessage");
+function isSubagentToolCallBlock(block) {
+  const b = block;
+  return b?.type === "toolCall" && b.name === "subagent";
+}
+__name(isSubagentToolCallBlock, "isSubagentToolCallBlock");
+var PORTABLE_TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var MAX_PORTABLE_TOOL_ID_LENGTH = 64;
+var COMPOSITE_TOOL_ID_APIS = /* @__PURE__ */ new Set([
+  "azure-openai-responses",
+  "cursor-native",
+  "openai-completions",
+  "openai-responses"
+]);
+var PROMPT_CACHE_KEY_APIS = /* @__PURE__ */ new Set([
+  "azure-openai-responses",
+  "openai-codex-responses",
+  "openai-completions",
+  "openai-responses"
+]);
+var isSystemMessage = /* @__PURE__ */ __name((message) => message.role === "system", "isSystemMessage");
+var writtenSince = /* @__PURE__ */ __name((message, forkedAt) => typeof message.timestamp === "number" && message.timestamp >= forkedAt, "writtenSince");
+function toolsDeclaredBefore(messages, forkedAt) {
+  const tools = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!isSystemMessage(message) || writtenSince(message, forkedAt))
+      continue;
+    for (const tool of message.toolsRemoved ?? [])
+      tools.delete(tool.name);
+    for (const tool of message.toolsAdded ?? [])
+      tools.set(tool.name, tool);
+  }
+  return [...tools.values()];
+}
+__name(toolsDeclaredBefore, "toolsDeclaredBefore");
+function keepInheritedToolDeclarations(messages, inherited, forkedAt) {
+  const older = /* @__PURE__ */ __name((message) => typeof message.timestamp === "number" && message.timestamp < forkedAt, "older");
+  if (inherited.length === 0 || !messages.some(older))
+    return messages;
+  const names = new Set(inherited.map((tool) => tool.name));
+  let changed = false;
+  let next = messages.map((message) => {
+    if (!isSystemMessage(message) || !writtenSince(message, forkedAt) || !message.toolsRemoved?.some((tool) => names.has(tool.name)))
+      return message;
+    changed = true;
+    const { toolsRemoved, ...rest } = message;
+    const kept = toolsRemoved.filter((tool) => !names.has(tool.name));
+    return kept.length > 0 ? { ...rest, toolsRemoved: kept } : rest;
+  });
+  const declared = new Map(toolsDeclaredBefore(next, Number.POSITIVE_INFINITY).map((tool) => [tool.name, tool]));
+  const wanted = [...inherited.map((tool) => declared.get(tool.name) ?? tool), ...[...declared.values()].filter((tool) => !names.has(tool.name))];
+  const order = [...declared.keys()];
+  const head = next[0];
+  if (head && isSystemMessage(head) && wanted.some((tool, index) => order[index] !== tool.name)) {
+    changed = true;
+    const { toolsRemoved: _removed, ...rest } = head;
+    next = [{ ...rest, toolsAdded: wanted }, ...next.slice(1)];
+  }
+  return changed ? next : messages;
+}
+__name(keepInheritedToolDeclarations, "keepInheritedToolDeclarations");
+function rewriteForkCacheProviderRequest(event, ctx, forkCacheKey) {
+  const key = forkCacheKey?.trim();
+  if (!key || !PROMPT_CACHE_KEY_APIS.has(ctx?.model?.api ?? ""))
+    return void 0;
+  if (!event || typeof event !== "object")
+    return void 0;
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return void 0;
+  if (typeof payload.prompt_cache_key !== "string")
+    return void 0;
+  return { ...payload, prompt_cache_key: key };
+}
+__name(rewriteForkCacheProviderRequest, "rewriteForkCacheProviderRequest");
+function portableToolId(id, preserveBoundedCompositeToolIds = false) {
+  if (PORTABLE_TOOL_ID_PATTERN.test(id) && id.length <= MAX_PORTABLE_TOOL_ID_LENGTH)
+    return id;
+  if (preserveBoundedCompositeToolIds) {
+    const parts = id.split("|");
+    if (parts.length === 2 && parts.every((part) => PORTABLE_TOOL_ID_PATTERN.test(part) && part.length <= MAX_PORTABLE_TOOL_ID_LENGTH))
+      return id;
+  }
+  const encoded = `tool_${Buffer.from(id).toString("base64url") || "empty"}`;
+  if (encoded.length <= MAX_PORTABLE_TOOL_ID_LENGTH)
+    return encoded;
+  return `tool_${createHash2("sha256").update(id).digest("base64url")}`;
+}
+__name(portableToolId, "portableToolId");
+function sanitizeToolHistoryMessage(message, preserveBoundedCompositeToolIds = false) {
+  const m = message;
+  if (m?.role === "toolResult" && typeof m.toolCallId === "string") {
+    const toolCallId = portableToolId(m.toolCallId, preserveBoundedCompositeToolIds);
+    return toolCallId === m.toolCallId ? message : { ...m, toolCallId };
+  }
+  if (m?.role !== "assistant" || !Array.isArray(m.content))
+    return message;
+  let changed = false;
+  const content = m.content.map((block) => {
+    const b = block;
+    if (b?.type !== "toolCall" || typeof b.id !== "string")
+      return block;
+    const id = portableToolId(b.id, preserveBoundedCompositeToolIds);
+    if (id === b.id)
+      return block;
+    changed = true;
+    return { ...b, id };
+  });
+  return changed ? { ...m, content } : message;
+}
+__name(sanitizeToolHistoryMessage, "sanitizeToolHistoryMessage");
+function stripAssistantSubagentToolCallBlocks(message) {
+  const m = message;
+  if (m?.role !== "assistant" || !Array.isArray(m.content))
+    return message;
+  const filteredContent = m.content.filter((block) => !isSubagentToolCallBlock(block));
+  if (filteredContent.length === m.content.length)
+    return message;
+  if (filteredContent.length === 0)
+    return void 0;
+  return { ...m, content: filteredContent };
+}
+__name(stripAssistantSubagentToolCallBlocks, "stripAssistantSubagentToolCallBlocks");
+function stripParentOnlySubagentMessages(messages, options = {}) {
+  const preserveCurrentFanoutToolHistory = options.preserveFanoutToolHistory === true;
+  const sanitizeToolIds = options.sanitizeToolIds ?? true;
+  const inheritedBefore = options.inheritedBefore;
+  const inherited = /* @__PURE__ */ __name((message) => inheritedBefore !== void 0 && typeof message?.timestamp === "number" && message.timestamp < inheritedBefore, "inherited");
+  let changed = false;
+  const filtered = [];
+  for (const message of messages) {
+    const keep = inherited(message);
+    if (!keep && (isParentOnlySubagentMessage(message) || !preserveCurrentFanoutToolHistory && isSubagentToolResultMessage(message))) {
+      changed = true;
+      continue;
+    }
+    const stripped = keep || preserveCurrentFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
+    if (stripped === void 0) {
+      changed = true;
+      continue;
+    }
+    const sanitized = sanitizeToolIds ? sanitizeToolHistoryMessage(stripped, options.preserveBoundedCompositeToolIds === true) : stripped;
+    if (stripped !== message || sanitized !== stripped)
+      changed = true;
+    filtered.push(sanitized);
+  }
+  return changed ? filtered : messages;
+}
+__name(stripParentOnlySubagentMessages, "stripParentOnlySubagentMessages");
+function registerPermissionGate(pi, permissions, childWatchdog, requestPermission = requestWatchdogPermission) {
+  const rules = permissions?.rules;
+  if (!rules || Object.keys(rules).length === 0)
+    return;
+  const rawWatchdogConfig = childWatchdog ? JSON.stringify(childWatchdog) : void 0;
+  const timeoutMs = childWatchdog?.agentEndTimeoutMs ?? 3e4;
+  const onRuntimeEvent = pi.on;
+  onRuntimeEvent("tool_call", async (event, ctx) => {
+    const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+    const decision = permissionDecision(rules, toolName);
+    if (decision === "allow")
+      return void 0;
+    if (decision === "deny")
+      return { block: true, reason: `Blocked by pi-subagents permission rule: '${toolName}' is denied.` };
+    if (ctx.signal?.aborted)
+      return { block: true, reason: "Blocked by pi-subagents permission rule: Watchdog permission decision was cancelled." };
+    let timeout;
+    let abort;
+    let result2;
+    try {
+      result2 = await Promise.race([
+        requestPermission({
+          ctx,
+          toolName,
+          args: event.input ?? {},
+          rawWatchdogConfig,
+          auditPath: permissions.auditPath,
+          ...ctx.signal ? { signal: ctx.signal } : {}
+        }),
+        new Promise((resolve3) => {
+          if (!ctx.signal)
+            return;
+          abort = /* @__PURE__ */ __name(() => resolve3({ approved: false, reason: "Watchdog permission decision was cancelled.", source: "watchdog" }), "abort");
+          ctx.signal.addEventListener("abort", abort, { once: true });
+        }),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error(`Watchdog permission decision timed out after ${timeoutMs}ms.`)), timeoutMs);
+        })
+      ]);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return { block: true, reason: `Blocked by pi-subagents permission rule: Watchdog permission arbiter failed closed: ${reason}` };
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+      if (abort)
+        ctx.signal?.removeEventListener("abort", abort);
+    }
+    if (result2.approved)
+      return void 0;
+    return { block: true, reason: `Blocked by pi-subagents permission rule: ${result2.reason}` };
+  });
+}
+__name(registerPermissionGate, "registerPermissionGate");
+function registerToolBudget(pi, budget) {
+  if (!budget)
+    return;
+  let toolCount = 0;
+  let softNudged = false;
+  const sendUserMessage = pi.sendUserMessage;
+  const onRuntimeEvent = pi.on;
+  onRuntimeEvent("tool_call", (event) => {
+    const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+    toolCount++;
+    if (budget.soft !== void 0 && toolCount >= budget.soft && !softNudged) {
+      softNudged = true;
+      try {
+        sendUserMessage?.(toolBudgetSoftNudge(budget, toolCount), { deliverAs: "steer" });
+      } catch {
+      }
+    }
+    if (!shouldBlockToolForBudget(budget, toolName, toolCount))
+      return void 0;
+    return { block: true, reason: toolBudgetBlockedMessage(budget, toolName, toolCount) };
+  });
+}
+__name(registerToolBudget, "registerToolBudget");
+function registerStructuredOutputTool(pi, structured) {
+  const terminalState = structured.terminalState ??= { captured: false };
+  const required = structured.acceptanceReport === "required";
+  const parameters = createStructuredOutputToolParameters(structured.schema, { acceptanceReport: structured.acceptanceReport });
+  const registerTool = pi.registerTool;
+  registerTool({
+    name: "structured_output",
+    ...MODEL_ONLY_TOOL,
+    label: "Structured Output",
+    description: "Submit the required final structured output for this subagent step. This terminates the step.",
+    parameters,
+    async execute(_id, params) {
+      const validation = await validateStructuredOutputValue(structured.schema, params.value);
+      if (validation.status === "invalid") {
+        throw new Error(`Structured output validation failed: ${validation.message}`);
+      }
+      if (required && params.acceptanceReport === void 0) {
+        throw new Error(MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR);
+      }
+      if (required && params.acceptanceReport !== void 0) {
+        const acceptanceValidation = validateAcceptanceReport(params.acceptanceReport, "acceptanceReport");
+        if (!acceptanceValidation.report) {
+          throw new Error(`Invalid structured output acceptance report: ${acceptanceValidation.errors.join("; ")}`);
+        }
+      }
+      structured.capture(params.value, structured.acceptanceReport ? params.acceptanceReport : void 0);
+      terminalState.captured = true;
+      return {
+        content: [{ type: "text", text: "Structured output captured." }],
+        details: {},
+        terminate: true
+      };
+    }
+  });
+}
+__name(registerStructuredOutputTool, "registerStructuredOutputTool");
+function registerSubagentPromptRuntime(pi, config, drainObservation) {
+  if (!config)
+    return;
+  registerRuntimeExtensionAcknowledgements(pi, config.runtimeAcknowledgements);
+  registerPermissionGate(pi, config.permissions, config.childWatchdog);
+  registerToolBudget(pi, config.toolBudget);
+  if (config.structuredOutput && !config.structuredOutput.terminalState)
+    config.structuredOutput.terminalState = { captured: false };
+  registerChildWatchdog(pi, config.childWatchdog, config.watchdogStatus, config.structuredOutput?.terminalState);
+  const requestedWatchdogDiff = config.requiredTools?.includes(WATCHDOG_DIFF_TOOL_NAME);
+  const reviewerLaunchBaseline = requestedWatchdogDiff && config.cwd ? captureWatchdogDiffBaseline(config.cwd) : void 0;
+  if (requestedWatchdogDiff && typeof pi.registerTool === "function") {
+    pi.registerTool(createWatchdogDiffTool(reviewerLaunchBaseline, { workingTreeAtLaunch: true }));
+  }
+  const waitState = config.runtimeState ?? {
+    baseCwd: "",
+    currentSessionId: null,
+    asyncJobs: /* @__PURE__ */ new Map(),
+    foregroundRuns: /* @__PURE__ */ new Map(),
+    foregroundControls: /* @__PURE__ */ new Map(),
+    lastForegroundControlId: null,
+    cleanupTimers: /* @__PURE__ */ new Map(),
+    lastUiContext: null,
+    poller: null,
+    completionSeen: /* @__PURE__ */ new Map(),
+    watcher: null,
+    watcherRestartTimer: null,
+    resultFileCoalescer: { schedule: /* @__PURE__ */ __name(() => false, "schedule"), clear: /* @__PURE__ */ __name(() => {
+    }, "clear") }
+  };
+  const nestedRootRunId = inheritedNestedRouteOf(config)?.rootRunId;
+  if (typeof pi.registerTool === "function")
+    registerWaitTool(pi, waitState, config.waitTool.enabled, void 0, config.waitTool.defaultTimeoutMs, { nestedRootRunId });
+  const supervisorMetadata = childSupervisorMetadata(config);
+  let nativeSupervisorClientRegistered = false;
+  const registerNativeSupervisorClientOnce = /* @__PURE__ */ __name(() => {
+    if (nativeSupervisorClientRegistered)
+      return;
+    nativeSupervisorClientRegistered = true;
+    registerNativeSupervisorClient(pi, supervisorMetadata);
+  }, "registerNativeSupervisorClientOnce");
+  const onRuntimeEvent = pi.on;
+  onRuntimeEvent("session_start", (_event, ctx) => {
+    const sessionManager = ctx?.sessionManager;
+    waitState.currentSessionId = sessionManager ? resolveCurrentSessionId(sessionManager) : null;
+    registerNativeSupervisorClientOnce();
+  });
+  onRuntimeEvent("agent_start", () => {
+    if (!config.requiredTools)
+      return;
+    const diagnostic = evaluateChildToolDiagnostic(config, pi.getAllTools().map((tool) => tool.name));
+    config.toolDiagnostic?.(diagnostic);
+    if (diagnostic)
+      throw new Error(formatChildToolDiagnostic(diagnostic));
+  });
+  onRuntimeEvent("agent_end", async (_event, ctx) => {
+    if (ctx?.hasUI === true)
+      drainObservation?.deny();
+    if (drainObservation) {
+      try {
+        if (ctx?.sessionManager?.getSessionFile() !== waitState.currentSessionId)
+          drainObservation.deny();
+      } catch {
+        drainObservation.deny();
+      }
+    }
+    config.holdFinalDrain?.(true);
+    try {
+      await drainOutstandingWork({ state: waitState, events: pi.events, nestedRootRunId, hasPendingSupervisorRequest: config.hasPendingSupervisorRequest }, drainObservation);
+    } finally {
+      config.holdFinalDrain?.(false);
+    }
+  });
+  if (config.structuredOutput)
+    registerStructuredOutputTool(pi, config.structuredOutput);
+  onRuntimeEvent("before_provider_request", (event, ctx) => rewriteForkCacheProviderRequest(event, ctx, config.forkCacheKey));
+  let inheritedTools;
+  if (config.forkCacheKey)
+    onRuntimeEvent("context_with_system", (event, ctx) => {
+      if (!event || typeof event !== "object" || !("messages" in event) || !Array.isArray(event.messages))
+        return void 0;
+      const header = ctx?.sessionManager?.getHeader();
+      if (!header)
+        return void 0;
+      if (inheritedTools?.session !== header.id) {
+        const forkedAt = Date.parse(header.timestamp);
+        inheritedTools = { session: header.id, forkedAt, tools: Number.isFinite(forkedAt) ? toolsDeclaredBefore(ctx.sessionManager.buildSessionProjection().messages, forkedAt) : [] };
+      }
+      const messages = keepInheritedToolDeclarations(event.messages, inheritedTools.tools, inheritedTools.forkedAt);
+      return messages === event.messages ? void 0 : { messages };
+    });
+  onRuntimeEvent("context", (event, ctx) => {
+    if (!event || typeof event !== "object" || !("messages" in event) || !Array.isArray(event.messages))
+      return void 0;
+    const forkedAt = config.forkCacheKey ? Date.parse(ctx?.sessionManager?.getHeader()?.timestamp ?? "") : Number.NaN;
+    const messages = stripParentOnlySubagentMessages(event.messages, {
+      sanitizeToolIds: !COMPOSITE_TOOL_ID_APIS.has(ctx?.model?.api ?? ""),
+      preserveBoundedCompositeToolIds: ctx?.model?.api === "openai-codex-responses",
+      preserveFanoutToolHistory: config.fanoutChild,
+      ...Number.isFinite(forkedAt) ? { inheritedBefore: forkedAt } : {}
+    });
+    if (messages === event.messages)
+      return void 0;
+    return { messages };
+  });
+  const routingName = config.intercomSessionName;
+  let intercomIdClaimed = false;
+  if (routingName) {
+    pi.events.on(INTERCOM_SESSION_IDENTITY_EVENT, (request) => {
+      if (!request || typeof request !== "object" || !("version" in request) || request.version !== 1 || !("claim" in request) || typeof request.claim !== "function")
+        return;
+      request.claim(routingName);
+      intercomIdClaimed = true;
+    });
+  }
+  onRuntimeEvent("before_agent_start", async (event) => {
+    if (!event || typeof event !== "object" || !("systemPrompt" in event) || typeof event.systemPrompt !== "string")
+      return void 0;
+    registerNativeSupervisorClientOnce();
+    const childSessionName = intercomIdClaimed ? config.sessionName || routingName : routingName || config.sessionName;
+    if (childSessionName && typeof pi.setSessionName === "function") {
+      pi.setSessionName(childSessionName);
+    }
+    if (!rewritesChildPrompt(config))
+      return;
+    filterChildPromptOptions(event.systemPromptOptions, {
+      inheritProjectContext: config.inheritProjectContext ?? true,
+      inheritGlobalContext: config.inheritGlobalContext ?? true,
+      inheritSkills: config.inheritSkills ?? true
+    });
+  });
+}
+__name(registerSubagentPromptRuntime, "registerSubagentPromptRuntime");
+
+export {
+  appendAgentRefinementOverlay,
+  handleRefinementAction,
+  projectRuntimeAcknowledgedExtensions,
+  formatChildToolDiagnostic,
+  rewriteSubagentPrompt,
+  registerSubagentPromptBoundary,
+  registerSubagentPromptRuntime
+};