@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{subagent-executor-5RNDEPIJ.js → subagent-executor-CXKXQDHH.js}

@@ -14,6 +14,7 @@ import {
   PI_CODING_AGENT_PACKAGE_ROOT_ENV,
   RESULTS_DIR,
   SUBAGENT_ACTIONS,
+  SUBAGENT_ASYNC_GUIDANCE,
   SUBAGENT_ASYNC_STARTED_EVENT,
   SUBAGENT_CONTROL_EVENT,
   SUBAGENT_CONTROL_INTERCOM_EVENT,
@@ -21,7 +22,6 @@ import {
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
   Semaphore,
   TEMP_ROOT_DIR,
-  THINKING_LEVELS,
   acceptChildWatchdogEvent,
   acceptanceFailureMessage,
   aggregateAcceptanceReport,
@@ -30,7 +30,6 @@ import {
   appendTurnBudgetSystemPrompt,
   applyIntercomBridgeToAgent,
   applyThinkingSuffix,
-  assertSafeNestedId,
   attachNestedChildrenToResultChildren,
   attachRootChildrenToSteps,
   buildChainInstructions,
@@ -69,11 +68,9 @@ import {
   expectsImplementationMutation,
   extractTextFromContent,
   extractToolArgsPreview,
-  findAsyncRunPrefixMatches,
   findLatestSessionFile,
   findModelInfo,
   findNestedRouteForRootId,
-  findNestedRunMatchesById,
   flatToLogicalStepIndex,
   formatAcceptancePrompt,
   formatActivityLabel,
@@ -116,7 +113,6 @@ import {
   normalizeChildSpec,
   normalizeParallelGroups,
   normalizeSkillInput,
-  parseWatchdogThinkingInput,
   projectNestedRegistryForRoot,
   readChildToolDiagnosticError,
   readNestedControlResults,
@@ -140,6 +136,7 @@ import {
   resolveEffectiveAcceptance,
   resolveEffectiveSubagentModel,
   resolveEffectiveThinking,
+  resolveExecutableChildModel,
   resolveInheritedNestedRouteFromEnv,
   resolveIntercomBridge,
   resolveIntercomSessionTarget,
@@ -148,22 +145,25 @@ import {
   resolveNestedAsyncDir,
   resolveNestedParentAddressFromEnv,
   resolveParallelBehaviors,
-  resolveRequiredTierModel,
   resolveSkillsWithFallback,
   resolveStepBehavior,
   resolveSubagentIntercomTarget,
+  resolveSubagentRequestParams,
   resolveSubagentResultStatus,
+  resolveSubagentRunId,
   resolveTopLevelParallelConcurrency,
   resolveTopLevelParallelMaxTasks,
   resolveTurnBudgetConfig,
   resolveWatchdogConfig,
   resolveWatchdogModelInput,
+  restorePersistedAcceptance,
   shouldAbortForTurnBudget,
   shouldNotifyControlEvent,
   splitKnownThinkingSuffix,
   splitThinkingSuffix,
   stripAcceptanceReport,
   stripDetailsOutputsForIntercomReceipt,
+  subagentLaunchRunsAsync,
   sumResultsCost,
   sumResultsUsage,
   suppressProgressForReadOnlyTask,
@@ -186,25 +186,26 @@ import {
   writeMetadata,
   writeNestedControlRequest,
   writeNestedEvent,
-  writePrivateAtomicJson,
-  writeWatchdogModelSettings
-} from "./chunk-CDFZEWPU.js";
+  writePrivateAtomicJson
+} from "./chunk-N3PNL74S.js";
 import {
   PLAN_MODE_WRITE_SPAWN_ERROR,
   resolveChildPermissions,
   snapshotParentPermissionMode
-} from "./chunk-EDBJNRSM.js";
-import "./chunk-ZKMFUD3Q.js";
-import "./chunk-AD6VXAO7.js";
-import "./chunk-LZAW4ZX3.js";
-import "./chunk-M3LZLQW2.js";
+} from "./chunk-ZVSORYRM.js";
+import "./chunk-GT5F3OKM.js";
 import "./chunk-53YJI7JU.js";
 import "./chunk-GZQHMEWL.js";
 import "./chunk-ZCHMJ34K.js";
 import {
   SessionManager
-} from "./chunk-PBC2Y6GS.js";
+} from "./chunk-6UB6NKA3.js";
 import "./chunk-FVDOXRUD.js";
+import "./chunk-MW2XJZIK.js";
+import "./chunk-D466UAID.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-VTPM5V35.js";
+import "./chunk-3ONQTOMR.js";
 import "./chunk-RQ2Q5IYR.js";
 import "./chunk-C4O2RSQQ.js";
 import "./chunk-MX3GJNXJ.js";
@@ -214,8 +215,8 @@ import "./chunk-BRJX2PRC.js";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/subagent-executor.js
 import { randomUUID as randomUUID4 } from "node:crypto";
-import * as fs16 from "node:fs";
-import * as path16 from "node:path";
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/chain-clarify.js
 import { matchesKey, visibleWidth, truncateToWidth } from "@ashx-j/lunr-tui";
@@ -1199,7 +1200,7 @@ function hasMutationToolCall(messages) {
   return !1;
 }
 function evaluateCompletionMutationGuard(input) {
-  let expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools) ? expectsImplementationMutation(input.agent, input.task) : !1, attemptedMutation = hasMutationToolCall(input.messages);
+  let expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools) ? expectsImplementationMutation(input.permissions, input.task) : !1, attemptedMutation = hasMutationToolCall(input.messages);
   return {
     expectedMutation,
     attemptedMutation,
@@ -1232,20 +1233,20 @@ function resolvePiPackageRoot() {
     return;
   }
 }
-function isRunnableNodeScript(filePath, existsSync12) {
-  return existsSync12(filePath) ? /\.(?:mjs|cjs|js)$/i.test(filePath) : !1;
+function isRunnableNodeScript(filePath, existsSync11) {
+  return existsSync11(filePath) ? /\.(?:mjs|cjs|js)$/i.test(filePath) : !1;
 }
 function normalizePath(filePath) {
   return path2.isAbsolute(filePath) ? filePath : path2.resolve(filePath);
 }
 function resolvePiCliScript(deps = {}) {
-  let existsSync12 = deps.existsSync ?? fs2.existsSync, realpathSync5 = deps.realpathSync ?? fs2.realpathSync, readFileSync8 = deps.readFileSync ?? ((filePath, encoding) => fs2.readFileSync(filePath, encoding)), argv1 = deps.argv1 ?? process.argv[1];
+  let existsSync11 = deps.existsSync ?? fs2.existsSync, realpathSync5 = deps.realpathSync ?? fs2.realpathSync, readFileSync8 = deps.readFileSync ?? ((filePath, encoding) => fs2.readFileSync(filePath, encoding)), argv1 = deps.argv1 ?? process.argv[1];
   if (argv1) {
     let argvPath = normalizePath(argv1);
-    if (isRunnableNodeScript(argvPath, existsSync12))
+    if (isRunnableNodeScript(argvPath, existsSync11))
       try {
         let canonicalArgvPath = realpathSync5(argvPath);
-        if (isRunnableNodeScript(canonicalArgvPath, existsSync12) && findPiPackageRootFromEntry(canonicalArgvPath))
+        if (isRunnableNodeScript(canonicalArgvPath, existsSync11) && findPiPackageRootFromEntry(canonicalArgvPath))
           return canonicalArgvPath;
       } catch {
       }
@@ -1263,7 +1264,7 @@ function resolvePiCliScript(deps = {}) {
     if (!binPath)
       return;
     let candidate = path2.resolve(path2.dirname(packageJsonPath), binPath);
-    if (isRunnableNodeScript(candidate, existsSync12))
+    if (isRunnableNodeScript(candidate, existsSync11))
       return candidate;
   } catch {
     return;
@@ -2136,7 +2137,7 @@ ${fullOutput}` : timeoutMessage;
 ${fullOutput}` : note;
   }
   if ((result2.exitCode === 0 && !result2.error ? evaluateCompletionMutationGuard({
-    agent: spec.effectivePermissions,
+    permissions: spec.effectivePermissions,
     task: shared.originalTask ?? task,
     messages: result2.messages,
     tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : void 0
@@ -3266,10 +3267,13 @@ function resolveChainToolBudget(input) {
   return { toolBudget: resolved.budget, error: resolved.error };
 }
 async function runParallelChainTasks(input) {
-  let concurrency = input.step.concurrency ?? MAX_CONCURRENCY, failFast = input.step.failFast ?? !1, aborted = !1, effectiveModels = input.step.parallel.map((task) => {
-    let taskChildConfig = input.agents.find((child) => child.name === task.agent);
-    return resolveRequiredTierModel(task.tier, input.availableModels, input.ctx.model?.provider);
-  });
+  let concurrency = input.step.concurrency ?? MAX_CONCURRENCY, failFast = input.step.failFast ?? !1, aborted = !1, effectiveModels = input.step.parallel.map((task) => resolveExecutableChildModel({
+    model: task.model,
+    tier: task.tier,
+    thinking: task.thinking,
+    availableModels: input.availableModels,
+    preferredProvider: input.ctx.model?.provider
+  }));
   for (let taskIndex = 0; taskIndex < input.step.parallel.length; taskIndex++) {
     let task = input.step.parallel[taskIndex];
     input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModels[taskIndex]);
@@ -3299,9 +3303,10 @@ async function runParallelChainTasks(input) {
       task: taskStr,
       description: task.description,
       permissions: task.permissions,
-      model: effectiveModel ?? task.model,
+      model: task.model,
       tier: task.tier,
-      modelSelection: captureModelSelection({ tier: task.tier }),
+      thinking: task.thinking,
+      modelSelection: captureModelSelection({ model: task.model, tier: task.tier }),
       skill: task.skill,
       cwd: taskCwd,
       output: task.output,
@@ -3806,7 +3811,13 @@ ${failureSummary}`;
       stepTask = stepTask.replace(/\{task\}/g, originalTask), stepTask = stepTask.replace(/\{previous\}/g, prev), stepTask = stepTask.replace(/\{chain_dir\}/g, chainDir);
       let cleanTask = stepTask;
       stepTask = prefix + stepTask + suffix;
-      let effectiveModel = resolveRequiredTierModel(seqStep.tier, availableModels, ctx.model?.provider), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0;
+      let effectiveModel = resolveExecutableChildModel({
+        model: seqStep.model,
+        tier: seqStep.tier,
+        thinking: seqStep.thinking,
+        availableModels,
+        preferredProvider: ctx.model?.provider
+      }), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0;
       stepTask = injectSingleOutputInstruction(stepTask, outputPath, agentConfig);
       let validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
       if (validationError)
@@ -3835,9 +3846,10 @@ ${failureSummary}`;
         task: stepTask,
         description: seqStep.description,
         permissions: seqStep.permissions,
-        model: effectiveModel ?? seqStep.model,
+        model: seqStep.model,
         tier: seqStep.tier,
-        modelSelection: captureModelSelection({ tier: seqStep.tier }),
+        thinking: seqStep.thinking,
+        modelSelection: captureModelSelection({ model: seqStep.model, tier: seqStep.tier }),
         skill: seqStep.skill,
         cwd: seqStep.cwd,
         output: seqStep.output,
@@ -3998,9 +4010,8 @@ function formatAsyncStartedMessage(headline) {
   return [
     headline,
     "",
-    "The async run is detached. Do not run sleep timers or polling loops just to wait for it.",
-    "If you have independent work, continue that work. When you have nothing left to do until the async result arrives, call subagent_wait() \u2014 it blocks until the run finishes and delivers the completion here. Only if you are certain you will get another turn (an interactive session where the user will prompt you again) can you instead stop and let Pi wake you; inside a skill that must run to completion, or in a non-interactive run, there is no next turn, so use subagent_wait().",
-    'Use subagent({ action: "status", id: "..." }) when you need a one-shot status/result or to inspect a blocked/stale run. To block until completion, prefer subagent_wait(). Do not poll in a loop just to wait.'
+    SUBAGENT_ASYNC_GUIDANCE,
+    'For one-time inspection or recovery of a blocked or stale run, use subagent({ action: "status", id: "..." }).'
   ].join(`
 `);
 }
@@ -4236,7 +4247,14 @@ ${injection}` : injection;
     taskTemplate = taskTemplate.replace(/\{task\}/g, originalTask ?? ""), taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
     let taskText = `${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`, task = namespaceOutputPath ? taskText : injectSingleOutputInstruction(taskText, outputPath, {
       tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : void 0
-    }), primaryModel = resolveRequiredTierModel(spec.tier, availableModels, ctx.currentModelProvider), thinkingOverride = flatIndex === void 0 ? void 0 : thinkingOverridesByFlatIndex?.[flatIndex], effectiveThinking = thinkingOverride, model = applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== void 0);
+    }), primaryModel = resolveExecutableChildModel({
+      modelSelection: spec.modelSelection,
+      model: spec.model,
+      tier: spec.tier,
+      thinking: spec.thinking,
+      availableModels,
+      preferredProvider: ctx.currentModelProvider
+    }), thinkingOverride = flatIndex === void 0 ? void 0 : thinkingOverridesByFlatIndex?.[flatIndex], effectiveThinking = thinkingOverride, model = applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== void 0);
     return {
       parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
       parentPermissionMode: snapshotParentPermissionMode(ctx.parentSessionId ?? ctx.currentSessionId),
@@ -4528,6 +4546,16 @@ function executeAsyncChain(id, params) {
     details: { mode: resultMode, runId: id, results: [], asyncId: id, asyncDir, workflowGraph, ...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs, deadlineAt } : {}, ...params.turnBudget ? { turnBudget: params.turnBudget } : {}, ...params.toolBudget ? { toolBudget: params.toolBudget } : {} }
   };
 }
+function resolveAsyncSingleAcceptance(input) {
+  return input.restoredAcceptance ? input.restoredAcceptance : resolveEffectiveAcceptance({
+    explicit: input.launchAcceptance,
+    agentName: input.agentName,
+    permissions: input.permissions,
+    task: input.task,
+    mode: "single",
+    async: !0
+  });
+}
 function executeAsyncSingle(id, params) {
   let { spec, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFile, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute } = params, agent = spec.description, task = spec.task, runnerCwd = resolveChildCwd(ctx.cwd, cwd), skillNames = params.skills ?? (spec.skill === !1 ? [] : normalizeSkillInput(spec.skill) ?? []), availableModels = params.availableModels, { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd, void 0, runnerCwd);
   if (missingSkills.includes("pi-subagents"))
@@ -4555,19 +4583,25 @@ ${injection}` : injection;
   let outputMode = params.outputMode ?? spec.outputMode ?? "inline", validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
   if (validationError)
     return formatAsyncStartError("single", validationError);
-  let taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, childToolShape), primaryModel = resolveRequiredTierModel(spec.tier, availableModels, ctx.currentModelProvider), effectiveThinking = params.thinkingOverride, model = applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== void 0), toolBudgetInput = params.toolBudget ?? spec.toolBudget ?? params.configToolBudget, resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget || spec.toolBudget ? "toolBudget" : "config.toolBudget");
+  let taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, childToolShape), primaryModel = resolveExecutableChildModel({
+    modelSelection: spec.modelSelection,
+    model: spec.model,
+    tier: spec.tier,
+    thinking: spec.thinking,
+    availableModels,
+    preferredProvider: ctx.currentModelProvider
+  }), effectiveThinking = params.thinkingOverride, model = applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== void 0), toolBudgetInput = params.toolBudget ?? spec.toolBudget ?? params.configToolBudget, resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget || spec.toolBudget ? "toolBudget" : "config.toolBudget");
   if (resolvedToolBudget.error)
     return formatAsyncStartError("single", resolvedToolBudget.error);
   let deadlineAt = params.absoluteDeadlineAt ?? (params.timeoutMs !== void 0 ? Date.now() + params.timeoutMs : void 0), timeoutMs = params.absoluteDeadlineAt !== void 0 && deadlineAt !== void 0 ? deadlineAt - Date.now() : params.timeoutMs;
   if (timeoutMs !== void 0 && timeoutMs <= 0)
     return formatAsyncStartError("single", "The source run's absolute deadline expired before recovery could launch.");
-  let initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : void 0, resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path7.join(sessionRoot, `async-${id}`) : void 0), resolvedAcceptance = resolveEffectiveAcceptance({
-    explicit: params.acceptance ?? spec.acceptance,
+  let initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : void 0, resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path7.join(sessionRoot, `async-${id}`) : void 0), resolvedAcceptance = resolveAsyncSingleAcceptance({
+    restoredAcceptance: params.restoredAcceptance,
+    launchAcceptance: params.acceptance ?? spec.acceptance,
     agentName: agent,
     permissions: spec.effectivePermissions,
-    task,
-    mode: "single",
-    async: !0
+    task
   }), recoveryDescriptor = {
     version: 4,
     lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
@@ -4579,8 +4613,8 @@ ${injection}` : injection;
     ...sessionFile ? { sessionFile } : {},
     cwd: runnerCwd,
     ...model ? { model } : {},
-    tier: spec.tier,
-    ...effectiveThinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {},
+    ...spec.tier ? { tier: spec.tier } : {},
+    ...effectiveThinking || spec.thinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking ?? spec.thinking) } : {},
     ...spec.modelSelection ? { modelSelection: spec.modelSelection } : {},
     ...resolvedSkills.length ? { skills: resolvedSkills.map((skill) => skill.name) } : {},
     ...outputPath ? { outputPath } : {},
@@ -4615,6 +4649,7 @@ ${injection}` : injection;
           permissions: spec.effectivePermissions,
           agent,
           task: taskWithOutputInstruction,
+          completionTask: params.completionTask ?? task,
           cwd: runnerCwd,
           model,
           thinking: resolveEffectiveThinking(model, effectiveThinking),
@@ -4859,62 +4894,13 @@ function result(text, isError = !1) {
 function messageFromError(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function parseScope(raw) {
-  if (raw === void 0 || raw === "session")
-    return "session";
-  if (raw === "user" || raw === "project")
-    return raw;
-  throw new Error("watchdog.configure scope must be 'session', 'user', or 'project'.");
-}
-function parseTarget(params) {
-  let target = params.target ?? "main";
-  if (target === "main")
-    return { kind: "main" };
-  if (target === "children")
-    return { kind: "children" };
-  if (target === "child") {
-    if (!params.agent?.trim())
-      throw new Error("watchdog.configure target='child' requires agent.");
-    return { kind: "child", agent: params.agent.trim() };
-  }
-  throw new Error("watchdog.configure target must be 'main', 'children', or 'child'.");
-}
-function parseThinking(raw) {
-  if (raw !== void 0)
-    return raw === "inherit" ? null : parseWatchdogThinkingInput(raw, "watchdog.configure thinking") ?? void 0;
-}
-function resolveConfiguredValue(ctx, params) {
-  let thinking = parseThinking(params.thinking), rawModel = params.model?.trim();
-  if (!rawModel) {
-    if (thinking === void 0)
-      throw new Error("watchdog.configure requires model, thinking, or both.");
-    return { thinking, description: `thinking ${thinking === null ? "inherit" : thinking === !1 ? "off" : thinking}` };
-  }
-  if (rawModel === "inherit")
-    return { model: null, thinking: thinking ?? null, description: "inherit" };
-  if (rawModel === "recommended") {
-    let recommendation = recommendStrongWatchdogModel(ctx);
-    return {
-      model: recommendation.model,
-      thinking: recommendation.thinking,
-      description: `${recommendation.model}:${recommendation.thinking}`
-    };
-  }
-  let resolved = resolveWatchdogModelInput(ctx, rawModel);
-  return {
-    model: resolved.model,
-    thinking: resolved.thinking ?? thinking,
-    description: `${resolved.model}${resolved.thinking ?? thinking ? `:${resolved.thinking ?? thinking}` : ""}`
-  };
-}
 function buildRecommendationText(ctx) {
   let recommendation = recommendStrongWatchdogModel(ctx);
   return [
     "Subagent watchdog recommended model",
     `Recommended: ${recommendation.model}:${recommendation.thinking}`,
     `Reason: ${recommendation.reason}`,
-    'Apply temporarily with subagent({ action: "watchdog.configure", scope: "session", model: "recommended" }).',
-    'Persist with scope: "project" or scope: "user" only when the user asks for that scope.'
+    "Watchdog settings are user-managed through /subagents-watchdog."
   ].join(`
 `);
 }
@@ -4941,44 +4927,14 @@ function buildCheckText(runtime, ctx) {
   return lines.join(`
 `);
 }
-function handleWatchdogToolAction(action, params, ctx, runtime) {
+function handleWatchdogToolAction(action, _params, ctx, runtime) {
   try {
-    if (action === "watchdog.status")
-      return runtime ? result(buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx)) : result("Subagent watchdog runtime is unavailable.", !0);
-    if (action === "watchdog.recommend-model")
-      return result(buildRecommendationText(ctx));
-    if (action === "watchdog.check")
-      return result(buildCheckText(runtime, ctx));
-    if (action !== "watchdog.configure")
-      return result(`Unknown watchdog action: ${action}`, !0);
-    let scope = parseScope(params.scope), target = parseTarget(params), value = resolveConfiguredValue(ctx, params);
-    if (scope === "session")
-      return runtime ? target.kind !== "main" ? result("Session-scoped watchdog.configure currently supports target='main' only.", !0) : (runtime.setSessionModel({ model: value.model, thinking: value.thinking }, ctx.cwd), result([
-        `Subagent watchdog session model configured: ${value.description}.`,
-        "No settings files were changed.",
-        "",
-        buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx)
-      ].join(`
-`))) : result("Subagent watchdog runtime is unavailable.", !0);
-    let settingsPath = writeWatchdogModelSettings({
-      scope,
-      cwd: ctx.cwd,
-      target,
-      model: value.model,
-      thinking: value.thinking
-    });
-    runtime?.refreshConfig(ctx.cwd);
-    let targetLabel = target.kind === "child" ? `child ${target.agent}` : target.kind;
-    return result([
-      `Subagent watchdog ${targetLabel} model configured: ${value.description}.`,
-      `Updated: ${settingsPath}`
-    ].join(`
-`));
+    return action === "watchdog.status" ? runtime ? result(buildWatchdogStatus(runtime.getSnapshot(ctx.cwd), ctx)) : result("Subagent watchdog runtime is unavailable.", !0) : action === "watchdog.recommend-model" ? result(buildRecommendationText(ctx)) : action === "watchdog.check" ? result(buildCheckText(runtime, ctx)) : result(`Unknown watchdog action: ${action}`, !0);
   } catch (error) {
     return result(`Subagent watchdog action failed: ${messageFromError(error)}`, !0);
   }
 }
-var WATCHDOG_TOOL_ACTIONS = ["watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model"], WATCHDOG_THINKING_VALUES = ["inherit", ...THINKING_LEVELS];
+var WATCHDOG_TOOL_ACTIONS = ["watchdog.status", "watchdog.check", "watchdog.recommend-model"];
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/chain-append.js
 import { randomUUID } from "node:crypto";
@@ -5460,81 +5416,11 @@ function resolveAsyncRootResultPath(resultsDir, runId) {
   return path13.join(resultsDir, `${runId}.json`);
 }
 
-// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/run-id-resolver.js
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/run-status.js
 import * as fs14 from "node:fs";
 import * as path14 from "node:path";
-function exactAsyncLocation(id, asyncDirRoot, resultsDir) {
-  let asyncDir = path14.join(asyncDirRoot, id), resultPath = path14.join(resultsDir, `${id}.json`);
-  if (!(!fs14.existsSync(asyncDir) && !fs14.existsSync(resultPath)))
-    return {
-      asyncDir: fs14.existsSync(asyncDir) ? asyncDir : null,
-      resultPath: fs14.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/runs/background/run-status.js
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
 function hasExistingSessionFile(value) {
-  return typeof value == "string" && fs15.existsSync(value);
+  return typeof value == "string" && fs14.existsSync(value);
 }
 function formatResumeGuidance(runId, children, fallbackSessionFile, options = {}) {
   if (options.stopped)
@@ -5570,9 +5456,9 @@ function formatSteeringSummary(input) {
 }
 function rememberedForegroundChildOutput(child) {
   let outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
-  if (outputPath && fs15.existsSync(outputPath))
+  if (outputPath && fs14.existsSync(outputPath))
     try {
-      let artifactOutput = fs15.readFileSync(outputPath, "utf-8").trim();
+      let artifactOutput = fs14.readFileSync(outputPath, "utf-8").trim();
       if (artifactOutput)
         return artifactOutput;
     } catch {
@@ -5745,7 +5631,7 @@ function inspectSubagentStatus(params, deps = {}) {
         details: { mode: "single", results: [] }
       };
     }
-    let status = reconciliation.status, effectiveRunId = status?.runId ?? resolvedId ?? "unknown", logPath = path15.join(asyncDir, `subagent-log-${effectiveRunId}.md`), eventsPath = path15.join(asyncDir, "events.jsonl");
+    let status = reconciliation.status, effectiveRunId = status?.runId ?? resolvedId ?? "unknown", logPath = path14.join(asyncDir, `subagent-log-${effectiveRunId}.md`), eventsPath = path14.join(asyncDir, "events.jsonl");
     if (status) {
       if (params.view === "transcript") {
         if (currentSessionId && status.sessionId !== currentSessionId)
@@ -5789,22 +5675,22 @@ function inspectSubagentStatus(params, deps = {}) {
         `Dir: ${asyncDir}`,
         outputPath ? `Output: ${outputPath}` : void 0,
         reconciliation.message ? `Diagnosis: ${reconciliation.message}` : void 0,
-        reconciliation.resultPath && fs15.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
+        reconciliation.resultPath && fs14.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : void 0
       ].filter((line) => !!line);
       for (let [index, step] of (status.steps ?? []).entries()) {
         let stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : void 0, modelThinking = formatModelSelection(step.modelSelection, step.model, step.thinking), modelText = modelThinking ? ` (${modelThinking})` : "", steeringText2 = formatSteeringSummary(step), steeringSuffix = steeringText2 ? `, steering: ${steeringText2}` : "", errorText2 = step.error ? `, error: ${step.error}` : "", acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "", budgetText = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "", display = step.label ? `${step.label} (${step.agent})` : step.agent, phase = step.phase ? `[${step.phase}] ` : "";
         lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText2}`), lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: !0, maxLines: 20 }));
-        let stepOutputPath = path15.join(asyncDir, `output-${index}.log`);
-        stepOutputPath !== outputPath && fs15.existsSync(stepOutputPath) && lines.push(`  Output: ${stepOutputPath}`), step.status === "running" && (lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.childId ?? step.agent, index)} (if registered)`), lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`));
+        let stepOutputPath = path14.join(asyncDir, `output-${index}.log`);
+        stepOutputPath !== outputPath && fs14.existsSync(stepOutputPath) && lines.push(`  Output: ${stepOutputPath}`), step.status === "running" && (lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.childId ?? step.agent, index)} (if registered)`), lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`));
       }
       let attached = new Set((status.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? [])), unattached = nestedChildren.filter((child) => !attached.has(child.id));
-      return lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: !0, maxLines: 20 })), nestedWarning && lines.push(`Warning: ${nestedWarning}`), status.sessionFile && lines.push(`Session: ${status.sessionFile}`), status.state === "running" && lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`), status.state !== "running" && lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === !0 })), fs15.existsSync(logPath) && lines.push(`Log: ${logPath}`), fs15.existsSync(eventsPath) && lines.push(`Events: ${eventsPath}`), { content: [{ type: "text", text: lines.join(`
+      return lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: !0, maxLines: 20 })), nestedWarning && lines.push(`Warning: ${nestedWarning}`), status.sessionFile && lines.push(`Session: ${status.sessionFile}`), status.state === "running" && lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`), status.state !== "running" && lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === !0 })), fs14.existsSync(logPath) && lines.push(`Log: ${logPath}`), fs14.existsSync(eventsPath) && lines.push(`Events: ${eventsPath}`), { content: [{ type: "text", text: lines.join(`
 `) }], details: { mode: "single", results: [] } };
     }
   }
   if (resultPath)
     try {
-      let raw = fs15.readFileSync(resultPath, "utf-8"), data = JSON.parse(raw);
+      let raw = fs14.readFileSync(resultPath, "utf-8"), data = JSON.parse(raw);
       if (params.view === "transcript")
         try {
           return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
@@ -5828,15 +5714,10 @@ function inspectSubagentStatus(params, deps = {}) {
   };
 }
 
-// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/top-level-async.js
-function applyForceTopLevelAsyncOverride(params, depth, forceTopLevelAsync) {
-  return params.foregroundOnly || !(depth === 0 && forceTopLevelAsync) ? params : { ...params, async: !0, clarify: !1 };
-}
-
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/foreground/subagent-executor.js
-var MUTATING_MANAGEMENT_ACTIONS = /* @__PURE__ */ new Set(["create", "update", "delete", "eject", "disable", "enable", "reset", "watchdog.configure"]);
+var MUTATING_MANAGEMENT_ACTIONS = /* @__PURE__ */ new Set(["create", "update", "delete", "eject", "disable", "enable", "reset"]);
 function resolveRequestedCwd(runtimeCwd, requestedCwd) {
-  return requestedCwd ? path16.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+  return requestedCwd ? path15.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
 function getForegroundControl(state, runId) {
   if (runId)
@@ -5868,7 +5749,7 @@ function nestedResolutionScopeForExecutor(deps) {
   };
 }
 function trustedSessionRootsForStatus(ctx, deps) {
-  let roots = deps.config.defaultSessionDir ? [path16.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [], parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
+  let roots = deps.config.defaultSessionDir ? [path15.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [], parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
   return parentSessionFile && roots.push(deps.getSubagentSessionRoot(parentSessionFile)), [...new Set(roots)];
 }
 function reserveSubagentSpawns(input) {
@@ -6015,10 +5896,10 @@ function resolveForegroundResumeTarget(params, state) {
   let child = run.children[index];
   if (!child.sessionFile)
     throw new Error(`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`);
-  if (path16.extname(child.sessionFile) !== ".jsonl")
+  if (path15.extname(child.sessionFile) !== ".jsonl")
     throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
-  let sessionFile = path16.resolve(child.sessionFile);
-  if (!fs16.existsSync(sessionFile))
+  let sessionFile = path15.resolve(child.sessionFile);
+  if (!fs15.existsSync(sessionFile))
     throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
   return { runId: run.runId, mode: run.mode, state: "complete", agent: child.agent, index, intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index), cwd: run.cwd, sessionFile };
 }
@@ -6073,7 +5954,7 @@ function resolveResumeTarget(params, state, options = {}) {
 function getAsyncInterruptTarget(state, runId, location, options = {}) {
   if (location?.asyncDir)
     return {
-      asyncId: location.resolvedId ?? runId ?? path16.basename(location.asyncDir),
+      asyncId: location.resolvedId ?? runId ?? path15.basename(location.asyncDir),
       asyncDir: location.asyncDir
     };
   if (runId) {
@@ -6338,27 +6219,27 @@ function nestedRunAgent(run) {
   return run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : void 0);
 }
 function pathWithin(base, candidate) {
-  let resolvedBase = path16.resolve(base), resolvedCandidate = path16.resolve(candidate);
-  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path16.sep}`);
+  let resolvedBase = path15.resolve(base), resolvedCandidate = path15.resolve(candidate);
+  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path15.sep}`);
 }
 function validateNestedSessionFile(run, trustedSessionRoots) {
   let sessionFile = nestedRunSessionFile(run);
   if (!sessionFile)
     throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
-  if (path16.extname(sessionFile) !== ".jsonl")
+  if (path15.extname(sessionFile) !== ".jsonl")
     throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
-  let resolved = path16.resolve(sessionFile);
-  if (!path16.isAbsolute(sessionFile))
+  let resolved = path15.resolve(sessionFile);
+  if (!path15.isAbsolute(sessionFile))
     throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
-  if (!fs16.existsSync(resolved))
+  if (!fs15.existsSync(resolved))
     throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
-  let stat = fs16.lstatSync(resolved);
+  let stat = fs15.lstatSync(resolved);
   if (!stat.isFile() || stat.isSymbolicLink())
     throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
-  let realSessionFile = fs16.realpathSync(resolved);
-  if (!trustedSessionRoots.filter((root) => fs16.existsSync(root)).map((root) => fs16.realpathSync(root)).some((root) => pathWithin(root, realSessionFile)))
+  let realSessionFile = fs15.realpathSync(resolved);
+  if (!trustedSessionRoots.filter((root) => fs15.existsSync(root)).map((root) => fs15.realpathSync(root)).some((root) => pathWithin(root, realSessionFile)))
     throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
-  if (!realSessionFile.split(path16.sep).includes(run.id))
+  if (!realSessionFile.split(path15.sep).includes(run.id))
     throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
   return realSessionFile;
 }
@@ -6378,7 +6259,7 @@ function resolveNestedResumeTarget(match, trustedSessionRoots) {
     agent,
     index: 0,
     intercomTarget: resolveSubagentIntercomTarget(run.id, agent, 0),
-    cwd: asyncDir ? path16.dirname(asyncDir) : void 0,
+    cwd: asyncDir ? path15.dirname(asyncDir) : void 0,
     sessionFile: validateNestedSessionFile(run, trustedSessionRoots)
   };
 }
@@ -6405,7 +6286,7 @@ function directNestedAsyncInterrupt(target) {
   let run = target.match.run, asyncDir = resolveNestedAsyncDir(target.match.rootRunId, run);
   if (!asyncDir)
     return;
-  let status = reconcileAsyncRun(asyncDir, { resultsDir: path16.join(RESULTS_DIR, "nested", target.match.rootRunId) }).status, pid = typeof status?.pid == "number" && status.pid > 0 ? status.pid : run.pid;
+  let status = reconcileAsyncRun(asyncDir, { resultsDir: path15.join(RESULTS_DIR, "nested", target.match.rootRunId) }).status, pid = typeof status?.pid == "number" && status.pid > 0 ? status.pid : run.pid;
   if (!(!status || status.state !== "running" || typeof pid != "number" || pid <= 0))
     try {
       return deliverInterruptRequest({ asyncDir, pid, source: "nested-interrupt" }), { content: [{ type: "text", text: `Interrupt requested for nested async run ${run.id}.` }], details: { mode: "management", results: [] } };
@@ -6418,7 +6299,7 @@ async function directNestedAsyncSteer(input) {
   let run = input.target.match.run, asyncDir = resolveNestedAsyncDir(input.target.match.rootRunId, run);
   if (!asyncDir)
     return;
-  let status = reconcileAsyncRun(asyncDir, { resultsDir: path16.join(RESULTS_DIR, "nested", input.target.match.rootRunId) }).status;
+  let status = reconcileAsyncRun(asyncDir, { resultsDir: path15.join(RESULTS_DIR, "nested", input.target.match.rootRunId) }).status;
   if (!status || status.state !== "running" && status.state !== "queued")
     return;
   let steps = status.steps ?? [];
@@ -6512,7 +6393,7 @@ async function resumeAsyncRun(input) {
       if (resolved.match.run.state === "running" || resolved.match.run.state === "queued")
         return resumeLiveNestedRun({ target: resolved, message: followUp });
       let trustedSessionRoots = [
-        ...input.deps.config.defaultSessionDir ? [path16.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : [],
+        ...input.deps.config.defaultSessionDir ? [path15.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : [],
         ...parentSessionFile ? [input.deps.getSubagentSessionRoot(parentSessionFile)] : []
       ];
       target = resolveNestedResumeTarget(resolved, trustedSessionRoots);
@@ -6577,7 +6458,7 @@ ${followUp}`, 500, { source: "async-resume", runId: target.runId, agent: target.
       goal,
       attachRoot: {
         runId: target.runId,
-        asyncDir: target.asyncDir ?? path16.join(ASYNC_DIR, target.runId),
+        asyncDir: target.asyncDir ?? path15.join(ASYNC_DIR, target.runId),
         resultPath: resolveAsyncRootResultPath(RESULTS_DIR, target.runId),
         index: target.index,
         agent: target.agent,
@@ -6623,32 +6504,43 @@ ${followUp}`, 500, { source: "async-resume", runId: target.runId, agent: target.
     return { content: [{ type: "text", text: formatAsyncStartedMessage(lines2.join(`
 `)) }], details: result3.details };
   }
-  let runId = randomUUID4().slice(0, 8), artifactConfig = recoveryDescriptor?.artifactConfig ?? { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== !1 }, artifactsDir = recoveryDescriptor?.artifactsDir ?? getArtifactsDir(parentSessionFile, effectiveCwd), availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo), recoverySpec;
+  let runId = randomUUID4().slice(0, 8), artifactConfig = recoveryDescriptor?.artifactConfig ?? { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== !1 }, artifactsDir = recoveryDescriptor?.artifactsDir ?? getArtifactsDir(parentSessionFile, effectiveCwd), availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo), restoredAcceptance;
+  if (recoveryDescriptor?.acceptance !== void 0 && input.params.acceptance === void 0)
+    try {
+      restoredAcceptance = restorePersistedAcceptance(recoveryDescriptor.acceptance, "recoveryDescriptor.acceptance");
+    } catch (error) {
+      return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
+    }
+  let recoverySpec;
   try {
+    let recoverySelection = recoveryDescriptor?.modelSelection ?? target.modelSelection, recoveryIsExplicitModel = recoverySelection?.kind === "model";
     recoverySpec = normalizeChildSpec({
       task: buildRevivedAsyncTask(target, followUp),
       description: recoveryDescriptor?.description ?? target.description ?? target.agent,
       permissions: recoveryDescriptor?.permissions ?? target.permissions ?? "read-only",
-      model: recoveryDescriptor?.model ?? target.model,
-      tier: input.params.tier ?? recoveryDescriptor?.tier ?? recoveryDescriptor?.modelSelection?.tier,
-      modelSelection: recoveryDescriptor?.modelSelection,
+      model: recoveryIsExplicitModel ? recoverySelection.model ?? recoveryDescriptor?.model ?? target.model : void 0,
+      tier: recoveryIsExplicitModel ? void 0 : input.params.tier ?? recoverySelection?.tier ?? recoveryDescriptor?.tier,
+      thinking: recoveryIsExplicitModel ? recoveryDescriptor?.thinking ?? target.thinking : void 0,
+      modelSelection: recoverySelection,
       skill: recoveryDescriptor?.skills,
       cwd: effectiveCwd,
       output: recoveryDescriptor?.outputPath,
       outputMode: recoveryDescriptor?.outputMode,
-      acceptance: input.params.acceptance ?? recoveryDescriptor?.acceptance,
+      acceptance: input.params.acceptance,
       toolBudget: recoveryDescriptor?.initialToolBudget
     }, {
       parentMode: snapshotParentPermissionMode(input.deps.state.currentSessionId),
       runId,
       index: 0,
-      childId: recoveryDescriptor?.childId ?? target.childId ?? `${runId}-0`
+      childId: recoveryDescriptor?.childId ?? target.childId ?? `${runId}-0`,
+      resolvedModelIsRuntime: !recoveryIsExplicitModel && !!(recoveryDescriptor?.model ?? target.model)
     });
   } catch (error) {
     return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
   }
   let result2 = executeAsyncSingle(runId, {
     spec: recoverySpec,
+    completionTask: followUp,
     goal: followUp,
     ctx: {
       pi: input.deps.pi,
@@ -6688,7 +6580,7 @@ ${followUp}`, 500, { source: "async-resume", runId: target.runId, agent: target.
     output: recoveryDescriptor?.outputPath,
     outputMode: recoveryDescriptor?.outputMode,
     ...recoveryDescriptor?.skills ? { skills: [...recoveryDescriptor.skills] } : {},
-    ...recoveryDescriptor?.acceptance !== void 0 && input.params.acceptance === void 0 ? { acceptance: recoveryDescriptor.acceptance } : {},
+    ...restoredAcceptance ? { restoredAcceptance } : {},
     ...input.params.timeoutMs !== void 0 ? { timeoutMs: input.params.timeoutMs } : {},
     ...input.absoluteDeadlineAt !== void 0 ? { absoluteDeadlineAt: input.absoluteDeadlineAt } : {},
     ...input.params.turnBudget !== void 0 ? { turnBudget: input.params.turnBudget } : {},
@@ -6956,6 +6848,7 @@ function internalizePromptDrivenChildren(params, options) {
     cwd: params.cwd,
     model: params.model,
     tier: params.tier,
+    thinking: params.thinking,
     skill: params.skill,
     output: params.output,
     outputMode: params.outputMode,
@@ -7300,13 +7193,21 @@ function runAsyncPath(data, deps) {
         isError: !0,
         details: { mode: "single", results: [] }
       };
-    let rawOutput = params.output !== void 0 ? params.output : a.output, effectiveOutput = normalizeSingleOutputOverride(rawOutput, a.output), effectiveOutputMode = params.outputMode ?? "inline", normalizedSkills = normalizeSkillInput(params.skill), skills = normalizedSkills === !1 ? [] : normalizedSkills, maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth), modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider), spec = normalizeChildSpec({
+    let rawOutput = params.output !== void 0 ? params.output : a.output, effectiveOutput = normalizeSingleOutputOverride(rawOutput, a.output), effectiveOutputMode = params.outputMode ?? "inline", normalizedSkills = normalizeSkillInput(params.skill), skills = normalizedSkills === !1 ? [] : normalizedSkills, maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth), modelSelection = captureModelSelection({ model: params.model, tier: params.tier }), modelOverride = resolveExecutableChildModel({
+      modelSelection,
+      model: params.model,
+      tier: params.tier,
+      thinking: params.thinking,
+      availableModels,
+      preferredProvider: currentProvider
+    }), spec = normalizeChildSpec({
       task: shouldForkAgent(contextPolicy, params.agent) ? wrapForkTask(params.task ?? "") : params.task ?? "",
       description: params.description,
       permissions: params.permissions,
-      model: modelOverride,
+      model: params.model,
       tier: params.tier,
-      modelSelection: captureModelSelection({ tier: params.tier }),
+      thinking: params.thinking,
+      modelSelection,
       skill: params.skill,
       cwd: effectiveCwd,
       output: effectiveOutput,
@@ -7492,7 +7393,7 @@ function buildParallelWorktreeTaskCwdError(tasks, sharedCwd) {
     return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
 }
 function resolveSingleRunOutputBaseDir(deps, artifactsDir, runId) {
-  return deps.config.singleRunOutputBaseDir ? path16.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : path16.join(artifactsDir, "outputs", runId);
+  return deps.config.singleRunOutputBaseDir ? path15.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir)) : path15.join(artifactsDir, "outputs", runId);
 }
 function buildChainWorktreeTaskCwdError(chain, sharedCwd) {
   for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
@@ -7512,7 +7413,7 @@ function resolveParallelTaskCwd(task, paramsCwd, worktreeSetup, index) {
 function buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks) {
   if (!worktreeSetup)
     return "";
-  let diffsDir = path16.join(artifactsDir, "worktree-diffs"), diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
+  let diffsDir = path15.join(artifactsDir, "worktree-diffs"), diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
   return formatWorktreeDiffSummary(diffs);
 }
 function findDuplicateParallelOutputPath(input) {
@@ -7535,13 +7436,16 @@ async function runForegroundParallelTasks(input) {
     input.sessionFileForTask(input.tasks[i].agent, i, input.modelOverrides[i]);
   return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
     let behavior = input.behaviors[index], effectiveSkills = behavior?.skills, taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index), readInstructions = behavior ? buildChainInstructions({ ...behavior, output: !1, progress: !1 }, taskCwd, !1) : { prefix: "", suffix: "" }, progressInstructions = behavior ? buildChainInstructions({ ...behavior, output: !1, reads: !1 }, input.progressDir, index === input.firstProgressIndex) : { prefix: "", suffix: "" }, outputPath = resolveSingleOutputPath(behavior?.output, input.ctx.cwd, taskCwd, input.outputBaseDir), agentConfig = input.agents.find((agent) => agent.name === task.agent), taskText = injectSingleOutputInstruction(`${readInstructions.prefix}${input.taskTexts[index]}${progressInstructions.suffix}`, outputPath, agentConfig), interruptController = new AbortController();
-    return input.foregroundControl && (input.foregroundControl.currentAgent = task.description || task.agent, input.foregroundControl.currentChildId = task.agent, input.foregroundControl.currentIndex = index, input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), input.foregroundControl.interrupt = () => interruptController.signal.aborted ? !1 : (interruptController.abort(), input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), !0)), runSync(input.ctx.cwd, normalizeChildSpec({
+    input.foregroundControl && (input.foregroundControl.currentAgent = task.description || task.agent, input.foregroundControl.currentChildId = task.agent, input.foregroundControl.currentIndex = index, input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), input.foregroundControl.interrupt = () => interruptController.signal.aborted ? !1 : (interruptController.abort(), input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), !0));
+    let modelSelection = input.modelSelections[index] ?? captureModelSelection({ model: task.model, tier: task.tier });
+    return runSync(input.ctx.cwd, normalizeChildSpec({
       task: taskText,
       description: task.description,
       permissions: task.permissions,
-      model: input.modelOverrides[index] ?? task.model,
+      model: task.model,
       tier: task.tier,
-      modelSelection: input.modelSelections[index] ?? captureModelSelection({ tier: task.tier }),
+      thinking: task.thinking,
+      modelSelection,
       skill: task.skill,
       cwd: taskCwd,
       output: task.output,
@@ -7646,7 +7550,14 @@ async function runParallelPath(data, deps) {
     ...task.reads !== void 0 && task.reads !== !0 ? { reads: task.reads } : {},
     ...task.progress !== void 0 ? { progress: task.progress } : {},
     ...skillOverrides[index] !== void 0 ? { skills: skillOverrides[index] } : {}
-  })), modelOverrides = tasks.map((task, i) => resolveRequiredTierModel(task.tier, availableModels, currentProvider)), modelSelections = tasks.map((task) => captureModelSelection({ tier: task.tier }));
+  })), modelSelections = tasks.map((task) => captureModelSelection({ model: task.model, tier: task.tier })), modelOverrides = tasks.map((task, index) => resolveExecutableChildModel({
+    modelSelection: modelSelections[index],
+    model: task.model,
+    tier: task.tier,
+    thinking: task.thinking,
+    availableModels,
+    preferredProvider: currentProvider
+  }));
   if (params.clarify === !0 && ctx.hasUI) {
     let behaviors2 = agentConfigs.map((_c, i) => resolveStepBehavior(behaviorOverrides[i])), availableSkills = discoverAvailableSkills(effectiveCwd), result2 = await ctx.ui.custom((tui, theme, _kb, done) => new ChainClarifyComponent(tui, theme, agentConfigs, taskTexts, "", void 0, behaviors2, availableModels, currentProvider, availableSkills, done, "parallel"), { overlay: !0, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } });
     if (!result2 || !result2.confirmed)
@@ -7722,7 +7633,7 @@ async function runParallelPath(data, deps) {
   if (errorResult)
     return errorResult;
   try {
-    let outputBaseDir = path16.join(artifactsDir, "outputs", runId), duplicateOutputError = findDuplicateParallelOutputPath({
+    let outputBaseDir = path15.join(artifactsDir, "outputs", runId), duplicateOutputError = findDuplicateParallelOutputPath({
       tasks,
       behaviors,
       paramsCwd: effectiveCwd,
@@ -7737,7 +7648,7 @@ async function runParallelPath(data, deps) {
       if (validationError)
         return buildParallelModeError(validationError);
     }
-    let parallelProgressPrecreated = firstProgressIndex !== -1, parallelProgressDir = path16.join(artifactsDir, "progress", runId);
+    let parallelProgressPrecreated = firstProgressIndex !== -1, parallelProgressDir = path15.join(artifactsDir, "progress", runId);
     parallelProgressPrecreated && writeInitialProgressFile(parallelProgressDir);
     for (let i = 0; i < taskTexts.length; i++)
       shouldForkAgent(contextPolicy, tasks[i].agent) && (taskTexts[i] = wrapForkTask(taskTexts[i]));
@@ -7855,7 +7766,9 @@ async function runSinglePath(data, deps) {
       task: params.task,
       description: params.description,
       permissions: params.permissions,
+      model: params.model,
       tier: params.tier,
+      thinking: params.thinking,
       skill: params.skill,
       cwd: effectiveCwd,
       output: params.output,
@@ -7884,7 +7797,14 @@ async function runSinglePath(data, deps) {
   }, effectiveToolBudget = resolveEffectiveToolBudget({ runBudget: data.toolBudget, agentBudget: spec.toolBudget, configBudget: data.configToolBudget });
   if (effectiveToolBudget.error)
     return toExecutionErrorResult(params, new Error(effectiveToolBudget.error));
-  let currentProvider = ctx.model?.provider, availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo), task = params.task ?? "", modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider), skillOverride = normalizeSkillInput(params.skill), rawOutput = params.output !== void 0 ? params.output : agentConfig.output, effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output), effectiveOutputMode = params.outputMode ?? "inline", currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth), maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
+  let currentProvider = ctx.model?.provider, availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo), task = params.task ?? "", modelSelection = captureModelSelection({ model: params.model, tier: params.tier }), modelOverride = resolveExecutableChildModel({
+    modelSelection,
+    model: params.model,
+    tier: params.tier,
+    thinking: params.thinking,
+    availableModels,
+    preferredProvider: currentProvider
+  }), skillOverride = normalizeSkillInput(params.skill), rawOutput = params.output !== void 0 ? params.output : agentConfig.output, effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output), effectiveOutputMode = params.outputMode ?? "inline", currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth), maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
   if (params.clarify === !0 && ctx.hasUI) {
     let behavior = resolveStepBehavior({ output: effectiveOutput, skills: skillOverride }), availableSkills = discoverAvailableSkills(effectiveCwd), result2 = await ctx.ui.custom((tui, theme, _kb, done) => new ChainClarifyComponent(tui, theme, [agentConfig], [task], task, void 0, [behavior], availableModels, currentProvider, availableSkills, done, "single"), { overlay: !0, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } });
     if (!result2 || !result2.confirmed)
@@ -8056,28 +7976,16 @@ function foregroundCapacityResult(params, inFlight, limit) {
   return {
     content: [{
       type: "text",
-      text: `Foreground subagent capacity reached (${inFlight}/${limit} running). Wait for a child to finish, use ONE subagent call with tasks: [{task, description}, \u2026], or set async: true.`
+      text: `Foreground subagent capacity reached (${inFlight}/${limit} running). Wait for a child to finish, combine work in ONE tasks call, or launch without async:false or clarify:true when foreground execution is unnecessary.`
     }],
     isError: !0,
     details: { mode: inferExecutionMode(params), results: [] }
   };
 }
-function omitExecutionModeActionAlias(params) {
-  let action = params.action?.toLowerCase();
-  if (action === "single" && params.task !== void 0) {
-    let rest = { ...params };
-    return delete rest.action, rest;
-  }
-  if ((action === "parallel" || action === "tasks") && (params.tasks?.length ?? 0) > 0) {
-    let rest = { ...params };
-    return delete rest.action, rest;
-  }
-  return params;
-}
 function createSubagentExecutor(deps) {
   let execute = async (_id, params, signal, onUpdate, ctx) => {
     deps.state.baseCwd = ctx.cwd, deps.state.foregroundRuns ??= /* @__PURE__ */ new Map(), deps.state.foregroundControls ??= /* @__PURE__ */ new Map(), deps.state.lastForegroundControlId ??= null;
-    let requestParams = omitExecutionModeActionAlias(params), requestCwd = resolveRequestedCwd(ctx.cwd, requestParams.cwd), paramsWithResolvedCwd = requestParams.cwd === void 0 ? requestParams : { ...requestParams, cwd: requestCwd }, action = paramsWithResolvedCwd.action;
+    let requestParams = resolveSubagentRequestParams(params), requestCwd = resolveRequestedCwd(ctx.cwd, requestParams.cwd), paramsWithResolvedCwd = requestParams.cwd === void 0 ? requestParams : { ...requestParams, cwd: requestCwd }, action = paramsWithResolvedCwd.action;
     if (action) {
       if (WATCHDOG_TOOL_ACTIONS.includes(action))
         return deps.allowMutatingManagementActions === !1 && MUTATING_MANAGEMENT_ACTIONS.has(action) ? {
@@ -8158,7 +8066,7 @@ function createSubagentExecutor(deps) {
         let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
         if (paramsWithResolvedCwd.dir)
           try {
-            let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR), runId2 = location.resolvedId ?? targetRunId ?? path16.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
+            let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR), runId2 = location.resolvedId ?? targetRunId ?? path15.basename(location.asyncDir ?? paramsWithResolvedCwd.dir);
             return steerAsyncRun({ state: deps.state, runId: runId2, message, index: paramsWithResolvedCwd.index, kill: deps.kill, location, signal, recover: ({ absoluteDeadlineAt, ...limits }) => resumeAsyncRun({ params: { ...limits, action: "resume", id: runId2, message }, requestCwd, ctx, deps, absoluteDeadlineAt }) });
           } catch (error) {
             return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
@@ -8186,7 +8094,7 @@ function createSubagentExecutor(deps) {
         if (paramsWithResolvedCwd.dir)
           try {
             let location = resolveAsyncRunLocation(paramsWithResolvedCwd, ASYNC_DIR, RESULTS_DIR);
-            return stopAsyncRun(deps.state, location.resolvedId ?? targetRunId ?? path16.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps.kill, location);
+            return stopAsyncRun(deps.state, location.resolvedId ?? targetRunId ?? path15.basename(location.asyncDir ?? paramsWithResolvedCwd.dir), deps.kill, location);
           } catch (error) {
             return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: !0, details: { mode: "management", results: [] } };
           }
@@ -8256,7 +8164,7 @@ function createSubagentExecutor(deps) {
     let normalized = normalizeRepeatedParallelCounts(paramsWithResolvedCwd);
     if (normalized.error)
       return normalized.error;
-    let normalizedParams = normalized.params, effectiveParams = applyForceTopLevelAsyncOverride(normalizedParams, depth, deps.config.forceTopLevelAsync === !0), runToolBudget = resolveToolBudget(effectiveParams.toolBudget, "toolBudget");
+    let effectiveParams = normalized.params, runToolBudget = resolveToolBudget(effectiveParams.toolBudget, "toolBudget");
     if (runToolBudget.error)
       return buildRequestedModeError(effectiveParams, runToolBudget.error);
     let configToolBudget = resolveToolBudget(deps.config.toolBudget, "config.toolBudget");
@@ -8307,23 +8215,23 @@ function createSubagentExecutor(deps) {
     } catch (error) {
       return toExecutionErrorResult(effectiveParams, error);
     }
-    let requestedAsync = effectiveParams.async ?? deps.asyncByDefault, backgroundRequestedWhileClarifying = (hasChain || hasTasks) && requestedAsync && effectiveParams.clarify === !0, effectiveAsync = requestedAsync && effectiveParams.clarify !== !0, controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control), artifactConfig = {
+    let backgroundRequestedWhileClarifying = (hasChain || hasTasks) && effectiveParams.async === !0 && effectiveParams.clarify === !0, effectiveAsync = subagentLaunchRunsAsync(effectiveParams), controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control), artifactConfig = {
       ...DEFAULT_ARTIFACT_CONFIG,
       enabled: effectiveParams.artifacts !== !1
     }, artifactsDir = getArtifactsDir(parentSessionFile, effectiveCwd), sessionRoot;
     if (effectiveParams.sessionDir)
-      sessionRoot = path16.resolve(deps.expandTilde(effectiveParams.sessionDir));
+      sessionRoot = path15.resolve(deps.expandTilde(effectiveParams.sessionDir));
     else {
-      let baseSessionRoot = deps.config.defaultSessionDir ? path16.resolve(deps.expandTilde(deps.config.defaultSessionDir)) : deps.getSubagentSessionRoot(parentSessionFile);
-      sessionRoot = path16.join(baseSessionRoot, runId);
+      let baseSessionRoot = deps.config.defaultSessionDir ? path15.resolve(deps.expandTilde(deps.config.defaultSessionDir)) : deps.getSubagentSessionRoot(parentSessionFile);
+      sessionRoot = path15.join(baseSessionRoot, runId);
     }
     try {
-      fs16.mkdirSync(sessionRoot, { recursive: !0 });
+      fs15.mkdirSync(sessionRoot, { recursive: !0 });
     } catch (error) {
       let message = error instanceof Error ? error.message : String(error);
       return toExecutionErrorResult(effectiveParams, new Error(`Failed to create session directory '${sessionRoot}': ${message}`));
     }
-    let sessionDirForIndex = (idx) => path16.join(sessionRoot, `run-${idx ?? 0}`), forkSessionFileForTask = (agentName, idx = 0, modelOverride) => {
+    let sessionDirForIndex = (idx) => path15.join(sessionRoot, `run-${idx ?? 0}`), forkSessionFileForTask = (agentName, idx = 0, modelOverride) => {
       if (shouldForkAgent(contextPolicy, agentName))
         return prepareForkThinking(agentName, idx, modelOverride), forkSessionFileForIndex(idx);
     }, forkThinkingOverrideForTask = (agentName, idx = 0, modelOverride) => {
@@ -8332,7 +8240,7 @@ function createSubagentExecutor(deps) {
       prepareForkThinking(agentName, idx, modelOverride);
       let override = forkThinkingOverrideForIndex(idx);
       return override === "off" && forkThinkingDowngrades.set(idx, agentName), override;
-    }, childSessionFileForTask = (agentName, idx, modelOverride) => forkSessionFileForTask(agentName, idx, modelOverride) ?? path16.join(sessionDirForIndex(idx), "session.jsonl"), childSessionFileForIndex = (idx) => path16.join(sessionDirForIndex(idx), "session.jsonl");
+    }, childSessionFileForTask = (agentName, idx, modelOverride) => forkSessionFileForTask(agentName, idx, modelOverride) ?? path15.join(sessionDirForIndex(idx), "session.jsonl"), childSessionFileForIndex = (idx) => path15.join(sessionDirForIndex(idx), "session.jsonl");
     try {
       effectiveParams.clarify === !0 && ctx.hasUI || preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, forkSessionFileForTask, deps.config.chain?.dynamicFanout?.maxItems);
     } catch (error) {
@@ -8461,11 +8369,8 @@ function createSubagentExecutor(deps) {
     }, effectiveParams.context);
   };
   return { execute: async (id, params, signal, onUpdate, ctx) => {
-    let requestParams = omitExecutionModeActionAlias(params);
-    if (requestParams.action)
-      return execute(id, requestParams, signal, onUpdate, ctx);
-    let { depth } = checkSubagentDepth(deps.config.maxSubagentDepth), dispatchParams = applyForceTopLevelAsyncOverride(requestParams, depth, deps.config.forceTopLevelAsync === !0);
-    if (!(dispatchParams.clarify === !0 || (dispatchParams.async ?? deps.asyncByDefault) !== !0))
+    let requestParams = resolveSubagentRequestParams(params);
+    if (requestParams.action || !!subagentLaunchRunsAsync(requestParams))
       return execute(id, requestParams, signal, onUpdate, ctx);
     let limit = resolveTopLevelParallelConcurrency(void 0, deps.config.parallel?.concurrency), inFlight = deps.state.foregroundSubagentInFlight ?? 0;
     if (inFlight >= limit)