@ashx-j/lunr 0.2.18 → 0.2.20

package/dist/node-runtime/{subagent-executor-5Q5A4HJ2.js → subagent-executor-SRFC26SJ.js}

@@ -21,7 +21,6 @@ import {
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
   Semaphore,
   TEMP_ROOT_DIR,
-  THINKING_LEVELS,
   acceptChildWatchdogEvent,
   acceptanceFailureMessage,
   aggregateAcceptanceReport,
@@ -30,7 +29,6 @@ import {
   appendTurnBudgetSystemPrompt,
   applyIntercomBridgeToAgent,
   applyThinkingSuffix,
-  assertSafeNestedId,
   attachNestedChildrenToResultChildren,
   attachRootChildrenToSteps,
   buildChainInstructions,
@@ -69,11 +67,9 @@ import {
   expectsImplementationMutation,
   extractTextFromContent,
   extractToolArgsPreview,
-  findAsyncRunPrefixMatches,
   findLatestSessionFile,
   findModelInfo,
   findNestedRouteForRootId,
-  findNestedRunMatchesById,
   flatToLogicalStepIndex,
   formatAcceptancePrompt,
   formatActivityLabel,
@@ -116,7 +112,6 @@ import {
   normalizeChildSpec,
   normalizeParallelGroups,
   normalizeSkillInput,
-  parseWatchdogThinkingInput,
   projectNestedRegistryForRoot,
   readChildToolDiagnosticError,
   readNestedControlResults,
@@ -140,6 +135,7 @@ import {
   resolveEffectiveAcceptance,
   resolveEffectiveSubagentModel,
   resolveEffectiveThinking,
+  resolveExecutableChildModel,
   resolveInheritedNestedRouteFromEnv,
   resolveIntercomBridge,
   resolveIntercomSessionTarget,
@@ -148,16 +144,17 @@ import {
   resolveNestedAsyncDir,
   resolveNestedParentAddressFromEnv,
   resolveParallelBehaviors,
-  resolveRequiredTierModel,
   resolveSkillsWithFallback,
   resolveStepBehavior,
   resolveSubagentIntercomTarget,
   resolveSubagentResultStatus,
+  resolveSubagentRunId,
   resolveTopLevelParallelConcurrency,
   resolveTopLevelParallelMaxTasks,
   resolveTurnBudgetConfig,
   resolveWatchdogConfig,
   resolveWatchdogModelInput,
+  restorePersistedAcceptance,
   shouldAbortForTurnBudget,
   shouldNotifyControlEvent,
   splitKnownThinkingSuffix,
@@ -186,14 +183,13 @@ import {
   writeMetadata,
   writeNestedControlRequest,
   writeNestedEvent,
-  writePrivateAtomicJson,
-  writeWatchdogModelSettings
-} from "./chunk-MCUNIRD5.js";
+  writePrivateAtomicJson
+} from "./chunk-46ECNOLF.js";
 import {
   PLAN_MODE_WRITE_SPAWN_ERROR,
   resolveChildPermissions,
   snapshotParentPermissionMode
-} from "./chunk-XATUM2HK.js";
+} from "./chunk-25I2BHAA.js";
 import "./chunk-WKDK4C5P.js";
 import "./chunk-53YJI7JU.js";
 import "./chunk-KBKMCJDU.js";
@@ -203,7 +199,7 @@ import {
 } from "./chunk-GKLEQ3I4.js";
 import "./chunk-FVDOXRUD.js";
 import "./chunk-AD6VXAO7.js";
-import "./chunk-J26TSGDL.js";
+import "./chunk-6N22HULO.js";
 import "./chunk-M3LZLQW2.js";
 import "./chunk-RQ2Q5IYR.js";
 import "./chunk-DDWHZ633.js";
@@ -214,8 +210,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";
@@ -1260,20 +1256,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 {
       }
@@ -1291,7 +1287,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;
@@ -3294,10 +3290,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]);
@@ -3327,9 +3326,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,
@@ -3834,7 +3834,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)
@@ -3863,9 +3869,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,
@@ -4264,7 +4271,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),
@@ -4556,6 +4570,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"))
@@ -4583,19 +4607,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,
@@ -4607,8 +4637,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 } : {},
@@ -4887,62 +4917,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(`
 `);
 }
@@ -4969,44 +4950,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";
@@ -5488,81 +5439,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)
@@ -5598,9 +5479,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 {
@@ -5773,7 +5654,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)
@@ -5817,22 +5698,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: [] } };
@@ -5862,9 +5743,9 @@ function applyForceTopLevelAsyncOverride(params, depth, forceTopLevelAsync) {
 }
 
 // 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)
@@ -5896,7 +5777,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) {
@@ -6043,10 +5924,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 };
 }
@@ -6101,7 +5982,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) {
@@ -6366,27 +6247,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;
 }
@@ -6406,7 +6287,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)
   };
 }
@@ -6433,7 +6314,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: [] } };
@@ -6446,7 +6327,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 ?? [];
@@ -6540,7 +6421,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);
@@ -6605,7 +6486,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,
@@ -6651,26 +6532,36 @@ ${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: [] } };
@@ -6716,7 +6607,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 } : {},
@@ -6984,6 +6875,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,
@@ -7328,13 +7220,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,
@@ -7520,7 +7420,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++) {
@@ -7540,7 +7440,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) {
@@ -7563,13 +7463,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,
@@ -7674,7 +7577,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)
@@ -7750,7 +7660,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,
@@ -7765,7 +7675,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]));
@@ -7883,7 +7793,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,
@@ -7912,7 +7824,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)
@@ -8174,7 +8093,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: [] } };
@@ -8202,7 +8121,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: [] } };
           }
@@ -8328,18 +8247,18 @@ function createSubagentExecutor(deps) {
       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) => {
@@ -8348,7 +8267,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) {