@ashx-j/lunr-dev 0.2.19-dev.10.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{chunk-MUMMMTW4.js → chunk-N3PNL74S.js}

@@ -2,16 +2,16 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   PLAN_MODE_WRITE_SPAWN_ERROR,
   resolveChildPermissions
-} from "./chunk-MGSB2C3M.js";
+} from "./chunk-ZVSORYRM.js";
 import {
   createReadOnlyTools
-} from "./chunk-K72NVGUB.js";
-import {
-  COMPUTER_TOOLS
-} from "./chunk-5OLJGVCB.js";
+} from "./chunk-GT5F3OKM.js";
 import {
   convertToLlm
 } from "./chunk-FVDOXRUD.js";
+import {
+  COMPUTER_TOOLS
+} from "./chunk-3ONQTOMR.js";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/types.js
 import * as os from "node:os";
@@ -66,7 +66,8 @@ function resolveTempScopeId(options) {
   }
   return "shared";
 }
-var MAX_PARALLEL = Number.MAX_SAFE_INTEGER, MAX_CONCURRENCY = Number.MAX_SAFE_INTEGER, TEMP_ROOT_DIR = path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`), RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results"), ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs"), CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs"), TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts"), WIDGET_KEY = "subagent-async", SLASH_RESULT_TYPE = "subagent-slash-result", SLASH_TEXT_RESULT_TYPE = "subagent-slash-text-result", SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request", SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started", SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response", SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update", SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel", POLL_INTERVAL_MS = 250, MAX_WIDGET_JOBS = 4, DEFAULT_SUBAGENT_MAX_DEPTH = 2, SUBAGENT_ACTIONS = ["status", "interrupt", "resume", "steer", "stop", "append-step", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule", "schedule-list", "schedule-status", "schedule-cancel"];
+var MAX_PARALLEL = Number.MAX_SAFE_INTEGER, MAX_CONCURRENCY = Number.MAX_SAFE_INTEGER, TEMP_ROOT_DIR = path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`), RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results"), ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs"), CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs"), TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts"), WIDGET_KEY = "subagent-async", SLASH_RESULT_TYPE = "subagent-slash-result", SLASH_TEXT_RESULT_TYPE = "subagent-slash-text-result", SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request", SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started", SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response", SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update", SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel", POLL_INTERVAL_MS = 250;
+var DEFAULT_SUBAGENT_MAX_DEPTH = 2, SUBAGENT_ACTIONS = ["status", "interrupt", "resume", "steer", "stop", "append-step", "doctor", "watchdog.status", "watchdog.check", "watchdog.recommend-model", "schedule", "schedule-list", "schedule-status", "schedule-cancel"];
 var DEFAULT_FORK_PREAMBLE = "You are a delegated subagent running from a fork of the parent session. Treat the inherited conversation as reference-only context, not a live thread to continue. Do not continue or answer prior messages as if they are waiting for a reply. Your sole job is to execute the task below and return a focused result for that task using your tools.";
 function normalizeTopLevelParallelValue(value) {
   let parsed = typeof value == "number" ? value : typeof value == "string" ? Number(value) : NaN;
@@ -423,7 +424,22 @@ function formatModelThinking(model, thinking) {
   return [displayModel, formatThinkingLabel(model, thinking)].filter(Boolean).join(" \xB7 ");
 }
 function formatModelSelection(selection, resolvedModel, thinking) {
-  return selection?.kind === "tier" && selection.tier ? [selection.tier, formatThinkingLabel(resolvedModel, thinking)].filter(Boolean).join(" \xB7 ") : formatModelThinking(resolvedModel, thinking);
+  if (selection?.kind === "tier" && selection.tier)
+    return [selection.tier, formatThinkingLabel(resolvedModel, thinking)].filter(Boolean).join(" \xB7 ");
+  let selectedModel = selection?.kind === "model" ? selection.model : void 0;
+  return formatModelThinking(selectedModel || resolvedModel, thinking);
+}
+function formatModelId(model) {
+  if (!model)
+    return "";
+  let displayModel = splitKnownThinkingSuffix(model).baseModel, slashIdx = displayModel.lastIndexOf("/");
+  return slashIdx !== -1 && (displayModel = displayModel.slice(slashIdx + 1)), displayModel;
+}
+function formatCompactModelBadge(selection, resolvedModel) {
+  if (selection?.kind === "tier" && selection.tier)
+    return selection.tier;
+  let explicit = selection?.kind === "model" && typeof selection.model == "string" && selection.model.trim() ? selection.model : void 0;
+  return formatModelId(explicit ?? resolvedModel);
 }
 function formatUsage(u, model) {
   let parts = [];
@@ -1914,7 +1930,7 @@ function resolveRuntimeScriptPath(basePathWithoutExt) {
   let tsPath = `${basePathWithoutExt}.ts`;
   return fs9.existsSync(tsPath) ? tsPath : `${basePathWithoutExt}.js`;
 }
-var PROMPT_RUNTIME_EXTENSION_PATH = resolveRuntimeScriptPath(path10.join(path10.dirname(fileURLToPath(new URL("../builtin-extensions/pi-subagents/src/runs/shared/pi-args.js", import.meta.url).href)), "subagent-prompt-runtime")), FANOUT_CHILD_EXTENSION_PATH = resolveRuntimeScriptPath(path10.join(path10.dirname(fileURLToPath(new URL("../builtin-extensions/pi-subagents/src/runs/shared/pi-args.js", import.meta.url).href)), "..", "..", "extension", "fanout-child")), SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD", SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET", SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV = "PI_SUBAGENT_ORCHESTRATOR_SESSION_ID", SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV = "PI_SUBAGENT_SUPERVISOR_CHANNEL_DIR", SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID", SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT", SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX", SUBAGENT_FANOUT_CHILD_ENV = "PI_SUBAGENT_FANOUT_CHILD", SUBAGENT_PARENT_EVENT_SINK_ENV = "PI_SUBAGENT_PARENT_EVENT_SINK", SUBAGENT_PARENT_CONTROL_INBOX_ENV = "PI_SUBAGENT_PARENT_CONTROL_INBOX", SUBAGENT_PARENT_ROOT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_ROOT_RUN_ID", SUBAGENT_PARENT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_RUN_ID", SUBAGENT_PARENT_CHILD_INDEX_ENV = "PI_SUBAGENT_PARENT_CHILD_INDEX", SUBAGENT_PARENT_DEPTH_ENV = "PI_SUBAGENT_PARENT_DEPTH", SUBAGENT_PARENT_PATH_ENV = "PI_SUBAGENT_PARENT_PATH", SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV = "PI_SUBAGENT_PARENT_CAPABILITY_TOKEN", SUBAGENT_PARENT_SESSION_ENV = "PI_SUBAGENT_PARENT_SESSION", SUBAGENT_PARENT_PERMISSION_MODE_ENV = "PI_SUBAGENT_PARENT_PERMISSION_MODE", SUBAGENT_CHILD_PERMISSION_ENV = "PI_SUBAGENT_CHILD_PERMISSION", SUBAGENT_STEER_INBOX_ENV = "PI_SUBAGENT_STEER_INBOX", SUBAGENT_STEER_CAPABILITY_ENV = "PI_SUBAGENT_STEER_CAPABILITY", SUBAGENT_STEER_ACK_DIR_ENV = "PI_SUBAGENT_STEER_ACK_DIR";
+var PROMPT_RUNTIME_EXTENSION_PATH = resolveRuntimeScriptPath(path10.join(path10.dirname(fileURLToPath(new URL("../builtin-extensions/pi-subagents/src/runs/shared/pi-args.js", import.meta.url).href)), "subagent-prompt-runtime")), FANOUT_CHILD_EXTENSION_PATH = resolveRuntimeScriptPath(path10.join(path10.dirname(fileURLToPath(new URL("../builtin-extensions/pi-subagents/src/runs/shared/pi-args.js", import.meta.url).href)), "..", "..", "extension", "fanout-child")), SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD", SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET", SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV = "PI_SUBAGENT_ORCHESTRATOR_SESSION_ID", SUBAGENT_SUPERVISOR_SESSION_ID_ENV = "PI_SUBAGENT_SUPERVISOR_SESSION_ID", SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV = "PI_SUBAGENT_SUPERVISOR_CHANNEL_DIR", SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID", SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT", SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX", SUBAGENT_FANOUT_CHILD_ENV = "PI_SUBAGENT_FANOUT_CHILD", SUBAGENT_PARENT_EVENT_SINK_ENV = "PI_SUBAGENT_PARENT_EVENT_SINK", SUBAGENT_PARENT_CONTROL_INBOX_ENV = "PI_SUBAGENT_PARENT_CONTROL_INBOX", SUBAGENT_PARENT_ROOT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_ROOT_RUN_ID", SUBAGENT_PARENT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_RUN_ID", SUBAGENT_PARENT_CHILD_INDEX_ENV = "PI_SUBAGENT_PARENT_CHILD_INDEX", SUBAGENT_PARENT_DEPTH_ENV = "PI_SUBAGENT_PARENT_DEPTH", SUBAGENT_PARENT_PATH_ENV = "PI_SUBAGENT_PARENT_PATH", SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV = "PI_SUBAGENT_PARENT_CAPABILITY_TOKEN", SUBAGENT_PARENT_SESSION_ENV = "PI_SUBAGENT_PARENT_SESSION", SUBAGENT_PARENT_PERMISSION_MODE_ENV = "PI_SUBAGENT_PARENT_PERMISSION_MODE", SUBAGENT_CHILD_PERMISSION_ENV = "PI_SUBAGENT_CHILD_PERMISSION", SUBAGENT_STEER_INBOX_ENV = "PI_SUBAGENT_STEER_INBOX", SUBAGENT_STEER_CAPABILITY_ENV = "PI_SUBAGENT_STEER_CAPABILITY", SUBAGENT_STEER_ACK_DIR_ENV = "PI_SUBAGENT_STEER_ACK_DIR";
 function sanitizeSupervisorChannelSegment(value) {
   return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
 }
@@ -1971,9 +1987,9 @@ function buildPiArgs(input) {
       ...input.childAgentName ? { agent: input.childAgentName } : {}
     }] : []
   ];
-  if (env[SUBAGENT_PARENT_EVENT_SINK_ENV] = fanoutAuthorized ? input.parentEventSink ?? process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] ?? "" : "", env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] = fanoutAuthorized ? input.parentControlInbox ?? process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] ?? "" : "", env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] = fanoutAuthorized ? input.parentRootRunId ?? process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] ?? input.runId ?? "" : "", env[SUBAGENT_PARENT_RUN_ID_ENV] = fanoutAuthorized ? parentRunId : "", env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = fanoutAuthorized ? parentChildIndex : "", env[SUBAGENT_PARENT_DEPTH_ENV] = fanoutAuthorized ? String(parentDepth) : "", env[SUBAGENT_PARENT_PATH_ENV] = fanoutAuthorized ? encodeNestedPathEnv(parentPath) : "", env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = fanoutAuthorized ? input.parentCapabilityToken ?? process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] ?? "" : "", env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0", env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0", input.intercomSessionName && (env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName), input.orchestratorIntercomTarget && (env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = input.orchestratorIntercomTarget), input.parentSessionId && (env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = input.parentSessionId), input.orchestratorIntercomTarget && input.parentSessionId && input.runId && input.childAgentName) {
-    let childIndex = input.childIndex ?? 0, channelDir = supervisorChannelDir(input.runId, input.childAgentName, childIndex);
-    fs9.mkdirSync(path10.join(channelDir, "requests"), { recursive: !0 }), fs9.mkdirSync(path10.join(channelDir, "replies"), { recursive: !0 }), env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = channelDir;
+  if (env[SUBAGENT_PARENT_EVENT_SINK_ENV] = fanoutAuthorized ? input.parentEventSink ?? process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] ?? "" : "", env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] = fanoutAuthorized ? input.parentControlInbox ?? process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] ?? "" : "", env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] = fanoutAuthorized ? input.parentRootRunId ?? process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] ?? input.runId ?? "" : "", env[SUBAGENT_PARENT_RUN_ID_ENV] = fanoutAuthorized ? parentRunId : "", env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = fanoutAuthorized ? parentChildIndex : "", env[SUBAGENT_PARENT_DEPTH_ENV] = fanoutAuthorized ? String(parentDepth) : "", env[SUBAGENT_PARENT_PATH_ENV] = fanoutAuthorized ? encodeNestedPathEnv(parentPath) : "", env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = fanoutAuthorized ? input.parentCapabilityToken ?? process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] ?? "" : "", env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0", env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0", input.intercomSessionName && (env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName), input.orchestratorIntercomTarget && (env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = input.orchestratorIntercomTarget), input.parentSessionId && (env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = input.parentSessionId), env[SUBAGENT_SUPERVISOR_SESSION_ID_ENV] = input.supervisorSessionId ?? "", input.parentSessionId && input.runId && (input.childId || input.childAgentName)) {
+    let childIndex = input.childIndex ?? 0, channelAgent = input.childId ?? input.childAgentName, channelDir = supervisorChannelDir(input.runId, channelAgent, childIndex);
+    fs9.mkdirSync(path10.join(channelDir, "requests"), { recursive: !0 }), fs9.mkdirSync(path10.join(channelDir, "replies"), { recursive: !0 }), fs9.mkdirSync(path10.join(channelDir, "questions"), { recursive: !0 }), env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = channelDir, env[SUBAGENT_CHILD_INDEX_ENV] = String(childIndex);
   }
   input.runId && (env[SUBAGENT_RUN_ID_ENV] = input.runId), (input.childId || input.childAgentName) && (env[SUBAGENT_CHILD_AGENT_ENV] = input.childId ?? input.childAgentName), input.childIndex !== void 0 && (env[SUBAGENT_CHILD_INDEX_ENV] = String(input.childIndex)), input.mcpDirectTools?.length ? env.MCP_DIRECT_TOOLS = input.mcpDirectTools.join(",") : env.MCP_DIRECT_TOOLS = "__none__", input.structuredOutput && (env[STRUCTURED_OUTPUT_CAPTURE_ENV] = input.structuredOutput.outputPath, env[STRUCTURED_OUTPUT_SCHEMA_ENV] = input.structuredOutput.schemaPath), input.steerInboxDir && (env[SUBAGENT_STEER_INBOX_ENV] = input.steerInboxDir), input.steerCapabilityPath && (env[SUBAGENT_STEER_CAPABILITY_ENV] = input.steerCapabilityPath), input.steerAckDir && (env[SUBAGENT_STEER_ACK_DIR_ENV] = input.steerAckDir);
   let encodedToolBudget = encodeToolBudgetEnv(input.toolBudget);
