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

package/dist/builtin-extensions/pi-subagents/src/runs/foreground/subagent-executor.js

@@ -6,13 +6,14 @@ import { snapshotParentPermissionMode } from "../../../../../core/subagent-permi
 import { normalizeChildSpec } from "../../shared/child-spec.js";
 import { getArtifactsDir, getProjectChainRunsDir } from "../../shared/artifacts.js";
 import { ChainClarifyComponent } from "./chain-clarify.js";
+import { resolveSubagentRequestParams } from "./request-params.js";
 import { toModelInfo } from "../../shared/model-info.js";
 import { executeChain } from "./chain-execution.js";
 import { buildDoctorReport } from "../../extension/doctor.js";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.js";
 import { runSync } from "./execution.js";
 import { handleWatchdogToolAction, WATCHDOG_TOOL_ACTIONS } from "../../watchdog/tool-actions.js";
-import { buildModelCandidates, captureModelSelection, resolveEffectiveSubagentModel, resolveRequiredTierModel } from "../shared/model-fallback.js";
+import { buildModelCandidates, captureModelSelection, resolveEffectiveSubagentModel, resolveExecutableChildModel } from "../shared/model-fallback.js";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.js";
 import { recordRun } from "../shared/run-history.js";
 import { buildChainInstructions, writeInitialProgressFile, getStepAgents, isParallelStep, isDynamicParallelStep, resolveStepBehavior, suppressProgressForReadOnlyTask, taskDisallowsFileUpdates, } from "../../shared/settings.js";
@@ -20,7 +21,7 @@ import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skill
 import { buildAsyncRunnerSteps, executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable } from "../background/async-execution.js";
 import { enqueueChainAppendRequest, readPendingChainAppendRequests, runnerStepOutputNames } from "../background/chain-append.js";
 import { ChainOutputValidationError, validateChainOutputBindingsWithContext } from "../shared/chain-outputs.js";
-import { validateExecutionAcceptance } from "../shared/acceptance.js";
+import { restorePersistedAcceptance, validateExecutionAcceptance } from "../shared/acceptance.js";
 import { createForkContextResolver, forkedChildRequiresThinkingOff } from "../../shared/fork-context.js";
 import { lunrContextPolicy } from "../../shared/lunr-child-context.js";
 import { resolveCurrentSessionId } from "../../shared/session-identity.js";
