@ashx-j/lunr 0.2.18 → 0.2.20

package/dist/node-runtime/{chunk-MCUNIRD5.js → chunk-46ECNOLF.js}

@@ -2,7 +2,7 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   PLAN_MODE_WRITE_SPAWN_ERROR,
   resolveChildPermissions
-} from "./chunk-XATUM2HK.js";
+} from "./chunk-25I2BHAA.js";
 import {
   createReadOnlyTools
 } from "./chunk-WKDK4C5P.js";
@@ -63,7 +63,7 @@ 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, MAX_WIDGET_JOBS = 4, 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;
@@ -420,7 +420,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 = [];
@@ -1968,9 +1983,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), 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);
@@ -1988,11 +2003,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) {
@@ -2120,14 +2131,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 ?? []];
@@ -2272,12 +2330,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())
@@ -2285,21 +2355,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),
@@ -3896,7 +3985,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";
 }
@@ -3946,18 +4035,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")
@@ -4017,6 +4113,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())
@@ -4038,9 +4157,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,
@@ -4663,132 +4784,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`;
@@ -4799,7 +4824,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 = {}) {
@@ -4821,7 +4846,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",
@@ -4832,10 +4857,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;
@@ -4843,8 +4875,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;
@@ -4854,14 +4893,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 {
@@ -4886,7 +4925,7 @@ function deliverInterruptRequest(input) {
       if (error?.code === "ENOSYS")
         return;
       try {
-        fs15.rmSync(requestPath, { force: !0 });
+        fs14.rmSync(requestPath, { force: !0 });
       } catch {
       }
       throw error;
@@ -4896,6 +4935,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";
@@ -4926,6 +5071,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.`);
@@ -5149,7 +5303,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.`);
@@ -5170,17 +5324,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");
@@ -5226,7 +5386,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(" ")}`);
   }
@@ -5279,6 +5439,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")
@@ -5304,6 +5465,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 } : {}
       };
     }
@@ -5336,6 +5498,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 } : {}
@@ -5357,6 +5520,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) {
@@ -5407,8 +5640,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);
 }
@@ -5416,9 +5649,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;
@@ -5430,7 +5663,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;
@@ -5442,7 +5675,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
@@ -5450,7 +5683,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 {
@@ -5496,8 +5729,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,
@@ -5567,7 +5800,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 [];
@@ -5577,13 +5810,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)}`);
       }
@@ -5611,7 +5844,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;
@@ -5645,8 +5878,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)));
@@ -5659,11 +5892,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);
@@ -5674,7 +5907,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) };
   }
@@ -5683,24 +5916,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) };
   }
@@ -5710,7 +5943,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) };
   }
@@ -5801,8 +6034,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}`);
@@ -5892,14 +6125,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");
@@ -5945,7 +6178,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))
@@ -6083,8 +6316,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 = [
@@ -6210,7 +6443,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))
@@ -6249,19 +6482,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)) {
@@ -6297,11 +6530,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 });
@@ -6319,13 +6552,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();
@@ -6333,16 +6566,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 };
@@ -6386,7 +6619,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) {
@@ -6404,7 +6637,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) {
@@ -6678,8 +6911,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 });
@@ -6687,28 +6920,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 };
@@ -6841,8 +7074,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"],
@@ -6855,14 +7088,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();
@@ -6873,7 +7106,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;
   }
@@ -6886,13 +7119,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 };
     }
@@ -6900,14 +7133,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);
@@ -7134,7 +7367,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) {
@@ -7157,7 +7390,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", {
@@ -7191,7 +7424,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",
@@ -7900,7 +8133,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) {
@@ -8218,7 +8451,6 @@ export {
   buildChainInstructions,
   resolveParallelBehaviors,
   createParallelDirs,
-  THINKING_LEVELS,
   toModelInfo,
   resolveEffectiveThinking,
   splitKnownThinkingSuffix,
@@ -8226,6 +8458,7 @@ export {
   getSupportedThinkingLevels,
   formatTokens,
   formatModelSelection,
+  formatCompactModelBadge,
   formatUsage,
   formatDuration,
   buildChainSummary,
@@ -8280,8 +8513,8 @@ export {
   splitThinkingSuffix,
   resolveModelCandidate,
   resolveEffectiveSubagentModel,
-  resolveRequiredTierModel,
   captureModelSelection,
+  resolveExecutableChildModel,
   buildModelCandidates,
   isRetryableModelFailure,
   formatModelAttemptNote,
@@ -8306,7 +8539,6 @@ export {
   formatControlIntercomMessage,
   writeAtomicJson,
   writePrivateAtomicJson,
-  assertSafeNestedId,
   createNestedRoute,
   resolveInheritedNestedRouteFromEnv,
   resolveNestedParentAddressFromEnv,
@@ -8314,7 +8546,6 @@ export {
   sanitizeSummary,
   findNestedRouteForRootId,
   projectNestedRegistryForRoot,
-  findNestedRunMatchesById,
   writeNestedEvent,
   writeNestedControlRequest,
   readNestedControlResults,
@@ -8340,6 +8571,7 @@ export {
   formatSubagentResultReceipt,
   expectsImplementationMutation,
   validateAcceptanceInput,
+  restorePersistedAcceptance,
   validateExecutionAcceptance,
   resolveEffectiveAcceptance,
   formatAcceptancePrompt,
@@ -8360,28 +8592,27 @@ 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_CONTROL_MESSAGE_TYPE,
   clearPendingForegroundControlNotices,
   handleSubagentControlNotice