@@ -1991,11 +2007,7 @@ function cleanupTempDir(tempDir) {
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/model-fallback.js
 function splitThinkingSuffix(model) {
-  let colonIdx = model.lastIndexOf(":");
-  return colonIdx === -1 ? { baseModel: model, thinkingSuffix: "" } : {
-    baseModel: model.substring(0, colonIdx),
-    thinkingSuffix: model.substring(colonIdx)
-  };
+  return splitKnownThinkingSuffix(model);
 }
 var INHERIT_MODEL = "inherit";
 function normalizeModelSegment(segment) {
@@ -2123,14 +2135,61 @@ function resolveRequiredTierModel(tier, availableModels, preferredProvider) {
     throw new Error(`Model tier '${String(tier)}' resolves to '${baseModel}', but that model is unavailable or unauthenticated. Configure an available model in /settings.`);
   return `${resolvedBase}${thinkingSuffix}`;
 }
+function requestedModelString(model) {
+  return typeof model == "string" && model.trim() && model.trim() !== INHERIT_MODEL ? model.trim() : void 0;
+}
 function requestedTier(tier) {
   return tier === "light" || tier === "standard" || tier === "heavy" ? tier : void 0;
 }
+function parseExplicitThinking(value, pathLabel = "thinking") {
+  if (value !== void 0) {
+    if (value === !1 || value === "off")
+      return "off";
+    if (typeof value != "string" || !THINKING_LEVELS.includes(value))
+      throw new Error(`${pathLabel} must be one of ${THINKING_LEVELS.join(", ")}.`);
+    return value;
+  }
+}
 function captureModelSelection(input) {
-  let tier = requestedTier(input.tier);
-  if (!tier)
-    throw new Error('Every subagent execution requires tier: "light", "standard", or "heavy".');
-  return { kind: "tier", tier };
+  let model = typeof input.model == "string" ? input.model.trim() : "", hasModel = !!model, tier = requestedTier(input.tier);
+  if (hasModel && model === INHERIT_MODEL)
+    throw new Error('model "inherit" is not supported; choose tier: "light", "standard", or "heavy", or an explicit provider/model.');
+  if (hasModel && tier)
+    throw new Error("Choose exactly one of tier or model; do not pass both.");
+  if (hasModel)
+    return { kind: "model", model };
+  if (tier)
+    return { kind: "tier", tier };
+  throw new Error('Every executable child requires tier: "light", "standard", or "heavy", or an explicit model when the user names one.');
+}
+function resolveRequiredExplicitModel(model, availableModels, preferredProvider, thinking) {
+  let requested = requestedModelString(model);
+  if (!requested)
+    throw new Error('Explicit model selection requires model as "provider/id".');
+  if (!availableModels?.length)
+    throw new Error(`Model '${requested}' cannot launch because no authenticated models are available.`);
+  let { baseModel, thinkingSuffix } = splitThinkingSuffix(requested), resolvedBase = resolveBaseModelCandidate(baseModel, availableModels, preferredProvider);
+  if (!resolvedBase)
+    throw new Error(`Model '${baseModel}' is unavailable or unauthenticated. Choose an available provider/model or a configured tier.`);
+  let fromSuffix = thinkingSuffix ? thinkingSuffix.slice(1) : void 0, fromParam = parseExplicitThinking(thinking);
+  if (fromSuffix && fromParam && fromSuffix !== fromParam)
+    throw new Error(`Conflicting thinking levels '${fromSuffix}' and '${fromParam}' for model '${requested}'.`);
+  let level = fromParam ?? fromSuffix;
+  if (!level)
+    return resolvedBase;
+  let info = availableModels.find((entry) => entry.fullId === resolvedBase), supported = getSupportedThinkingLevels(info);
+  if (!supported.includes(level))
+    throw new Error(`Thinking level '${level}' is not supported by '${resolvedBase}'. Supported: ${supported.join(", ") || "none"}.`);
+  return applyThinkingSuffix(resolvedBase, level, !0) ?? resolvedBase;
+}
+function resolveExecutableChildModel(input) {
+  let selection = input.modelSelection ?? captureModelSelection({ model: input.model, tier: input.tier });
+  if (selection.kind === "tier") {
+    if (input.thinking !== void 0)
+      throw new Error("thinking is only valid with an explicit model; tier children use the configured tier thinking level.");
+    return resolveRequiredTierModel(selection.tier, input.availableModels, input.preferredProvider);
+  }
+  return resolveRequiredExplicitModel(input.model, input.availableModels, input.preferredProvider, input.thinking);
 }
 function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider, options) {
   let seen = /* @__PURE__ */ new Set(), candidates = [], rawCandidates = [primaryModel, ...fallbackModels ?? []];
@@ -2276,12 +2335,24 @@ function optionalCount(value) {
 function isModelSelection(value) {
   if (!value || typeof value != "object")
     return !1;
-  if (value.kind === "tier") {
+  let kind = value.kind;
+  if (kind === "model")
+    return !0;
+  if (kind === "tier") {
     let tier = value.tier;
     return tier === "light" || tier === "standard" || tier === "heavy";
   }
   return !1;
 }
+function parseThinking(value, pathLabel) {
+  if (value !== void 0) {
+    if (value === !1)
+      return "off";
+    if (typeof value == "string" && THINKING_LEVELS.includes(value))
+      return value;
+    throw new Error(`${pathLabel}.thinking must be one of ${THINKING_LEVELS.join(", ")}.`);
+  }
+}
 function normalizeChildSpec(input, options) {
   let pathLabel = options.pathLabel ?? "task", description = validateChildDescription(input.description, `${pathLabel}.description`), task = typeof input.task == "string" && input.task.trim() ? input.task : options.defaultTask;
   if (typeof task != "string" || !task.trim())
@@ -2289,21 +2360,40 @@ function normalizeChildSpec(input, options) {
   let requested = parseChildPermissionsInput(input.permissions, `${pathLabel}.permissions`), resolved = resolveChildPermissions(options.parentMode, requested);
   if (!resolved.ok)
     throw new Error(resolved.error || PLAN_MODE_WRITE_SPAWN_ERROR);
-  if (input.model !== void 0 && !isModelSelection(input.modelSelection))
-    throw new Error(`${pathLabel}.model is not supported for executable children; choose tier: "light", "standard", or "heavy".`);
-  let selectedTier = isModelSelection(input.modelSelection) ? input.modelSelection.tier : input.tier;
-  if (selectedTier !== "light" && selectedTier !== "standard" && selectedTier !== "heavy")
-    throw new Error(`${pathLabel}.tier is required and must be "light", "standard", or "heavy".`);
-  let tier = selectedTier, outputMode = input.outputMode === "inline" || input.outputMode === "file-only" ? input.outputMode : void 0, modelSelection = isModelSelection(input.modelSelection) ? input.modelSelection : captureModelSelection({ tier });
+  let preservedSelection = isModelSelection(input.modelSelection) ? input.modelSelection : void 0, rawModel = optionalString(input.model);
+  if (rawModel === INHERIT_MODEL)
+    throw new Error(`${pathLabel}.model "inherit" is not supported; choose tier or an explicit provider/model.`);
+  let modelSelection, tier, model, thinking;
+  if (preservedSelection)
+    if (modelSelection = preservedSelection, modelSelection.kind === "tier") {
+      if (tier = modelSelection.tier, model = void 0, input.thinking !== void 0)
+        throw new Error(`${pathLabel}.thinking is only valid with an explicit model selection.`);
+    } else {
+      if (model = rawModel ?? optionalString(modelSelection.model), !model)
+        throw new Error(`${pathLabel}.model is required when modelSelection.kind is "model".`);
+      modelSelection.model || (modelSelection = { kind: "model", model }), thinking = parseThinking(input.thinking, pathLabel);
+    }
+  else if (options.resolvedModelIsRuntime) {
+    let selectedTier = input.tier === "light" || input.tier === "standard" || input.tier === "heavy" ? input.tier : void 0;
+    if (!selectedTier)
+      throw new Error(`${pathLabel}.tier is required to resume a child without a stored modelSelection.`);
+    modelSelection = { kind: "tier", tier: selectedTier }, tier = selectedTier, model = void 0;
+  } else if (modelSelection = captureModelSelection({ model: input.model, tier: input.tier }), modelSelection.kind === "tier") {
+    if (tier = modelSelection.tier, model = void 0, input.thinking !== void 0)
+      throw new Error(`${pathLabel}.thinking is only valid with an explicit model selection.`);
+  } else
+    model = rawModel, !modelSelection.model && model && (modelSelection = { kind: "model", model }), thinking = parseThinking(input.thinking, pathLabel);
+  let outputMode = input.outputMode === "inline" || input.outputMode === "file-only" ? input.outputMode : void 0;
   return {
     childId: options.childId ?? allocateChildId(options.runId, options.index),
     task,
     description,
     requestedPermissions: resolved.requested,
     effectivePermissions: resolved.effective,
-    model: optionalString(input.model),
+    model,
     tier,
     modelSelection,
+    thinking,
     skill: optionalSkill(input.skill),
     cwd: optionalString(input.cwd),
     output: optionalOutput(input.output),
@@ -2334,9 +2424,6 @@ function formatActivityLabel(lastActivityAt, activityState, now = Date.now()) {
 function isCompletedStepStatus(status) {
   return status === "complete" || status === "completed";
 }
-function aggregateStepStatus(steps) {
-  return steps.some((step) => step.status === "running") ? "running" : steps.some((step) => step.status === "failed") ? "failed" : steps.some((step) => step.status === "stopped") ? "stopped" : steps.some((step) => step.status === "paused") ? "paused" : steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status)) ? "complete" : "pending";
-}
 function formatAgentRunningLabel(count) {
   return count === 1 ? "1 agent running" : `${count} agents running`;
 }
@@ -2420,6 +2507,34 @@ function formatNestedRunStatusLines(children, options = {}) {
   });
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/request-params.js
+var LAUNCH_COMPATIBLE_ACTIONS = /* @__PURE__ */ new Set(["schedule", "append-step", "resume", "steer"]);
+function omitExecutionModeActionAlias(params) {
+  let action = params.action?.toLowerCase();
+  if (action === "single" && params.task !== void 0) {
+    let rest = { ...params };
+    return delete rest.action, rest;
+  }
+  if ((action === "parallel" || action === "tasks") && (params.tasks?.length ?? 0) > 0) {
+    let rest = { ...params };
+    return delete rest.action, rest;
+  }
+  return params;
+}
+function hasLaunchFields(params) {
+  return params.task !== void 0 || Array.isArray(params.tasks) && params.tasks.length > 0 || Array.isArray(params.chain) && params.chain.length > 0;
+}
+function omitConflictingControlAction(params) {
+  let action = params.action?.toLowerCase();
+  if (!action || LAUNCH_COMPATIBLE_ACTIONS.has(action) || !hasLaunchFields(params))
+    return params;
+  let rest = { ...params };
+  return delete rest.action, typeof rest.task == "string" && rest.task.length > 0 && (delete rest.tasks, delete rest.chain), rest;
+}
+function resolveSubagentRequestParams(params) {
+  return omitConflictingControlAction(omitExecutionModeActionAlias(params));
+}
+
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/subagent-control.js
 var CONTROL_EVENT_TYPES = ["active_long_running", "needs_attention"], CONTROL_NOTIFICATION_CHANNELS = ["event", "async", "intercom"], DEFAULT_NOTIFY_ON = ["active_long_running", "needs_attention"], DEFAULT_CONTROL_CONFIG = {
   enabled: !0,
@@ -3808,7 +3923,7 @@ var REVIEW_ONLY_PATTERNS = [
   /\balways\s+(?:edit|modify|change|fix|patch|apply)\b/i,
   /\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
   /\bmake\s+(?:the\s+)?code\s+changes\b/i
-], NO_EDIT_PROHIBITION_PATTERN = /\b(?:do not|don't|must not)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b((?:(?!\b(?:but|and|then)\b)[^.;,:!?\n–—-])*)/gi, GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|source|sources|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
+], NO_EDIT_PROHIBITION_PATTERN = /\b(?:do not|don't|must not)\s+(?:implement|edit|modify|write(?:\s+to)?|touch|change)\b((?:(?!\b(?:but|and|then)\b)[^.;,:!?\n–—-])*)/gi, GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|source|sources|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
   /\bdo not edit files?\s+outside\b/i,
   /\bdo not edit\s+outside\b/i,
   /\bdo not edit\s+unrelated files?\b/i,
@@ -3865,17 +3980,14 @@ function taskHasReadOnlyDeliverable(taskText) {
 function hasImplementationIntent(taskText) {
   return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText)) || WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText)) || REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
 }
-function isReadOnlyPermission(permissionsOrLegacyName) {
-  return permissionsOrLegacyName === "read-only";
-}
-function classifyTaskMutationIntent(permissionsOrLegacyName, task) {
-  if (isReadOnlyPermission(permissionsOrLegacyName))
+function classifyTaskMutationIntent(permissions, task) {
+  if (permissions === "read-only")
     return { kind: "read-only" };
   let taskText = stripFrameworkInstructions(task), taskTextWithoutScopedConstraints = stripPatterns(taskText, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS), prohibitions = analyzeNoEditProhibitions(taskTextWithoutScopedConstraints);
   return prohibitions.present ? prohibitions.blanket ? { kind: "read-only" } : hasImplementationIntent(prohibitions.strippedText) ? { kind: "implementation" } : { kind: "read-only" } : hasImplementationIntent(taskText) ? { kind: "implementation" } : RESEARCH_TASK_PATTERNS.some((pattern) => pattern.test(taskText)) && !hasImplementationIntent(taskText) ? { kind: "read-only" } : taskHasReadOnlyDeliverable(taskTextWithoutScopedConstraints) ? { kind: "read-only" } : { kind: "unknown" };
 }
-function expectsImplementationMutation(permissionsOrLegacyName, task) {
-  return isReadOnlyPermission(permissionsOrLegacyName) ? !1 : classifyTaskMutationIntent(permissionsOrLegacyName, task).kind === "implementation";
+function expectsImplementationMutation(permissions, task) {
+  return classifyTaskMutationIntent(permissions, task).kind === "implementation";
 }
 var MAY_MUTATE_VERB_PATTERN = /\b(?:fix|implement|update|write|edit|modify|migrate|delete|remove|refactor|commit)\b/i;
 function taskMayMutate(task) {
@@ -3900,7 +4012,7 @@ var LEVEL_RANK = {
   "diff-summary",
   "review-findings",
   "manual-notes"
-]), ACCEPTANCE_CONFIG_KEYS = /* @__PURE__ */ new Set(["level", "criteria", "evidence", "verify", "review", "stopRules", "reason"]), ACCEPTANCE_GATE_KEYS = /* @__PURE__ */ new Set(["id", "must", "evidence", "severity"]), ACCEPTANCE_VERIFY_KEYS = /* @__PURE__ */ new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure"]), ACCEPTANCE_REVIEW_KEYS = /* @__PURE__ */ new Set(["agent", "focus", "required"]), EXPLICIT_REVIEWED_UNAVAILABLE = "cannot be requested explicitly because this run cannot supply an independent reviewer result; use checked/verified and orchestrate the reviewer separately, or omit acceptance for read-only review tasks.";
+]), ACCEPTANCE_CONFIG_KEYS = /* @__PURE__ */ new Set(["level", "criteria", "evidence", "verify", "review", "stopRules", "reason"]), PERSISTED_ACCEPTANCE_KEYS = /* @__PURE__ */ new Set([...ACCEPTANCE_CONFIG_KEYS, "explicit", "inferredReason"]), ACCEPTANCE_GATE_KEYS = /* @__PURE__ */ new Set(["id", "must", "evidence", "severity"]), ACCEPTANCE_VERIFY_KEYS = /* @__PURE__ */ new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure"]), ACCEPTANCE_REVIEW_KEYS = /* @__PURE__ */ new Set(["agent", "focus", "required"]), EXPLICIT_REVIEWED_UNAVAILABLE = "cannot be requested explicitly because this run cannot supply an independent reviewer result; use checked/verified and orchestrate the reviewer separately, or omit acceptance for read-only review tasks.", RESOLVED_LEVELS = /* @__PURE__ */ new Set(["none", "attested", "checked", "verified", "reviewed"]);
 function normalizeLevel(level) {
   return level ?? "auto";
 }
@@ -3950,18 +4062,25 @@ function normalizeAcceptanceInput(input) {
 function explicitAcceptanceCanDisable(explicit) {
   return explicit.level === "none" && typeof explicit.reason == "string" && explicit.reason.trim().length > 0;
 }
-function validateAcceptanceInput(input, pathLabel = "acceptance") {
+function validateAcceptanceValue(input, pathLabel, mode) {
   let errors = [];
-  if (input === void 0 || input === !1)
+  if (input === void 0)
     return errors;
-  if (typeof input == "string")
-    return VALID_LEVELS.has(input) ? input === "none" ? errors.push(`${pathLabel} level "none" requires a reason; use { level: "none", reason: "..." }.`) : input === "reviewed" && errors.push(`${pathLabel} ${EXPLICIT_REVIEWED_UNAVAILABLE}`) : errors.push(`${pathLabel} has invalid level '${input}'.`), errors;
-  if (!input || typeof input != "object" || Array.isArray(input))
-    return errors.push(`${pathLabel} must be a string level, false, or an object.`), errors;
-  let value = input;
+  if (mode === "persisted") {
+    if (!input || typeof input != "object" || Array.isArray(input))
+      return errors.push(`${pathLabel} must be a resolved acceptance object.`), errors;
+  } else {
+    if (input === !1)
+      return errors;
+    if (typeof input == "string")
+      return VALID_LEVELS.has(input) ? input === "none" ? errors.push(`${pathLabel} level "none" requires a reason; use { level: "none", reason: "..." }.`) : input === "reviewed" && errors.push(`${pathLabel} ${EXPLICIT_REVIEWED_UNAVAILABLE}`) : errors.push(`${pathLabel} has invalid level '${input}'.`), errors;
+    if (!input || typeof input != "object" || Array.isArray(input))
+      return errors.push(`${pathLabel} must be a string level, false, or an object.`), errors;
+  }
+  let value = input, allowedKeys = mode === "persisted" ? PERSISTED_ACCEPTANCE_KEYS : ACCEPTANCE_CONFIG_KEYS;
   for (let key of Object.keys(value))
-    ACCEPTANCE_CONFIG_KEYS.has(key) || errors.push(`${pathLabel}.${key} is not supported.`);
-  if (value.level !== void 0 && (typeof value.level != "string" || !VALID_LEVELS.has(value.level)) && errors.push(`${pathLabel}.level must be one of auto, none, attested, checked, verified, reviewed.`), value.level === "none" && (typeof value.reason != "string" || !value.reason.trim()) && errors.push(`${pathLabel}.reason is required when level is none.`), value.level === "reviewed" && errors.push(`${pathLabel}.level ${EXPLICIT_REVIEWED_UNAVAILABLE}`), value.reason !== void 0 && typeof value.reason != "string" && errors.push(`${pathLabel}.reason must be a string.`), value.criteria !== void 0 && !Array.isArray(value.criteria) && errors.push(`${pathLabel}.criteria must be an array.`), Array.isArray(value.criteria)) {
+    allowedKeys.has(key) || errors.push(`${pathLabel}.${key} is not supported.`);
+  if (mode === "persisted" ? (typeof value.level != "string" || !RESOLVED_LEVELS.has(value.level)) && errors.push(`${pathLabel}.level must be one of none, attested, checked, verified, reviewed.`) : value.level !== void 0 && (typeof value.level != "string" || !VALID_LEVELS.has(value.level)) && errors.push(`${pathLabel}.level must be one of auto, none, attested, checked, verified, reviewed.`), value.level === "none" && (typeof value.reason != "string" || !value.reason.trim()) && errors.push(`${pathLabel}.reason is required when level is none.`), mode === "launch" && value.level === "reviewed" && errors.push(`${pathLabel}.level ${EXPLICIT_REVIEWED_UNAVAILABLE}`), mode === "persisted" && (value.explicit !== void 0 && typeof value.explicit != "boolean" && errors.push(`${pathLabel}.explicit must be a boolean.`), value.inferredReason !== void 0 && (!Array.isArray(value.inferredReason) || value.inferredReason.some((item) => typeof item != "string")) && errors.push(`${pathLabel}.inferredReason must be an array of strings.`)), value.reason !== void 0 && typeof value.reason != "string" && errors.push(`${pathLabel}.reason must be a string.`), value.criteria !== void 0 && !Array.isArray(value.criteria) && errors.push(`${pathLabel}.criteria must be an array.`), Array.isArray(value.criteria)) {
     let criterionIds = /* @__PURE__ */ new Set();
     for (let [index, criterion] of value.criteria.entries()) {
       if (typeof criterion == "string")
@@ -4021,6 +4140,29 @@ function validateAcceptanceInput(input, pathLabel = "acceptance") {
       typeof item != "string" && errors.push(`${pathLabel}.stopRules[${index}] must be a string.`);
   return errors;
 }
+function validateAcceptanceInput(input, pathLabel = "acceptance") {
+  return validateAcceptanceValue(input, pathLabel, "launch");
+}
+function validatePersistedAcceptance(input, pathLabel = "acceptance") {
+  return validateAcceptanceValue(input, pathLabel, "persisted");
+}
+function restorePersistedAcceptance(input, pathLabel = "acceptance") {
+  let errors = validatePersistedAcceptance(input, pathLabel);
+  if (errors.length > 0)
+    throw new Error(errors.join(" "));
+  let value = input, evidence = Array.isArray(value.evidence) ? unique(value.evidence.filter((item) => VALID_EVIDENCE.has(item))) : [];
+  return {
+    level: value.level,
+    explicit: value.explicit === !0,
+    inferredReason: Array.isArray(value.inferredReason) ? value.inferredReason.filter((item) => typeof item == "string") : [],
+    criteria: normalizeCriteria(value.criteria, evidence),
+    evidence,
+    verify: Array.isArray(value.verify) ? value.verify : [],
+    review: value.review,
+    stopRules: Array.isArray(value.stopRules) ? value.stopRules.filter((item) => typeof item == "string") : [],
+    ...typeof value.reason == "string" ? { reason: value.reason } : {}
+  };
+}
 function validateExecutionAcceptance(input) {
   let errors = validateAcceptanceInput(input.acceptance, "acceptance");
   for (let [index, task] of (input.tasks ?? []).entries())
@@ -4042,9 +4184,11 @@ function normalizeCriteria(criteria, evidence) {
 }
 function resolveEffectiveAcceptance(input) {
   let explicit = normalizeAcceptanceInput(input.explicit), inferred = inferLevel(input), explicitLevel = normalizeLevel(explicit.level), level = explicitAcceptanceCanDisable(explicit) ? "none" : explicitLevel === "auto" ? inferred.level : LEVEL_RANK[explicitLevel] >= LEVEL_RANK[inferred.level] ? explicitLevel : inferred.level, evidence = unique([...level === inferred.level ? inferred.evidence : requiredEvidenceForLevel(level), ...explicit.evidence ?? []]), criteria = normalizeCriteria(explicit.criteria?.length ? explicit.criteria : inferred.criteria, evidence), review = explicit.review !== void 0 ? explicit.review : inferred.review;
-  return level === "reviewed" && input.explicit !== void 0 && explicitLevel !== "reviewed" && explicit.review === void 0 && review && review !== !1 && (review = { ...review, required: !1 }), {
+  level === "reviewed" && input.explicit !== void 0 && explicitLevel !== "reviewed" && explicit.review === void 0 && review && review !== !1 && (review = { ...review, required: !1 });
+  let parentRequestedLevel = input.explicit === void 0 || explicitLevel === "auto" ? void 0 : explicitLevel;
+  return {
     level,
-    explicit: input.explicit !== void 0,
+    explicit: parentRequestedLevel === level,
     inferredReason: inferred.reasons,
     criteria,
     evidence,
@@ -4607,6 +4751,17 @@ function acceptanceFailureMessage(ledger) {
   return failedVerify ? `Acceptance verification '${failedVerify.id}' ${failedVerify.status}.` : ledger.reviewResult?.status === "needs-parent-decision" ? "Acceptance review required but no automatic reviewer result is available." : ledger.reviewResult?.status === "blockers" ? "Acceptance review found blockers." : "Acceptance rejected.";
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/top-level-async.js
+function normalizeAsyncLaunchConfig(config) {
+  return { ...config, asyncByDefault: !0, forceTopLevelAsync: !1 };
+}
+function subagentLaunchRunsAsync(params) {
+  return !(params.foregroundOnly === !0 || params.clarify === !0 || params.async === !1);
+}
+function isAsyncSubagentExecution(params) {
+  return params.action || !params.task && !params.tasks?.length && !params.chain?.length ? !1 : subagentLaunchRunsAsync(params);
+}
+
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/shared/turn-budget.js
 function resolveTurnBudgetConfig(raw, label = "turnBudget") {
   if (raw === void 0)
@@ -4667,132 +4822,36 @@ function shouldAbortForTurnBudget(budget, turnCount, terminalAssistantStop) {
   return turnCount < hardLimit ? !1 : turnCount > hardLimit ? !0 : !terminalAssistantStop;
 }
 
-// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/intercom-bridge.js
-import * as fs14 from "node:fs";
-import * as os7 from "node:os";
-import * as path15 from "node:path";
-var NATIVE_INTERCOM_EXTENSION_DIR = "native:pi-subagents-supervisor-channel";
-function defaultAgentDir() {
-  return getAgentDir();
-}
-function defaultSubagentConfigDir(agentDir = defaultAgentDir()) {
-  return path15.join(agentDir, "extensions", "subagent");
-}
-var DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat", INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:", DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
-
-Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
-- Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
-- Need structured supervisor input rather than a freeform reply: contact_supervisor({ reason: "interview_request", message: "<what input is needed>", interview: { title: "...", questions: [] } })
-- After contact_supervisor with reason "need_decision" or "interview_request", stay alive and continue only after the reply arrives. Do not finish your final response with a choose-one question.
-- Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. If an output path is configured but no write-capable tool is available, return the complete artifact in your final response; the runtime will persist it. Do not contact the supervisor merely because you cannot write that output path directly.
-- Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
-- Generic intercom is lower-level plumbing/fallback only: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
-
-Do not use contact_supervisor or intercom for routine completion handoffs. If no coordination is needed, return a focused task result.`;
-function resolveIntercomSessionTarget(sessionName, sessionId) {
-  let trimmedName = sessionName?.trim();
-  if (trimmedName)
-    return trimmedName;
-  let normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice(8) : sessionId;
-  return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
-}
-function sanitizeIntercomTargetPart(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
-}
-function resolveSubagentIntercomTarget(runId, agent, index) {
-  let stepSuffix = index !== void 0 ? `-${index + 1}` : "";
-  return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
-}
-function resolveIntercomBridgeMode(value) {
-  return value === "off" || value === "always" || value === "fork-only" ? value : "always";
-}
-function resolveIntercomBridgeConfig(value) {
-  return !value || typeof value != "object" || Array.isArray(value) ? { mode: "always", instructionFile: "" } : {
-    mode: resolveIntercomBridgeMode(value.mode),
-    instructionFile: typeof value.instructionFile == "string" ? value.instructionFile : ""
-  };
-}
-function expandTilde(filePath) {
-  return filePath.startsWith("~/") ? path15.join(os7.homedir(), filePath.slice(2)) : filePath;
-}
-function resolveInstructionTemplate(instructionFile, settingsDir) {
-  if (!instructionFile)
-    return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
-  let expandedPath = expandTilde(instructionFile), resolvedPath = path15.isAbsolute(expandedPath) ? expandedPath : path15.resolve(settingsDir, expandedPath);
-  try {
-    return fs14.readFileSync(resolvedPath, "utf-8");
-  } catch (error) {
-    return console.warn(`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`, error), DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
-  }
-}
-function buildIntercomBridgeInstruction(orchestratorTarget, template) {
-  let instruction = template.replaceAll("{orchestratorTarget}", orchestratorTarget).trim();
-  return instruction.startsWith(INTERCOM_BRIDGE_MARKER) ? instruction : `${INTERCOM_BRIDGE_MARKER}
-${instruction}`;
-}
-function inactiveReason(mode, context, orchestratorTarget) {
-  if (mode === "off")
-    return "bridge mode is off";
-  if (mode === "fork-only" && context !== "fork")
-    return "bridge mode is fork-only and context is not fork";
-  if (!orchestratorTarget)
-    return "orchestrator target is not available";
-}
-function diagnoseIntercomBridge(input) {
-  let mode = resolveIntercomBridgeConfig(input.config).mode, orchestratorTarget = input.orchestratorTarget?.trim(), wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork"), reason = inactiveReason(mode, input.context, orchestratorTarget);
-  return {
-    active: reason === void 0,
-    mode,
-    wantsIntercom,
-    supervisorChannelAvailable: !0,
-    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
-    ...orchestratorTarget ? { orchestratorTarget } : {},
-    ...reason ? { reason } : {}
-  };
-}
-function resolveIntercomBridge(input) {
-  let config = resolveIntercomBridgeConfig(input.config), mode = config.mode, orchestratorTarget = input.orchestratorTarget?.trim(), agentDir = path15.resolve(input.agentDir ?? defaultAgentDir()), settingsDir = path15.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir)), defaultInstruction = buildIntercomBridgeInstruction(orchestratorTarget || "{orchestratorTarget}", DEFAULT_INTERCOM_BRIDGE_TEMPLATE);
-  return inactiveReason(mode, input.context, orchestratorTarget) || !orchestratorTarget ? { active: !1, mode, extensionDir: NATIVE_INTERCOM_EXTENSION_DIR, instruction: defaultInstruction } : {
-    active: !0,
-    mode,
-    orchestratorTarget,
-    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
-    instruction: buildIntercomBridgeInstruction(orchestratorTarget, resolveInstructionTemplate(config.instructionFile, settingsDir))
-  };
-}
-function applyIntercomBridgeToAgent(agent, bridge) {
-  if (!bridge.active || !bridge.orchestratorTarget)
-    return agent;
-  let bridgeTools = ["intercom", "contact_supervisor"], tools = agent.tools ? [...agent.tools, ...bridgeTools.filter((tool) => !agent.tools?.includes(tool))] : agent.tools, instruction = bridge.instruction, trimmedPrompt = agent.systemPrompt?.trim() || "", systemPrompt = trimmedPrompt.includes(INTERCOM_BRIDGE_MARKER) ? trimmedPrompt : trimmedPrompt ? `${trimmedPrompt}
-
-${instruction}` : instruction;
-  return tools === agent.tools && systemPrompt === agent.systemPrompt ? agent : {
-    ...agent,
-    tools,
-    systemPrompt
-  };
-}
-
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/control-channel.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs15 from "node:fs";
-import * as path16 from "node:path";
+import * as fs14 from "node:fs";
+import * as path15 from "node:path";
 var INTERRUPT_SIGNAL = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2", STEER_REQUESTS_DIR = "steer-requests";
-var STEER_ACKS_DIR = "steer-acks", STEER_INBOX_CLOSED_FILE = "steer-inbox-closed.json", MAX_STEER_MESSAGE_BYTES = 128 * 1024, MAX_STEER_REQUEST_ID_LENGTH = 256;
+var STEER_CAPABILITIES_DIR = "steer-capabilities", STEER_ACKS_DIR = "steer-acks", STEER_INBOX_CLOSED_FILE = "steer-inbox-closed.json", MAX_STEER_MESSAGE_BYTES = 128 * 1024, MAX_STEER_REQUEST_ID_LENGTH = 256;
 function controlInboxDir(asyncDir) {
-  return path16.join(asyncDir, "control");
+  return path15.join(asyncDir, "control");
 }
 function interruptRequestPath(asyncDir) {
-  return path16.join(controlInboxDir(asyncDir), "interrupt.json");
+  return path15.join(controlInboxDir(asyncDir), "interrupt.json");
 }
 function stopRequestPath(asyncDir) {
-  return path16.join(controlInboxDir(asyncDir), "stop.json");
+  return path15.join(controlInboxDir(asyncDir), "stop.json");
 }
 function steerRequestsDir(asyncDir) {
-  return path16.join(controlInboxDir(asyncDir), STEER_REQUESTS_DIR);
+  return path15.join(controlInboxDir(asyncDir), STEER_REQUESTS_DIR);
 }
 function steerInboxClosedPath(asyncDir) {
-  return path16.join(controlInboxDir(asyncDir), STEER_INBOX_CLOSED_FILE);
+  return path15.join(controlInboxDir(asyncDir), STEER_INBOX_CLOSED_FILE);
+}
+function steerCapabilitiesDir(asyncDir) {
+  return path15.join(controlInboxDir(asyncDir), STEER_CAPABILITIES_DIR);
+}
+function steerCapabilityPath(asyncDir, index) {
+  return assertChildIndex(index), path15.join(steerCapabilitiesDir(asyncDir), `${index}.json`);
+}
+function assertChildIndex(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 1e6)
+    throw new Error("steer child index must be a non-negative integer.");
 }
 function steerRequestFileName(request) {
   return `${String(request.ts).padStart(13, "0")}-${Buffer.from(request.id).toString("base64url")}.json`;
@@ -4803,7 +4862,7 @@ function validSteerRequest(request) {
 function writeSteerRequestToDir(dir, request) {
   if (!validSteerRequest(request))
     throw new Error("steer request is malformed or exceeds transport limits.");
-  let requestPath = path16.join(dir, steerRequestFileName(request));
+  let requestPath = path15.join(dir, steerRequestFileName(request));
   return writeAtomicJson(requestPath, request), requestPath;
 }
 function requestAsyncInterrupt(asyncDir, payload = {}, deps = {}) {
@@ -4825,7 +4884,7 @@ function requestAsyncSteer(asyncDir, payload, deps = {}) {
   if (payload.targetIndexes !== void 0 && (!Array.isArray(payload.targetIndexes) || payload.targetIndex !== void 0 || payload.targetIndexes.length === 0 || payload.targetIndexes.length > 1e3 || payload.targetIndexes.some((index) => !Number.isInteger(index) || index < 0 || index > 1e6) || new Set(payload.targetIndexes).size !== payload.targetIndexes.length))
     throw new Error("steer targetIndexes must contain 1-1000 unique non-negative integers and cannot be combined with targetIndex.");
   let closedPath = steerInboxClosedPath(asyncDir);
-  if (fs15.existsSync(closedPath))
+  if (fs14.existsSync(closedPath))
     throw new Error("Async run no longer accepts steering requests.");
   let request = {
     type: "steer",
@@ -4836,10 +4895,17 @@ function requestAsyncSteer(asyncDir, payload, deps = {}) {
     ...payload.targetIndexes !== void 0 ? { targetIndexes: [...payload.targetIndexes] } : {},
     ...payload.source ? { source: payload.source } : {}
   }, requestPath = writeSteerRequestToDir(steerRequestsDir(asyncDir), request);
-  if (fs15.existsSync(closedPath))
-    throw fs15.rmSync(requestPath, { force: !0 }), new Error("Async run stopped accepting steering before the request was committed.");
+  if (fs14.existsSync(closedPath))
+    throw fs14.rmSync(requestPath, { force: !0 }), new Error("Async run stopped accepting steering before the request was committed.");
   return requestPath;
 }
+function parseSteerCapability(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (!(input.type !== "steer-capability" || input.protocolVersion !== 1) && !(!Number.isInteger(input.index) || input.index < 0 || input.index > 1e6) && !(!Number.isInteger(input.pid) || input.pid <= 0 || !Number.isFinite(input.readyAt) || input.readyAt <= 0 || typeof input.supported != "boolean"))
+    return { type: "steer-capability", protocolVersion: 1, index: input.index, pid: input.pid, readyAt: input.readyAt, supported: input.supported };
+}
 function parseSteerAck(raw) {
   if (!raw || typeof raw != "object" || Array.isArray(raw))
     return;
@@ -4847,8 +4913,15 @@ function parseSteerAck(raw) {
   if (!(input.type !== "steer-ack" || input.protocolVersion !== 1 || typeof input.requestId != "string" || !/^[^\s]+$/.test(input.requestId) || input.requestId.length > 256) && !(!Number.isInteger(input.index) || input.index < 0 || input.index > 1e6 || !Number.isFinite(input.ts) || input.ts <= 0) && !(input.state !== "delivered" && input.state !== "failed") && !(typeof input.message != "string" || !input.message.trim() || input.message.length > 1e3))
     return { type: "steer-ack", protocolVersion: 1, requestId: input.requestId, index: input.index, ts: input.ts, state: input.state, message: input.message.trim() };
 }
-function consumeSteerAcks(asyncDir, fsImpl = fs15) {
-  let root = path16.join(controlInboxDir(asyncDir), STEER_ACKS_DIR);
+function readSteerCapability(asyncDir, index) {
+  try {
+    return parseSteerCapability(JSON.parse(fs14.readFileSync(steerCapabilityPath(asyncDir, index), "utf-8")));
+  } catch {
+    return;
+  }
+}
+function consumeSteerAcks(asyncDir, fsImpl = fs14) {
+  let root = path15.join(controlInboxDir(asyncDir), STEER_ACKS_DIR);
   if (!fsImpl.existsSync(root))
     return [];
   let acks = [], indexNames;
@@ -4858,14 +4931,14 @@ function consumeSteerAcks(asyncDir, fsImpl = fs15) {
     return [];
   }
   for (let indexName of indexNames) {
-    let dir = path16.join(root, indexName), entries;
+    let dir = path15.join(root, indexName), entries;
     try {
       entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
     } catch {
       continue;
     }
     for (let entry of entries) {
-      let target = path16.join(dir, entry), ack;
+      let target = path15.join(dir, entry), ack;
       try {
         ack = parseSteerAck(JSON.parse(fsImpl.readFileSync(target, "utf-8")));
       } catch {
@@ -4890,7 +4963,7 @@ function deliverInterruptRequest(input) {
       if (error?.code === "ENOSYS")
         return;
       try {
-        fs15.rmSync(requestPath, { force: !0 });
+        fs14.rmSync(requestPath, { force: !0 });
       } catch {
       }
       throw error;
@@ -4900,6 +4973,112 @@ function deliverStopRequest(input) {
   requestAsyncStop(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/intercom-bridge.js
+import * as fs15 from "node:fs";
+import * as os7 from "node:os";
+import * as path16 from "node:path";
+var NATIVE_INTERCOM_EXTENSION_DIR = "native:pi-subagents-supervisor-channel";
+function defaultAgentDir() {
+  return getAgentDir();
+}
+function defaultSubagentConfigDir(agentDir = defaultAgentDir()) {
+  return path16.join(agentDir, "extensions", "subagent");
+}
+var DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat", INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:", DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
+
+Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
+- Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
+- Need structured supervisor input rather than a freeform reply: contact_supervisor({ reason: "interview_request", message: "<what input is needed>", interview: { title: "...", questions: [] } })
+- After contact_supervisor with reason "need_decision" or "interview_request", stay alive and continue only after the reply arrives. Do not finish your final response with a choose-one question.
+- Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. If an output path is configured but no write-capable tool is available, return the complete artifact in your final response; the runtime will persist it. Do not contact the supervisor merely because you cannot write that output path directly.
+- Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
+- Generic intercom is lower-level plumbing/fallback only: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
+
+Do not use contact_supervisor or intercom for routine completion handoffs. If no coordination is needed, return a focused task result.`;
+function resolveIntercomSessionTarget(sessionName, sessionId) {
+  let trimmedName = sessionName?.trim();
+  if (trimmedName)
+    return trimmedName;
+  let normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice(8) : sessionId;
+  return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
+}
+function sanitizeIntercomTargetPart(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function resolveSubagentIntercomTarget(runId, agent, index) {
+  let stepSuffix = index !== void 0 ? `-${index + 1}` : "";
+  return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
+}
+function resolveIntercomBridgeMode(value) {
+  return value === "off" || value === "always" || value === "fork-only" ? value : "always";
+}
+function resolveIntercomBridgeConfig(value) {
+  return !value || typeof value != "object" || Array.isArray(value) ? { mode: "always", instructionFile: "" } : {
+    mode: resolveIntercomBridgeMode(value.mode),
+    instructionFile: typeof value.instructionFile == "string" ? value.instructionFile : ""
+  };
+}
+function expandTilde(filePath) {
+  return filePath.startsWith("~/") ? path16.join(os7.homedir(), filePath.slice(2)) : filePath;
+}
+function resolveInstructionTemplate(instructionFile, settingsDir) {
+  if (!instructionFile)
+    return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
+  let expandedPath = expandTilde(instructionFile), resolvedPath = path16.isAbsolute(expandedPath) ? expandedPath : path16.resolve(settingsDir, expandedPath);
+  try {
+    return fs15.readFileSync(resolvedPath, "utf-8");
+  } catch (error) {
+    return console.warn(`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`, error), DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
+  }
+}
+function buildIntercomBridgeInstruction(orchestratorTarget, template) {
+  let instruction = template.replaceAll("{orchestratorTarget}", orchestratorTarget).trim();
+  return instruction.startsWith(INTERCOM_BRIDGE_MARKER) ? instruction : `${INTERCOM_BRIDGE_MARKER}
+${instruction}`;
+}
+function inactiveReason(mode, context, orchestratorTarget) {
+  if (mode === "off")
+    return "bridge mode is off";
+  if (mode === "fork-only" && context !== "fork")
+    return "bridge mode is fork-only and context is not fork";
+  if (!orchestratorTarget)
+    return "orchestrator target is not available";
+}
+function diagnoseIntercomBridge(input) {
+  let mode = resolveIntercomBridgeConfig(input.config).mode, orchestratorTarget = input.orchestratorTarget?.trim(), wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork"), reason = inactiveReason(mode, input.context, orchestratorTarget);
+  return {
+    active: reason === void 0,
+    mode,
+    wantsIntercom,
+    supervisorChannelAvailable: !0,
+    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+    ...orchestratorTarget ? { orchestratorTarget } : {},
+    ...reason ? { reason } : {}
+  };
+}
+function resolveIntercomBridge(input) {
+  let config = resolveIntercomBridgeConfig(input.config), mode = config.mode, orchestratorTarget = input.orchestratorTarget?.trim(), agentDir = path16.resolve(input.agentDir ?? defaultAgentDir()), settingsDir = path16.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir)), defaultInstruction = buildIntercomBridgeInstruction(orchestratorTarget || "{orchestratorTarget}", DEFAULT_INTERCOM_BRIDGE_TEMPLATE);
+  return inactiveReason(mode, input.context, orchestratorTarget) || !orchestratorTarget ? { active: !1, mode, extensionDir: NATIVE_INTERCOM_EXTENSION_DIR, instruction: defaultInstruction } : {
+    active: !0,
+    mode,
+    orchestratorTarget,
+    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+    instruction: buildIntercomBridgeInstruction(orchestratorTarget, resolveInstructionTemplate(config.instructionFile, settingsDir))
+  };
+}
+function applyIntercomBridgeToAgent(agent, bridge) {
+  if (!bridge.active || !bridge.orchestratorTarget)
+    return agent;
+  let bridgeTools = ["intercom", "contact_supervisor"], tools = agent.tools ? [...agent.tools, ...bridgeTools.filter((tool) => !agent.tools?.includes(tool))] : agent.tools, instruction = bridge.instruction, trimmedPrompt = agent.systemPrompt?.trim() || "", systemPrompt = trimmedPrompt.includes(INTERCOM_BRIDGE_MARKER) ? trimmedPrompt : trimmedPrompt ? `${trimmedPrompt}
+
+${instruction}` : instruction;
+  return tools === agent.tools && systemPrompt === agent.systemPrompt ? agent : {
+    ...agent,
+    tools,
+    systemPrompt
+  };
+}
+
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/async-resume.js
 import * as fs16 from "node:fs";
 import * as path17 from "node:path";
@@ -4930,6 +5109,15 @@ function interruptLiveAsyncResumeTarget(input) {
 function getErrorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var TURN_BUDGET_RUNTIME_KEYS = /* @__PURE__ */ new Set(["outcome", "turnCount", "wrapUpRequestedAtTurn", "exceededAtTurn"]);
+function persistedTurnBudgetConfig(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return raw;
+  let config = {};
+  for (let [key, value] of Object.entries(raw))
+    TURN_BUDGET_RUNTIME_KEYS.has(key) || (config[key] = value);
+  return config;
+}
 function ensureObject(value, source) {
   if (!value || typeof value != "object" || Array.isArray(value))
     throw new Error(`Async result file '${source}' must contain a JSON object.`);
@@ -5153,7 +5341,7 @@ function readAsyncRecoveryDescriptor(asyncDir) {
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${field} must be a non-empty string.`);
   if (parsed.permissions !== "full" && parsed.permissions !== "read-only")
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': permissions must be full or read-only.`);
-  if (parsed.tier !== "light" && parsed.tier !== "standard" && parsed.tier !== "heavy")
+  if (parsed.tier !== void 0 && parsed.tier !== "light" && parsed.tier !== "standard" && parsed.tier !== "heavy")
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': tier must be light, standard, or heavy.`);
   if (validateChildDescription(parsed.description, `Async recovery descriptor '${descriptorPath}' description`), parsed.outputMode !== "inline" && parsed.outputMode !== "file-only")
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': outputMode is invalid.`);
@@ -5174,17 +5362,23 @@ function readAsyncRecoveryDescriptor(asyncDir) {
     let selection = parsed.modelSelection;
     if (!selection || typeof selection != "object")
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelSelection must be an object.`);
-    if (selection.kind !== "tier")
+    if (selection.kind === "tier") {
+      if (selection.tier !== "light" && selection.tier !== "standard" && selection.tier !== "heavy")
+        throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelSelection.tier is invalid.`);
+    } else if (selection.kind === "model") {
+      if (selection.model !== void 0 && (typeof selection.model != "string" || !selection.model.trim()))
+        throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelSelection.model must be a non-empty string.`);
+    } else
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelSelection.kind is invalid.`);
-    if (selection.kind === "tier" && selection.tier !== "light" && selection.tier !== "standard" && selection.tier !== "heavy")
-      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelSelection.tier is invalid.`);
-  }
+  } else if (parsed.tier === void 0)
+    throw new Error(`Invalid async recovery descriptor '${descriptorPath}': tier or modelSelection is required.`);
   if (parsed.absoluteDeadlineAt !== void 0 && (!Number.isFinite(parsed.absoluteDeadlineAt) || parsed.absoluteDeadlineAt <= 0))
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': absoluteDeadlineAt must be a positive timestamp.`);
   if (parsed.initialTurnBudget !== void 0) {
-    let result = resolveTurnBudgetConfig(parsed.initialTurnBudget, "recoveryDescriptor.initialTurnBudget");
+    let result = resolveTurnBudgetConfig(persistedTurnBudgetConfig(parsed.initialTurnBudget), "recoveryDescriptor.initialTurnBudget");
     if (result.error)
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${result.error}`);
+    result.turnBudget && (parsed.initialTurnBudget = result.turnBudget);
   }
   if (parsed.initialToolBudget !== void 0) {
     let result = validateToolBudgetConfig(parsed.initialToolBudget, "recoveryDescriptor.initialToolBudget");
@@ -5230,7 +5424,7 @@ function readAsyncRecoveryDescriptor(asyncDir) {
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': controlConfig.notifyChannels is invalid.`);
   }
   if (parsed.acceptance !== void 0) {
-    let errors = validateAcceptanceInput(parsed.acceptance, "recoveryDescriptor.acceptance");
+    let errors = validatePersistedAcceptance(parsed.acceptance, "recoveryDescriptor.acceptance");
     if (errors.length)
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${errors.join(" ")}`);
   }
@@ -5283,6 +5477,7 @@ function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
           sessionFile: selectedStep.sessionFile ?? status?.sessionFile ?? result?.sessionFile,
           model: selectedStep.model,
           thinking: selectedStep.thinking,
+          modelSelection: selectedStep.modelSelection,
           ...recoveryDescriptor ? { recoveryDescriptor } : {}
         };
       if (selectedStep?.status === "pending")
@@ -5308,6 +5503,7 @@ function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
         sessionFile: selected.step.sessionFile ?? status?.sessionFile ?? result?.sessionFile,
         model: selected.step.model,
         thinking: selected.step.thinking,
+        modelSelection: selected.step.modelSelection,
         ...recoveryDescriptor ? { recoveryDescriptor } : {}
       };
     }
@@ -5340,6 +5536,7 @@ function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
     intercomTarget: resolveSubagentIntercomTarget(runId, childId ?? agent, index),
     cwd: status?.cwd ?? result?.cwd,
     ...resolvedSessionFile ? { sessionFile: resolvedSessionFile } : {},
+    modelSelection: statusSteps[index]?.modelSelection,
     ...stepModel ? { model: stepModel } : {},
     ...stepThinking ? { thinking: stepThinking } : {},
     ...recoveryDescriptor ? { recoveryDescriptor } : {}
@@ -5361,6 +5558,76 @@ function buildRevivedAsyncTask(target, message) {
 `);
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/run-id-resolver.js
+import * as fs17 from "node:fs";
+import * as path18 from "node:path";
+function exactAsyncLocation(id, asyncDirRoot, resultsDir) {
+  let asyncDir = path18.join(asyncDirRoot, id), resultPath = path18.join(resultsDir, `${id}.json`);
+  if (!(!fs17.existsSync(asyncDir) && !fs17.existsSync(resultPath)))
+    return {
+      asyncDir: fs17.existsSync(asyncDir) ? asyncDir : null,
+      resultPath: fs17.existsSync(resultPath) ? resultPath : null,
+      resolvedId: id
+    };
+}
+function foregroundIds(state) {
+  if (!state)
+    return [];
+  let remembered = state.currentSessionId ? [...state.foregroundRuns?.values() ?? []].filter((run) => run.sessionId === state.currentSessionId).map((run) => run.runId) : [];
+  return [.../* @__PURE__ */ new Set([...state.foregroundControls.keys(), ...remembered])];
+}
+function hasExactForegroundId(state, id) {
+  if (!state)
+    return !1;
+  if (state.foregroundControls.has(id))
+    return !0;
+  let remembered = state.foregroundRuns?.get(id);
+  return !!(remembered && state.currentSessionId && remembered.sessionId === state.currentSessionId);
+}
+function nestedScopeFromState(state) {
+  if (!state)
+    return;
+  let routes = [], seen = /* @__PURE__ */ new Set(), add = (route) => {
+    if (!route)
+      return;
+    let key = `${route.rootRunId}:${route.eventSink}:${route.controlInbox}`;
+    seen.has(key) || (seen.add(key), routes.push(route));
+  };
+  for (let control of state.foregroundControls.values())
+    add(control.nestedRoute);
+  for (let job of state.asyncJobs.values())
+    add(job.nestedRoute);
+  return { routes };
+}
+function asyncPrefixMatches(prefix, asyncDirRoot, resultsDir) {
+  return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
+}
+function resolveSubagentRunId(id, deps = {}) {
+  assertSafeNestedId("id", id);
+  let asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR, resultsDir = deps.resultsDir ?? RESULTS_DIR, nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
+  if (hasExactForegroundId(deps.state, id))
+    return { kind: "foreground", id };
+  let exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
+  if (exactAsync)
+    return { kind: "async", id, location: exactAsync };
+  let exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
+  if (exactNested.length > 1)
+    throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
+  if (exactNested[0])
+    return { kind: "nested", id, match: exactNested[0] };
+  let matches = [];
+  for (let foregroundId of foregroundIds(deps.state).filter((candidate) => candidate.startsWith(id)))
+    matches.push({ kind: "foreground", id: foregroundId });
+  for (let match of asyncPrefixMatches(id, asyncDirRoot, resultsDir))
+    matches.push({ kind: "async", id: match.id, location: match.location });
+  for (let match of findNestedRunMatchesById(id, nestedScope ? { prefix: !0, scope: nestedScope } : { prefix: !0 }))
+    matches.push({ kind: "nested", id: match.run.id, match });
+  let values = [...new Map(matches.map((match) => [`${match.kind}:${match.id}`, match])).values()];
+  if (values.length > 1)
+    throw new Error(`Ambiguous subagent run id prefix '${id}' matched: ${values.map((match) => `${match.kind}:${match.id}`).join(", ")}. Provide a longer id.`);
+  return values[0];
+}
+
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/control-notices.js
 var SUBAGENT_CONTROL_MESSAGE_TYPE = "subagent_control_notice";
 function controlNoticeTarget(details) {
@@ -5411,8 +5678,8 @@ function handleSubagentControlNotice(input) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/async-status.js
-import * as fs17 from "node:fs";
-import * as path18 from "node:path";
+import * as fs18 from "node:fs";
+import * as path19 from "node:path";
 function getErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -5420,9 +5687,9 @@ function isNotFoundError3(error) {
   return typeof error == "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAsyncRunDir(root, entry) {
-  let entryPath = path18.join(root, entry);
+  let entryPath = path19.join(root, entry);
   try {
-    return fs17.statSync(entryPath).isDirectory();
+    return fs18.statSync(entryPath).isDirectory();
   } catch (error) {
     if (isNotFoundError3(error))
       return !1;
@@ -5434,7 +5701,7 @@ function isAsyncRunDir(root, entry) {
 function outputFileMtime(outputFile) {
   if (outputFile)
     try {
-      return fs17.statSync(outputFile).mtimeMs;
+      return fs18.statSync(outputFile).mtimeMs;
     } catch (error) {
       if (isNotFoundError3(error))
         return;
@@ -5446,7 +5713,7 @@ function outputFileMtime(outputFile) {
 function deriveAsyncActivityState(asyncDir, status) {
   if (status.state !== "running")
     return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
-  let outputPath = status.outputFile ? path18.isAbsolute(status.outputFile) ? status.outputFile : path18.join(asyncDir, status.outputFile) : void 0, currentStep = typeof status.currentStep == "number" ? status.steps?.[status.currentStep] : void 0;
+  let outputPath = status.outputFile ? path19.isAbsolute(status.outputFile) ? status.outputFile : path19.join(asyncDir, status.outputFile) : void 0, currentStep = typeof status.currentStep == "number" ? status.steps?.[status.currentStep] : void 0;
   return {
     activityState: status.activityState,
     lastActivityAt: status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt
@@ -5454,7 +5721,7 @@ function deriveAsyncActivityState(asyncDir, status) {
 }
 function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
   if (status.sessionId !== void 0 && typeof status.sessionId != "string")
-    throw new Error(`Invalid async status '${path18.join(asyncDir, "status.json")}': sessionId must be a string.`);
+    throw new Error(`Invalid async status '${path19.join(asyncDir, "status.json")}': sessionId must be a string.`);
   let { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status), steps = status.steps ?? [], chainStepCount = status.chainStepCount ?? steps.length, parallelGroups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount), nestedChildren = [];
   if (nestedWarnings.length === 0 && nestedRoute)
     try {
@@ -5500,8 +5767,8 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
       ...step.children?.length ? { children: step.children } : {}
     };
   });
-  return attachRootChildrenToSteps(status.runId || path18.basename(asyncDir), summarizedSteps, nestedChildren), {
-    id: status.runId || path18.basename(asyncDir),
+  return attachRootChildrenToSteps(status.runId || path19.basename(asyncDir), summarizedSteps, nestedChildren), {
+    id: status.runId || path19.basename(asyncDir),
     asyncDir,
     ...status.sessionId ? { sessionId: status.sessionId } : {},
     state: status.state,
@@ -5571,7 +5838,7 @@ function sortRuns(runs) {
 function listAsyncRuns(asyncDirRoot, options = {}) {
   let entries;
   try {
-    entries = fs17.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
+    entries = fs18.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
   } catch (error) {
     if (isNotFoundError3(error))
       return [];
@@ -5581,13 +5848,13 @@ function listAsyncRuns(asyncDirRoot, options = {}) {
   }
   let allowedStates = options.states ? new Set(options.states) : void 0, runs = [], nestedRouteIndex, resolveNestedRoute = (rootRunId) => (nestedRouteIndex || (nestedRouteIndex = buildNestedRouteIndex()), nestedRouteIndex.get(rootRunId));
   for (let entry of entries) {
-    let asyncDir = path18.join(asyncDirRoot, entry), status = (options.reconcile === !1 ? void 0 : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }))?.status ?? readStatus(asyncDir);
+    let asyncDir = path19.join(asyncDirRoot, entry), status = (options.reconcile === !1 ? void 0 : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }))?.status ?? readStatus(asyncDir);
     if (!status || allowedStates && !allowedStates.has(status.state) || options.sessionId && status.sessionId !== options.sessionId)
       continue;
     let nestedWarnings = [], nestedRoute;
     if (options.reconcile !== !1)
       try {
-        nestedRoute = resolveNestedRoute(status.runId || path18.basename(asyncDir)), nestedRoute && reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
+        nestedRoute = resolveNestedRoute(status.runId || path19.basename(asyncDir)), nestedRoute && reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
       } catch (error) {
         nestedWarnings.push(`Nested status unavailable: ${getErrorMessage4(error)}`);
       }
@@ -5615,7 +5882,7 @@ function formatStepLine(step) {
 }
 function formatAsyncRunOutputPath(run) {
   if (run.outputFile)
-    return path18.isAbsolute(run.outputFile) ? run.outputFile : path18.join(run.asyncDir, run.outputFile);
+    return path19.isAbsolute(run.outputFile) ? run.outputFile : path19.join(run.asyncDir, run.outputFile);
 }
 function formatAsyncRunProgressLabel(run) {
   let stepCount = run.steps.length || 1, chainStepCount = run.chainStepCount ?? stepCount, groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, chainStepCount), activeGroup = run.currentStep !== void 0 ? groups.find((group) => run.currentStep >= group.start && run.currentStep < group.start + group.count) : void 0;
@@ -5649,8 +5916,8 @@ function formatAsyncRunList(runs, heading = "Active async runs") {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/fleet-view.js
-import * as fs18 from "node:fs";
-import * as path19 from "node:path";
+import * as fs19 from "node:fs";
+import * as path20 from "node:path";
 var DEFAULT_TRANSCRIPT_LINES = 80, MAX_TRANSCRIPT_LINES = 500, TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 function transcriptLineLimit(value) {
   return value === void 0 || !Number.isFinite(value) ? DEFAULT_TRANSCRIPT_LINES : Math.max(1, Math.min(MAX_TRANSCRIPT_LINES, Math.trunc(value)));
@@ -5663,11 +5930,11 @@ function uniqueStrings2(values) {
 }
 function resolveMaybeRelative(asyncDir, filePath) {
   if (filePath)
-    return path19.resolve(asyncDir, filePath);
+    return path20.resolve(asyncDir, filePath);
 }
 function pathWithin(base, candidate) {
-  let resolvedBase = path19.resolve(base), resolvedCandidate = path19.resolve(candidate);
-  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path19.sep}`);
+  let resolvedBase = path20.resolve(base), resolvedCandidate = path20.resolve(candidate);
+  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path20.sep}`);
 }
 function getErrorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5678,7 +5945,7 @@ function isNotFoundError4(error) {
 function readTextTail(filePath, maxLines) {
   let stat;
   try {
-    stat = fs18.statSync(filePath);
+    stat = fs19.statSync(filePath);
   } catch (error) {
     return isNotFoundError4(error) ? { path: filePath, lines: [], truncated: !1 } : { path: filePath, lines: [], truncated: !1, error: getErrorMessage5(error) };
   }
@@ -5687,24 +5954,24 @@ function readTextTail(filePath, maxLines) {
   let fd;
   try {
     let bytesToRead = Math.min(stat.size, TRANSCRIPT_TAIL_BYTES), start = stat.size - bytesToRead, buffer = Buffer.alloc(bytesToRead);
-    fd = fs18.openSync(filePath, "r");
-    let bytesRead = fs18.readSync(fd, buffer, 0, bytesToRead, start), lines = buffer.subarray(0, bytesRead).toString("utf-8").split(/\r?\n/);
+    fd = fs19.openSync(filePath, "r");
+    let bytesRead = fs19.readSync(fd, buffer, 0, bytesToRead, start), lines = buffer.subarray(0, bytesRead).toString("utf-8").split(/\r?\n/);
     return start > 0 && lines.length > 0 && (lines = lines.slice(1)), lines.at(-1) === "" && (lines = lines.slice(0, -1)), { path: filePath, lines: lines.slice(-maxLines), truncated: start > 0 || lines.length > maxLines };
   } catch (error) {
     return { path: filePath, lines: [], truncated: !1, error: getErrorMessage5(error) };
   } finally {
-    fd !== void 0 && fs18.closeSync(fd);
+    fd !== void 0 && fs19.closeSync(fd);
   }
 }
 function readContainedTextTail(filePath, maxLines, trustedRoots, label) {
   if (trustedRoots.length === 0)
     return { path: filePath, lines: [], truncated: !1, error: `Refusing to read ${label} transcript path without a trusted root: ${filePath}` };
-  let resolvedPath = path19.resolve(filePath);
+  let resolvedPath = path20.resolve(filePath);
   if (!trustedRoots.some((root) => pathWithin(root, resolvedPath)))
     return { path: filePath, lines: [], truncated: !1, error: `Refusing to read ${label} transcript path outside trusted roots: ${filePath}` };
   let lstat;
   try {
-    lstat = fs18.lstatSync(resolvedPath);
+    lstat = fs19.lstatSync(resolvedPath);
   } catch (error) {
     return isNotFoundError4(error) ? { path: filePath, lines: [], truncated: !1 } : { path: filePath, lines: [], truncated: !1, error: getErrorMessage5(error) };
   }
@@ -5714,7 +5981,7 @@ function readContainedTextTail(filePath, maxLines, trustedRoots, label) {
     return { path: filePath, lines: [], truncated: !1, error: `Refusing to read non-file ${label} transcript path: ${filePath}` };
   let realPath, realRoots;
   try {
-    realPath = fs18.realpathSync(resolvedPath), realRoots = trustedRoots.filter((root) => fs18.existsSync(root)).map((root) => fs18.realpathSync(root));
+    realPath = fs19.realpathSync(resolvedPath), realRoots = trustedRoots.filter((root) => fs19.existsSync(root)).map((root) => fs19.realpathSync(root));
   } catch (error) {
     return { path: filePath, lines: [], truncated: !1, error: getErrorMessage5(error) };
   }
@@ -5805,8 +6072,8 @@ function formatAsyncFleetLines(runs) {
     for (let step of run.steps) {
       let display = step.label ? `${step.label} (${step.agent})` : step.agent, phase = step.phase ? `[${step.phase}] ` : "", stepActivity = formatActivityFacts2(step), modelThinking = formatModelSelection(step.modelSelection, step.model, step.thinking), parts = [`${step.index}. ${phase}${display}`, step.status, stepActivity, modelThinking].filter(Boolean);
       lines.push(`  ${parts.join(" | ")}`);
-      let output = path19.join(run.asyncDir, `output-${step.index}.log`);
-      fs18.existsSync(output) && lines.push(`    output: ${shortenPath(output)}`), step.sessionFile && lines.push(`    session: ${shortenPath(step.sessionFile)}`), (step.status === "running" || step.recentOutput?.length || fs18.existsSync(output)) && lines.push(`    transcript: subagent({ action: "status", id: "${run.id}", index: ${step.index}, view: "transcript" })`), lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: !0, maxLines: 12 }));
+      let output = path20.join(run.asyncDir, `output-${step.index}.log`);
+      fs19.existsSync(output) && lines.push(`    output: ${shortenPath(output)}`), step.sessionFile && lines.push(`    session: ${shortenPath(step.sessionFile)}`), (step.status === "running" || step.recentOutput?.length || fs19.existsSync(output)) && lines.push(`    transcript: subagent({ action: "status", id: "${run.id}", index: ${step.index}, view: "transcript" })`), lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: !0, maxLines: 12 }));
     }
     let attached = new Set(run.steps.flatMap((step) => step.children?.map((child) => child.id) ?? [])), unattached = run.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
     lines.push(...formatNestedRunStatusLines(unattached, { indent: "  ", commandHints: !0, maxLines: 12 })), run.error && lines.push(`  error: ${run.error}`);
@@ -5896,14 +6163,14 @@ function appendTranscriptBody(lines, sourceLabel, sourceLines, truncated) {
     lines.push(`  ${line}`);
 }
 function formatAsyncRunTranscript(status, asyncDir, options = {}) {
-  let lineLimit = transcriptLineLimit(options.lines), selected = selectTranscriptStep(status, options), stepOutputPath = selected.index !== void 0 ? path19.join(asyncDir, `output-${selected.index}.log`) : void 0, runOutputPath = resolveMaybeRelative(asyncDir, status.outputFile), logPath = path19.join(asyncDir, `subagent-log-${status.runId}.md`), outputPaths = selected.index !== void 0 ? uniqueStrings2([stepOutputPath, runOutputPath && stepOutputPath && path19.resolve(runOutputPath) === path19.resolve(stepOutputPath) ? runOutputPath : void 0]) : uniqueStrings2([runOutputPath]), sessionFile = selected.index !== void 0 ? selected.step?.sessionFile : status.sessionFile, eventsPath = path19.join(asyncDir, "events.jsonl"), lines = [
+  let lineLimit = transcriptLineLimit(options.lines), selected = selectTranscriptStep(status, options), stepOutputPath = selected.index !== void 0 ? path20.join(asyncDir, `output-${selected.index}.log`) : void 0, runOutputPath = resolveMaybeRelative(asyncDir, status.outputFile), logPath = path20.join(asyncDir, `subagent-log-${status.runId}.md`), outputPaths = selected.index !== void 0 ? uniqueStrings2([stepOutputPath, runOutputPath && stepOutputPath && path20.resolve(runOutputPath) === path20.resolve(stepOutputPath) ? runOutputPath : void 0]) : uniqueStrings2([runOutputPath]), sessionFile = selected.index !== void 0 ? selected.step?.sessionFile : status.sessionFile, eventsPath = path20.join(asyncDir, "events.jsonl"), lines = [
     `Run: ${status.runId}`,
     `State: ${status.state}`,
     `Mode: ${status.mode}`,
     stepStateLine(status.mode, selected.index, selected.step),
     selected.hint
   ].filter((line) => !!line);
-  appendKnownArtifacts(lines, { outputPaths, sessionFile, eventsPath: fs18.existsSync(eventsPath) ? eventsPath : void 0, logPath: fs18.existsSync(logPath) ? logPath : void 0 });
+  appendKnownArtifacts(lines, { outputPaths, sessionFile, eventsPath: fs19.existsSync(eventsPath) ? eventsPath : void 0, logPath: fs19.existsSync(logPath) ? logPath : void 0 });
   let warnings = [], transcriptLines = [], transcriptSource = "Transcript tail", truncated = !1;
   for (let outputPath of outputPaths) {
     let tail = readContainedTextTail(outputPath, lineLimit, [asyncDir], "output");
@@ -5949,7 +6216,7 @@ function formatNestedRunTranscript(run, options = {}) {
 `);
 }
 function formatAsyncResultTranscript(data, resultPath, options = {}) {
-  let lineLimit = transcriptLineLimit(options.lines), runId = data.runId ?? data.id ?? path19.basename(resultPath, ".json"), children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, output: data.output, summary: data.summary, sessionFile: data.sessionFile, state: data.state, success: data.success, exitCode: data.exitCode }] : [], index = options.index;
+  let lineLimit = transcriptLineLimit(options.lines), runId = data.runId ?? data.id ?? path20.basename(resultPath, ".json"), children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, output: data.output, summary: data.summary, sessionFile: data.sessionFile, state: data.state, success: data.success, exitCode: data.exitCode }] : [], index = options.index;
   if (index !== void 0 && !Number.isInteger(index))
     throw new Error("Transcript index must be an integer.");
   if (index === void 0 && children.length === 1 && (index = 0), index !== void 0 && (index < 0 || index >= children.length))
@@ -6087,8 +6354,8 @@ function recommendStrongWatchdogModel(ctx) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/watchdog/settings.js
-import * as fs19 from "node:fs";
-import * as path20 from "node:path";
+import * as fs20 from "node:fs";
+import * as path21 from "node:path";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/watchdog/types.js
 var SUBAGENT_WATCHDOG_WARNING_TYPE = "subagent_watchdog_warning", WATCHDOG_WARNING_SEVERITIES = ["concern", "blocker"], WATCHDOG_WARNING_CATEGORIES = [
@@ -6214,7 +6481,7 @@ function parseNonEmptyString(value, field, meta) {
     return value.trim();
   throw invalid(meta, field, "a non-empty string");
 }
-function parseThinking(value, field, meta) {
+function parseThinking2(value, field, meta) {
   if (value === !1)
     return !1;
   if (typeof value == "string" && THINKING_LEVELS.includes(value))
@@ -6253,19 +6520,19 @@ function parseEndpointPatch(value, field, meta) {
   let input = parseObject(value, field, meta);
   assertKnownFields(input, ENDPOINT_FIELDS, field, meta);
   let patch = {};
-  return "enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking(input.thinking, `${field}.thinking`, meta)), patch;
+  return "enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking2(input.thinking, `${field}.thinking`, meta)), patch;
 }
 function parseChildOverridePatch(value, field, meta) {
   let input = parseObject(value, field, meta);
   assertKnownFields(input, CHILD_OVERRIDE_FIELDS, field, meta);
   let patch = {};
-  return "enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking(input.thinking, `${field}.thinking`, meta)), patch;
+  return "enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking2(input.thinking, `${field}.thinking`, meta)), patch;
 }
 function parseChildrenPatch(value, field, meta) {
   let input = parseObject(value, field, meta);
   assertKnownFields(input, CHILDREN_FIELDS, field, meta);
   let patch = {};
-  if ("enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking(input.thinking, `${field}.thinking`, meta)), "watchdogTailTimeoutMs" in input && (patch.watchdogTailTimeoutMs = parseInteger(input.watchdogTailTimeoutMs, `${field}.watchdogTailTimeoutMs`, meta, "a positive integer", (candidate) => candidate >= 1)), "autoFollow" in input && (patch.autoFollow = parseAutoFollowPatch(input.autoFollow, `${field}.autoFollow`, meta)), "overrides" in input) {
+  if ("enabled" in input && (patch.enabled = parseBoolean(input.enabled, `${field}.enabled`, meta)), "model" in input && (patch.model = parseNonEmptyString(input.model, `${field}.model`, meta)), "thinking" in input && (patch.thinking = parseThinking2(input.thinking, `${field}.thinking`, meta)), "watchdogTailTimeoutMs" in input && (patch.watchdogTailTimeoutMs = parseInteger(input.watchdogTailTimeoutMs, `${field}.watchdogTailTimeoutMs`, meta, "a positive integer", (candidate) => candidate >= 1)), "autoFollow" in input && (patch.autoFollow = parseAutoFollowPatch(input.autoFollow, `${field}.autoFollow`, meta)), "overrides" in input) {
     let overrides = parseObject(input.overrides, `${field}.overrides`, meta);
     patch.overrides = {};
     for (let [agent, override] of Object.entries(overrides)) {
@@ -6301,11 +6568,11 @@ function parseSettingsObject(settings, meta) {
   return "watchdog" in subagents ? parseWatchdogPatch(subagents.watchdog, "subagents.watchdog", meta) : {};
 }
 function readSettingsFileStrict(filePath) {
-  if (!fs19.existsSync(filePath))
+  if (!fs20.existsSync(filePath))
     return {};
   let raw;
   try {
-    raw = fs19.readFileSync(filePath, "utf-8");
+    raw = fs20.readFileSync(filePath, "utf-8");
   } catch (error) {
     let message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to read settings file '${filePath}': ${message}`, { cause: error });
@@ -6323,13 +6590,13 @@ function readSettingsFileStrict(filePath) {
 }
 function isDirectory(dir) {
   try {
-    return fs19.statSync(dir).isDirectory();
+    return fs20.statSync(dir).isDirectory();
   } catch {
     return !1;
   }
 }
 function getUserSettingsPath() {
-  return path20.join(getAgentDir(), "settings.json");
+  return path21.join(getAgentDir(), "settings.json");
 }
 function getWatchdogUserSettingsPath() {
   return getUserSettingsPath();
@@ -6337,16 +6604,16 @@ function getWatchdogUserSettingsPath() {
 function getProjectSettingsPath(cwd) {
   let currentDir = cwd;
   for (; ; ) {
-    if (isDirectory(getProjectConfigDir(currentDir)) || isDirectory(path20.join(currentDir, ".agents")))
-      return path20.join(getProjectConfigDir(currentDir), "settings.json");
-    let parentDir = path20.dirname(currentDir);
+    if (isDirectory(getProjectConfigDir(currentDir)) || isDirectory(path21.join(currentDir, ".agents")))
+      return path21.join(getProjectConfigDir(currentDir), "settings.json");
+    let parentDir = path21.dirname(currentDir);
     if (parentDir === currentDir)
       return;
     currentDir = parentDir;
   }
 }
 function getWatchdogProjectSettingsPath(cwd) {
-  return path20.join(getProjectConfigDir(cwd), "settings.json");
+  return path21.join(getProjectConfigDir(cwd), "settings.json");
 }
 function deepMerge(base, patch) {
   let next = { ...base };
@@ -6390,7 +6657,7 @@ function targetSettingsObject(watchdog, target, meta) {
   return ensureObjectField(overrides, target.agent.trim(), `subagents.watchdog.children.overrides.${target.agent.trim()}`, meta);
 }
 function writeSettingsFile(settingsPath, settings) {
-  return fs19.mkdirSync(path20.dirname(settingsPath), { recursive: !0 }), fs19.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  return fs20.mkdirSync(path21.dirname(settingsPath), { recursive: !0 }), fs20.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8"), settingsPath;
 }
 function writeUserWatchdogEnabled(enabled) {
@@ -6408,7 +6675,7 @@ function resolveWatchdogConfig(cwd, options = {}) {
   ];
   for (let source of sourceSpecs)
     if (source.path) {
-      sources.push({ scope: source.scope, path: source.path, exists: fs19.existsSync(source.path) });
+      sources.push({ scope: source.scope, path: source.path, exists: fs20.existsSync(source.path) });
       try {
         patch = deepMerge(patch, parseSourceFile(source.path, source.scope));
       } catch (error) {
@@ -6682,8 +6949,8 @@ import { createHash as createHash4 } from "node:crypto";
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/watchdog/change-signature.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import * as fs20 from "node:fs";
-import * as path21 from "node:path";
+import * as fs21 from "node:fs";
+import * as path22 from "node:path";
 var IGNORED_CHANGE_PREFIXES = [".pi-subagents/", "tmp/", "node_modules/"], IGNORED_CHANGE_PATHS = /* @__PURE__ */ new Set([".pi-subagents", "tmp", "node_modules"]);
 function git(cwd, args) {
   let result = spawnSync2("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10485760 });
@@ -6691,28 +6958,28 @@ function git(cwd, args) {
     return result.stdout;
 }
 function normalizeRelPath(value) {
-  return value.replaceAll(path21.sep, "/").replace(/^\.\//, "");
+  return value.replaceAll(path22.sep, "/").replace(/^\.\//, "");
 }
 function ignoredRelPath(relPath) {
   let normalized = normalizeRelPath(relPath);
   return IGNORED_CHANGE_PATHS.has(normalized) || IGNORED_CHANGE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
 }
 function hashFile(filePath) {
-  return createHash2("sha256").update(fs20.readFileSync(filePath)).digest("hex");
+  return createHash2("sha256").update(fs21.readFileSync(filePath)).digest("hex");
 }
 function hashPath(root, relPath) {
-  let normalized = normalizeRelPath(relPath), fullPath = path21.join(root, normalized), stat;
+  let normalized = normalizeRelPath(relPath), fullPath = path22.join(root, normalized), stat;
   try {
-    stat = fs20.lstatSync(fullPath);
+    stat = fs21.lstatSync(fullPath);
   } catch (error) {
     if (error.code === "ENOENT")
       return { path: normalized, state: "deleted" };
     throw error;
   }
   if (stat.isSymbolicLink())
-    return { path: normalized, state: "symlink", target: fs20.readlinkSync(fullPath) };
+    return { path: normalized, state: "symlink", target: fs21.readlinkSync(fullPath) };
   if (stat.isDirectory()) {
-    let entries = fs20.readdirSync(fullPath).map((entry) => normalizeRelPath(path21.posix.join(normalized, entry))).filter((entry) => !ignoredRelPath(entry)).sort();
+    let entries = fs21.readdirSync(fullPath).map((entry) => normalizeRelPath(path22.posix.join(normalized, entry))).filter((entry) => !ignoredRelPath(entry)).sort();
     return { path: normalized, state: "dir", entries: entries.map((entry) => hashPath(root, entry)) };
   }
   return stat.isFile() ? { path: normalized, state: "file", mode: stat.mode & 511, size: stat.size, hash: hashFile(fullPath) } : { path: normalized, state: "other", mode: stat.mode };
@@ -6845,8 +7112,8 @@ var WatchdogEmissionGuard = class {
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/watchdog/lsp-diagnostics.js
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import * as fs21 from "node:fs";
-import * as path22 from "node:path";
+import * as fs22 from "node:fs";
+import * as path23 from "node:path";
 import { pathToFileURL } from "node:url";
 var TS_JS_EXTENSIONS = /* @__PURE__ */ new Map([
   [".ts", "typescript"],
@@ -6859,14 +7126,14 @@ var TS_JS_EXTENSIONS = /* @__PURE__ */ new Map([
   [".cjs", "javascript"]
 ]), PROVIDER_NAME = "typescript-language-server", MAX_MESSAGE_LENGTH = 500, MAX_STDERR_LENGTH = 2e3, SHUTDOWN_TIMEOUT_MS = 250;
 function normalizeRelPath2(value) {
-  return value.replaceAll(path22.sep, "/").replace(/^\.\//, "");
+  return value.replaceAll(path23.sep, "/").replace(/^\.\//, "");
 }
 function isPathInsideRoot(absPath, root) {
-  let rel = path22.relative(root, absPath);
-  return rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel);
+  let rel = path23.relative(root, absPath);
+  return rel === "" || !rel.startsWith("..") && !path23.isAbsolute(rel);
 }
 function languageIdForPath(filePath) {
-  return TS_JS_EXTENSIONS.get(path22.extname(filePath).toLowerCase());
+  return TS_JS_EXTENSIONS.get(path23.extname(filePath).toLowerCase());
 }
 function trimDiagnosticMessage(message) {
   let normalized = message.replace(/\s+/g, " ").trim();
@@ -6877,7 +7144,7 @@ function severityFromLsp(value) {
 }
 function pathExecutable(filePath) {
   try {
-    return fs21.statSync(filePath).isFile() ? (process.platform === "win32" || fs21.accessSync(filePath, fs21.constants.X_OK), !0) : !1;
+    return fs22.statSync(filePath).isFile() ? (process.platform === "win32" || fs22.accessSync(filePath, fs22.constants.X_OK), !0) : !1;
   } catch {
     return !1;
   }
@@ -6890,13 +7157,13 @@ function pathExecutableNames(name) {
 }
 function resolveTypeScriptLanguageServer(root) {
   for (let name of pathExecutableNames(PROVIDER_NAME)) {
-    let local = path22.join(root, "node_modules", ".bin", name);
+    let local = path23.join(root, "node_modules", ".bin", name);
     if (pathExecutable(local))
       return { command: local, args: ["--stdio"], label: `${PROVIDER_NAME} (project)` };
   }
-  for (let dir of (process.env.PATH ?? "").split(path22.delimiter).filter(Boolean))
+  for (let dir of (process.env.PATH ?? "").split(path23.delimiter).filter(Boolean))
     for (let name of pathExecutableNames(PROVIDER_NAME)) {
-      let candidate = path22.join(dir, name);
+      let candidate = path23.join(dir, name);
       if (pathExecutable(candidate))
         return { command: candidate, args: ["--stdio"], label: PROVIDER_NAME };
     }
@@ -6904,14 +7171,14 @@ function resolveTypeScriptLanguageServer(root) {
 function collectTargetFiles(root, changedPaths, maxFiles) {
   let targets = [], skippedPaths = [];
   for (let changedPath of changedPaths) {
-    let relPath = normalizeRelPath2(changedPath), absPath = path22.resolve(root, relPath), languageId = languageIdForPath(absPath);
+    let relPath = normalizeRelPath2(changedPath), absPath = path23.resolve(root, relPath), languageId = languageIdForPath(absPath);
     if (!languageId || !isPathInsideRoot(absPath, root)) {
       skippedPaths.push(relPath);
       continue;
     }
     let stat;
     try {
-      stat = fs21.statSync(absPath);
+      stat = fs22.statSync(absPath);
     } catch (error) {
       if (error.code === "ENOENT") {
         skippedPaths.push(relPath);
@@ -7138,7 +7405,7 @@ function initializeParams(root) {
       },
       workspace: { configuration: !1, workspaceFolders: !0 }
     },
-    workspaceFolders: [{ uri: rootUri, name: path22.basename(root) || "workspace" }]
+    workspaceFolders: [{ uri: rootUri, name: path23.basename(root) || "workspace" }]
   };
 }
 async function waitForDiagnostics(client, targets, timeoutMs, signal) {
@@ -7161,7 +7428,7 @@ async function collectWithTypeScriptLanguageServer(input) {
   try {
     await client.request("initialize", initializeParams(input.root), remaining(), input.signal), client.notify("initialized", {});
     for (let target of input.targets) {
-      let text = fs21.readFileSync(target.absPath, "utf-8");
+      let text = fs22.readFileSync(target.absPath, "utf-8");
       client.notify("textDocument/didOpen", {
         textDocument: { uri: target.uri, languageId: target.languageId, version: 1, text }
       }), client.notify("textDocument/didSave", {
@@ -7195,7 +7462,7 @@ async function collectWithTypeScriptLanguageServer(input) {
 async function collectWatchdogLspDiagnostics(request) {
   if (!request.config.enabled)
     return { status: "disabled", checkedPaths: [], skippedPaths: [], diagnostics: [] };
-  let root = path22.resolve(request.root || request.cwd), { targets, skippedPaths } = collectTargetFiles(root, request.changedPaths, request.config.maxFiles);
+  let root = path23.resolve(request.root || request.cwd), { targets, skippedPaths } = collectTargetFiles(root, request.changedPaths, request.config.maxFiles);
   if (!targets.length)
     return {
       status: "skipped",
@@ -7904,7 +8171,7 @@ function buildWatchdogStatus(snapshot, ctx) {
     `Auto-follow: not implemented${snapshot.autoFollowQueued ? " (queued)" : ""}`,
     `Review model call: ${snapshot.reviewDescription}`
   ];
-  return snapshot.failedReviews > 0 && lines.push(`Failed reviews: ${snapshot.failedReviews}`), snapshot.staleReviews > 0 && lines.push(`Stale reviews: ${snapshot.staleReviews}`), snapshot.changedPaths?.length && lines.push(`Changed paths: ${snapshot.changedPaths.slice(0, 8).join(", ")}${snapshot.changedPaths.length > 8 ? `, +${snapshot.changedPaths.length - 8} more` : ""}`), snapshot.lastWarning && lines.push(`Last warning: ${snapshot.lastWarning.severity} \xB7 ${snapshot.lastWarning.state ?? "candidate"} \xB7 ${snapshot.lastWarning.summary}`), snapshot.lastError && lines.push(`Last error: ${snapshot.lastError}`), snapshot.configOk ? lines.push("", "Config: ok") : lines.push("", "Config errors:", ...snapshot.errors.map((error) => `- ${error.message}`), "Watchdog is disabled until the config is fixed."), lines.push("Sources:", ...snapshot.sources.map(sourceLine), "", "Model commands:", "- /subagents-watchdog recommend-model", "- /subagents-watchdog model recommended", "- /subagents-watchdog model <provider/model[:thinking]>", "- /subagents-watchdog model inherit", "- /subagents-watchdog session model recommended", 'Agent action: subagent({ action: "watchdog.configure", model: "recommended", scope: "session" })'), lines.join(`
+  return snapshot.failedReviews > 0 && lines.push(`Failed reviews: ${snapshot.failedReviews}`), snapshot.staleReviews > 0 && lines.push(`Stale reviews: ${snapshot.staleReviews}`), snapshot.changedPaths?.length && lines.push(`Changed paths: ${snapshot.changedPaths.slice(0, 8).join(", ")}${snapshot.changedPaths.length > 8 ? `, +${snapshot.changedPaths.length - 8} more` : ""}`), snapshot.lastWarning && lines.push(`Last warning: ${snapshot.lastWarning.severity} \xB7 ${snapshot.lastWarning.state ?? "candidate"} \xB7 ${snapshot.lastWarning.summary}`), snapshot.lastError && lines.push(`Last error: ${snapshot.lastError}`), snapshot.configOk ? lines.push("", "Config: ok") : lines.push("", "Config errors:", ...snapshot.errors.map((error) => `- ${error.message}`), "Watchdog is disabled until the config is fixed."), lines.push("Sources:", ...snapshot.sources.map(sourceLine), "", "Model commands:", "- /subagents-watchdog recommend-model", "- /subagents-watchdog model recommended", "- /subagents-watchdog model <provider/model[:thinking]>", "- /subagents-watchdog model inherit", "- /subagents-watchdog session model recommended", "Configure via /subagents-watchdog or /settings; agent watchdog.configure is not available."), lines.join(`
 `);
 }
 function parseTestCommand(input) {
@@ -8157,6 +8424,9 @@ function registerMainWatchdog(pi, options = {}) {
   }), runtime;
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/async-guidance.js
+var SUBAGENT_ASYNC_GUIDANCE = "Subagents run async by default. Set async:false when you need the result immediately and have no independent work to do, or need an interactive preview. Otherwise continue independent work or yield for normal interactive completion. Use subagent_wait for same-turn or skill completion. Headless sessions auto-drain current-session work. Use status for one-time inspection. Do not poll or sleep to wait.";
+
 export {
   childRowLabel,
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
@@ -8185,7 +8455,6 @@ export {
   SLASH_SUBAGENT_UPDATE_EVENT,
   SLASH_SUBAGENT_CANCEL_EVENT,
   POLL_INTERVAL_MS,
-  MAX_WIDGET_JOBS,
   SUBAGENT_ACTIONS,
   DEFAULT_FORK_PREAMBLE,
   resolveTopLevelParallelMaxTasks,
@@ -8222,7 +8491,6 @@ export {
   buildChainInstructions,
   resolveParallelBehaviors,
   createParallelDirs,
-  THINKING_LEVELS,
   toModelInfo,
   resolveEffectiveThinking,
   splitKnownThinkingSuffix,
@@ -8230,6 +8498,7 @@ export {
   getSupportedThinkingLevels,
   formatTokens,
   formatModelSelection,
+  formatCompactModelBadge,
   formatUsage,
   formatDuration,
   buildChainSummary,
@@ -8284,8 +8553,8 @@ export {
   splitThinkingSuffix,
   resolveModelCandidate,
   resolveEffectiveSubagentModel,
-  resolveRequiredTierModel,
   captureModelSelection,
+  resolveExecutableChildModel,
   buildModelCandidates,
   isRetryableModelFailure,
   formatModelAttemptNote,
@@ -8295,11 +8564,10 @@ export {
   normalizeParallelGroups,
   flatToLogicalStepIndex,
   formatActivityLabel,
-  aggregateStepStatus,
   formatAgentRunningLabel,
-  formatParallelOutcome,
   formatNestedAggregate,
   formatNestedRunStatusLines,
+  resolveSubagentRequestParams,
   DEFAULT_CONTROL_CONFIG,
   resolveControlConfig,
   deriveActivityState,
@@ -8310,7 +8578,6 @@ export {
   formatControlIntercomMessage,
   writeAtomicJson,
   writePrivateAtomicJson,
-  assertSafeNestedId,
   createNestedRoute,
   resolveInheritedNestedRouteFromEnv,
   resolveNestedParentAddressFromEnv,
@@ -8318,7 +8585,6 @@ export {
   sanitizeSummary,
   findNestedRouteForRootId,
   projectNestedRegistryForRoot,
-  findNestedRunMatchesById,
   writeNestedEvent,
   writeNestedControlRequest,
   readNestedControlResults,
@@ -8337,6 +8603,7 @@ export {
   resolveSubagentResultStatus,
   compactNestedResultChildren,
   attachNestedChildrenToResultChildren,
+  formatNestedResultLines,
   buildSubagentResultIntercomPayload,
   deliverSubagentResultIntercomEvent,
   deliverSubagentIntercomMessageEvent,
@@ -8344,6 +8611,7 @@ export {
   formatSubagentResultReceipt,
   expectsImplementationMutation,
   validateAcceptanceInput,
+  restorePersistedAcceptance,
   validateExecutionAcceptance,
   resolveEffectiveAcceptance,
   formatAcceptancePrompt,
@@ -8352,6 +8620,9 @@ export {
   evaluateAcceptance,
   buildSkippedAcceptanceLedger,
   acceptanceFailureMessage,
+  normalizeAsyncLaunchConfig,
+  subagentLaunchRunsAsync,
+  isAsyncSubagentExecution,
   inspectSubagentFleet,
   formatAsyncRunTranscript,
   formatNestedRunTranscript,
@@ -8364,28 +8635,28 @@ export {
   initialTurnBudgetState,
   turnBudgetState,
   shouldAbortForTurnBudget,
-  parseWatchdogThinkingInput,
   resolveWatchdogModelInput,
   recommendStrongWatchdogModel,
-  writeWatchdogModelSettings,
   resolveWatchdogConfig,
   buildWatchdogStatus,
   registerMainWatchdog,
+  requestAsyncSteer,
+  readSteerCapability,
+  consumeSteerAcks,
+  deliverInterruptRequest,
+  deliverStopRequest,
   INTERCOM_BRIDGE_MARKER,
   resolveIntercomSessionTarget,
   resolveSubagentIntercomTarget,
   diagnoseIntercomBridge,
   resolveIntercomBridge,
   applyIntercomBridgeToAgent,
-  requestAsyncSteer,
-  consumeSteerAcks,
-  deliverInterruptRequest,
-  deliverStopRequest,
   interruptLiveAsyncResumeTarget,
-  findAsyncRunPrefixMatches,
   resolveAsyncRunLocation,
   resolveAsyncResumeTarget,
   buildRevivedAsyncTask,
+  resolveSubagentRunId,
+  SUBAGENT_ASYNC_GUIDANCE,
   SUBAGENT_CONTROL_MESSAGE_TYPE,
   clearPendingForegroundControlNotices,
   handleSubagentControlNotice