@@ -42,10 +43,10 @@ import { attachRootChildrenToSteps, createNestedRoute, readNestedControlResults,
 import { resolveSubagentRunId } from "../background/run-id-resolver.js";
 import { formatNestedRunStatusLines } from "../shared/nested-render.js";
 import { inspectSubagentStatus } from "../background/run-status.js";
-import { applyForceTopLevelAsyncOverride } from "../background/top-level-async.js";
+import { subagentLaunchRunsAsync } from "../background/top-level-async.js";
 import { cleanupWorktrees, createWorktrees, diffWorktrees, findWorktreeTaskCwdConflict, formatWorktreeDiffSummary, formatWorktreeTaskCwdConflict, } from "../shared/worktree.js";
 import { ASYNC_DIR, DEFAULT_ARTIFACT_CONFIG, DEFAULT_FORK_PREAMBLE, RESULTS_DIR, SUBAGENT_ACTIONS, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, checkSubagentDepth, resolveMaxSubagentSpawnsPerSession, resolveTopLevelParallelConcurrency, resolveTopLevelParallelMaxTasks, resolveChildMaxSubagentDepth, resolveCurrentMaxSubagentDepth, wrapForkTask, } from "../../shared/types.js";
-const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete", "eject", "disable", "enable", "reset", "watchdog.configure"]);
+const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete", "eject", "disable", "enable", "reset"]);
 function resolveRequestedCwd(runtimeCwd, requestedCwd) {
     return requestedCwd ? path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
@@ -1038,26 +1039,43 @@ async function resumeAsyncRun(input) {
     const artifactConfig = recoveryDescriptor?.artifactConfig ?? { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== false };
     const artifactsDir = recoveryDescriptor?.artifactsDir ?? getArtifactsDir(parentSessionFile, effectiveCwd);
     const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
+    let restoredAcceptance;
+    if (recoveryDescriptor?.acceptance !== undefined && input.params.acceptance === undefined) {
+        try {
+            restoredAcceptance = restorePersistedAcceptance(recoveryDescriptor.acceptance, "recoveryDescriptor.acceptance");
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+        }
+    }
     let recoverySpec;
     try {
+        const recoverySelection = recoveryDescriptor?.modelSelection ?? target.modelSelection;
+        const 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)
+                : undefined,
+            tier: recoveryIsExplicitModel
+                ? undefined
+                : (input.params.tier ?? recoverySelection?.tier ?? recoveryDescriptor?.tier),
+            thinking: recoveryIsExplicitModel ? (recoveryDescriptor?.thinking ?? target.thinking) : undefined,
+            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`,
+            resolvedModelIsRuntime: !recoveryIsExplicitModel && Boolean(recoveryDescriptor?.model ?? target.model),
         });
     }
     catch (error) {
@@ -1065,6 +1083,7 @@ async function resumeAsyncRun(input) {
     }
     const result = executeAsyncSingle(runId, {
         spec: recoverySpec,
+        completionTask: followUp,
         goal: followUp,
         ctx: {
             pi: input.deps.pi,
@@ -1104,7 +1123,7 @@ async function resumeAsyncRun(input) {
         output: recoveryDescriptor?.outputPath,
         outputMode: recoveryDescriptor?.outputMode,
         ...(recoveryDescriptor?.skills ? { skills: [...recoveryDescriptor.skills] } : {}),
-        ...(recoveryDescriptor?.acceptance !== undefined && input.params.acceptance === undefined ? { acceptance: recoveryDescriptor.acceptance } : {}),
+        ...(restoredAcceptance ? { restoredAcceptance } : {}),
         ...(input.params.timeoutMs !== undefined ? { timeoutMs: input.params.timeoutMs } : {}),
         ...(input.absoluteDeadlineAt !== undefined ? { absoluteDeadlineAt: input.absoluteDeadlineAt } : {}),
         ...(input.params.turnBudget !== undefined ? { turnBudget: input.params.turnBudget } : {}),
@@ -1416,6 +1435,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,
@@ -1850,14 +1870,23 @@ function runAsyncPath(data, deps) {
         const normalizedSkills = normalizeSkillInput(params.skill);
         const skills = normalizedSkills === false ? [] : normalizedSkills;
         const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
-        const modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider);
+        const modelSelection = captureModelSelection({ model: params.model, tier: params.tier });
+        const modelOverride = resolveExecutableChildModel({
+            modelSelection,
+            model: params.model,
+            tier: params.tier,
+            thinking: params.thinking,
+            availableModels,
+            preferredProvider: currentProvider,
+        });
         const 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,
@@ -2154,13 +2183,15 @@ async function runForegroundParallelTasks(input) {
                 return true;
             };
         }
+        const 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,
@@ -2301,8 +2332,15 @@ async function runParallelPath(data, deps) {
         ...(task.progress !== undefined ? { progress: task.progress } : {}),
         ...(skillOverrides[index] !== undefined ? { skills: skillOverrides[index] } : {}),
     }));
-    const modelOverrides = tasks.map((task, i) => resolveRequiredTierModel(task.tier, availableModels, currentProvider));
-    const modelSelections = tasks.map((task) => captureModelSelection({ tier: task.tier }));
+    const modelSelections = tasks.map((task) => captureModelSelection({ model: task.model, tier: task.tier }));
+    const modelOverrides = tasks.map((task, index) => resolveExecutableChildModel({
+        modelSelection: modelSelections[index],
+        model: task.model,
+        tier: task.tier,
+        thinking: task.thinking,
+        availableModels,
+        preferredProvider: currentProvider,
+    }));
     if (params.clarify === true && ctx.hasUI) {
         const behaviors = agentConfigs.map((_c, i) => resolveStepBehavior(behaviorOverrides[i]));
         const availableSkills = discoverAvailableSkills(effectiveCwd);
@@ -2559,7 +2597,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,
@@ -2596,7 +2636,15 @@ async function runSinglePath(data, deps) {
     const currentProvider = ctx.model?.provider;
     const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
     let task = params.task ?? "";
-    let modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider);
+    const modelSelection = captureModelSelection({ model: params.model, tier: params.tier });
+    let modelOverride = resolveExecutableChildModel({
+        modelSelection,
+        model: params.model,
+        tier: params.tier,
+        thinking: params.thinking,
+        availableModels,
+        preferredProvider: currentProvider,
+    });
     let skillOverride = normalizeSkillInput(params.skill);
     const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
     let effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
@@ -2858,33 +2906,19 @@ 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}, …], 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: true,
         details: { mode: inferExecutionMode(params), results: [] },
     };
 }
-function omitExecutionModeActionAlias(params) {
-    const action = params.action?.toLowerCase();
-    if (action === "single" && params.task !== undefined) {
-        const rest = { ...params };
-        delete rest.action;
-        return rest;
-    }
-    if ((action === "parallel" || action === "tasks") && (params.tasks?.length ?? 0) > 0) {
-        const rest = { ...params };
-        delete rest.action;
-        return rest;
-    }
-    return params;
-}
 export function createSubagentExecutor(deps) {
     const execute = async (_id, params, signal, onUpdate, ctx) => {
         deps.state.baseCwd = ctx.cwd;
         deps.state.foregroundRuns ??= new Map();
         deps.state.foregroundControls ??= new Map();
         deps.state.lastForegroundControlId ??= null;
-        const requestParams = omitExecutionModeActionAlias(params);
+        const requestParams = resolveSubagentRequestParams(params);
         const requestCwd = resolveRequestedCwd(ctx.cwd, requestParams.cwd);
         const paramsWithResolvedCwd = requestParams.cwd === undefined ? requestParams : { ...requestParams, cwd: requestCwd };
         const action = paramsWithResolvedCwd.action;
@@ -3132,7 +3166,7 @@ export function createSubagentExecutor(deps) {
         if (normalized.error)
             return normalized.error;
         const normalizedParams = normalized.params;
-        let effectiveParams = applyForceTopLevelAsyncOverride(normalizedParams, depth, deps.config.forceTopLevelAsync === true);
+        let effectiveParams = normalizedParams;
         const runToolBudget = resolveToolBudget(effectiveParams.toolBudget, "toolBudget");
         if (runToolBudget.error)
             return buildRequestedModeError(effectiveParams, runToolBudget.error);
@@ -3212,9 +3246,10 @@ export function createSubagentExecutor(deps) {
         catch (error) {
             return toExecutionErrorResult(effectiveParams, error);
         }
-        const requestedAsync = effectiveParams.async ?? deps.asyncByDefault;
-        const backgroundRequestedWhileClarifying = (hasChain || hasTasks) && requestedAsync && effectiveParams.clarify === true;
-        const effectiveAsync = requestedAsync && effectiveParams.clarify !== true;
+        const backgroundRequestedWhileClarifying = (hasChain || hasTasks)
+            && effectiveParams.async === true
+            && effectiveParams.clarify === true;
+        const effectiveAsync = subagentLaunchRunsAsync(effectiveParams);
         const controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control);
         const artifactConfig = {
             ...DEFAULT_ARTIFACT_CONFIG,
@@ -3442,12 +3477,10 @@ export function createSubagentExecutor(deps) {
         }, effectiveParams.context);
     };
     const executeWithSingleDispatchGuard = async (id, params, signal, onUpdate, ctx) => {
-        const requestParams = omitExecutionModeActionAlias(params);
+        const requestParams = resolveSubagentRequestParams(params);
         if (requestParams.action)
             return execute(id, requestParams, signal, onUpdate, ctx);
-        const { depth } = checkSubagentDepth(deps.config.maxSubagentDepth);
-        const dispatchParams = applyForceTopLevelAsyncOverride(requestParams, depth, deps.config.forceTopLevelAsync === true);
-        const runsForeground = dispatchParams.clarify === true || (dispatchParams.async ?? deps.asyncByDefault) !== true;
+        const runsForeground = !subagentLaunchRunsAsync(requestParams);
         if (!runsForeground)
             return execute(id, requestParams, signal, onUpdate, ctx);
         const limit = resolveTopLevelParallelConcurrency(undefined, deps.config.parallel?.concurrency);