@ashx-j/lunr 0.2.13 → 0.2.15

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

@@ -12,7 +12,7 @@ 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, resolveEffectiveSubagentModel, resolveTierModelOverride } from "../shared/model-fallback.js";
+import { buildModelCandidates, captureModelSelection, resolveEffectiveSubagentModel, resolveRequiredTierModel } 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";
@@ -1044,7 +1044,9 @@ async function resumeAsyncRun(input) {
             task: buildRevivedAsyncTask(target, followUp),
             description: recoveryDescriptor?.description ?? target.description ?? target.agent,
             permissions: recoveryDescriptor?.permissions ?? target.permissions ?? "read-only",
-            model: input.params.model ?? recoveryDescriptor?.model ?? target.model,
+            model: recoveryDescriptor?.model ?? target.model,
+            tier: input.params.tier ?? recoveryDescriptor?.tier ?? recoveryDescriptor?.modelSelection?.tier,
+            modelSelection: recoveryDescriptor?.modelSelection,
             skill: recoveryDescriptor?.skills,
             cwd: effectiveCwd,
             output: recoveryDescriptor?.outputPath,
@@ -1087,8 +1089,8 @@ async function resumeAsyncRun(input) {
             sourceRunId: target.runId,
             ...(input.deps.state.currentSessionId ? { parentSessionId: input.deps.state.currentSessionId } : {}),
         },
-        modelOverride: input.params.model ?? recoveryDescriptor?.model ?? target.model,
-        thinkingOverride: input.params.model ? undefined : recoveryDescriptor?.thinking ?? target.thinking,
+        modelOverride: recoveryDescriptor?.model ?? target.model,
+        thinkingOverride: recoveryDescriptor?.thinking ?? target.thinking,
         outputBaseDir: resolveSingleRunOutputBaseDir(input.deps, artifactsDir, runId),
         maxSubagentDepth: recoveryDescriptor?.maxSubagentDepth ?? resolveCurrentMaxSubagentDepth(input.deps.config.maxSubagentDepth),
         waitToolEnabled: input.deps.waitToolEnabled,
@@ -1749,8 +1751,10 @@ function runAsyncPath(data, deps) {
         const parallelTasks = params.tasks.map((task, index) => ({
             agent: task.agent,
             task: shouldForkAgent(contextPolicy, task.agent) ? wrapForkTask(task.task) : task.task,
+            description: task.description,
+            permissions: task.permissions,
             cwd: task.cwd,
-            ...(task.model !== undefined ? { model: task.model } : {}),
+            tier: task.tier,
             ...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
             ...(task.output !== undefined && task.output !== true ? { output: task.output } : {}),
             ...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
@@ -1846,14 +1850,14 @@ function runAsyncPath(data, deps) {
         const normalizedSkills = normalizeSkillInput(params.skill);
         const skills = normalizedSkills === false ? [] : normalizedSkills;
         const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
-        // lunr: model tiers — explicit model wins; otherwise resolve params.tier via the tier bridge.
-        const modelOverride = resolveEffectiveSubagentModel(params.model ?? resolveTierModelOverride(params.tier), a.model, ctx.model, availableModels, currentProvider, { scope: data.modelScope });
+        const modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider);
         const spec = normalizeChildSpec({
             task: shouldForkAgent(contextPolicy, params.agent) ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
             description: params.description,
             permissions: params.permissions,
             model: modelOverride,
             tier: params.tier,
+            modelSelection: captureModelSelection({ tier: params.tier }),
             skill: params.skill,
             cwd: effectiveCwd,
             output: effectiveOutput,
@@ -2155,6 +2159,8 @@ async function runForegroundParallelTasks(input) {
             description: task.description,
             permissions: task.permissions,
             model: input.modelOverrides[index] ?? task.model,
+            tier: task.tier,
+            modelSelection: input.modelSelections[index] ?? captureModelSelection({ tier: task.tier }),
             skill: task.skill,
             cwd: taskCwd,
             output: task.output,
@@ -2294,11 +2300,9 @@ async function runParallelPath(data, deps) {
         ...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
         ...(task.progress !== undefined ? { progress: task.progress } : {}),
         ...(skillOverrides[index] !== undefined ? { skills: skillOverrides[index] } : {}),
-        ...(task.model !== undefined ? { model: task.model } : {}),
     }));
-    const modelOverrides = tasks.map((task, i) => 
-    // lunr: model tiers — explicit per-task model wins; otherwise resolve task.tier via the tier bridge.
-    resolveEffectiveSubagentModel(behaviorOverrides[i]?.model ?? resolveTierModelOverride(task.tier), agentConfigs[i]?.model, ctx.model, availableModels, currentProvider, { scope: data.modelScope }));
+    const modelOverrides = tasks.map((task, i) => resolveRequiredTierModel(task.tier, availableModels, currentProvider));
+    const modelSelections = tasks.map((task) => captureModelSelection({ tier: task.tier }));
     if (params.clarify === true && ctx.hasUI) {
         const behaviors = agentConfigs.map((_c, i) => resolveStepBehavior(behaviorOverrides[i]));
         const availableSkills = discoverAvailableSkills(effectiveCwd);
@@ -2309,10 +2313,6 @@ async function runParallelPath(data, deps) {
         taskTexts = result.templates;
         for (let i = 0; i < result.behaviorOverrides.length; i++) {
             const override = result.behaviorOverrides[i];
-            if (override?.model !== undefined) {
-                modelOverrides[i] = resolveEffectiveSubagentModel(override.model, agentConfigs[i]?.model, ctx.model, availableModels, currentProvider, { scope: data.modelScope });
-                behaviorOverrides[i].model = override.model;
-            }
             if (override?.output !== undefined)
                 behaviorOverrides[i].output = override.output;
             if (override?.reads !== undefined)
@@ -2348,8 +2348,10 @@ async function runParallelPath(data, deps) {
                 return {
                     agent: t.agent,
                     task: taskText,
+                    description: t.description,
+                    permissions: t.permissions,
                     cwd: t.cwd,
-                    ...(behaviorOverrides[i]?.model !== undefined ? { model: behaviorOverrides[i].model } : {}),
+                    tier: t.tier,
                     ...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
                     ...(behaviorOverrides[i]?.output !== undefined ? { output: behaviorOverrides[i].output } : {}),
                     ...(behaviorOverrides[i]?.outputMode !== undefined ? { outputMode: behaviorOverrides[i].outputMode } : {}),
@@ -2448,6 +2450,7 @@ async function runParallelPath(data, deps) {
             availableModels,
             modelScope: data.modelScope,
             modelOverrides,
+            modelSelections,
             behaviors,
             firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,
             controlConfig,
@@ -2556,7 +2559,6 @@ async function runSinglePath(data, deps) {
             task: params.task,
             description: params.description,
             permissions: params.permissions,
-            model: params.model,
             tier: params.tier,
             skill: params.skill,
             cwd: effectiveCwd,
@@ -2594,8 +2596,7 @@ async function runSinglePath(data, deps) {
     const currentProvider = ctx.model?.provider;
     const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
     let task = params.task ?? "";
-    // lunr: model tiers — explicit model wins; otherwise resolve params.tier via the tier bridge.
-    let modelOverride = resolveEffectiveSubagentModel(params.model ?? resolveTierModelOverride(params.tier), agentConfig.model, ctx.model, availableModels, currentProvider, { scope: data.modelScope });
+    let modelOverride = resolveRequiredTierModel(params.tier, availableModels, currentProvider);
     let skillOverride = normalizeSkillInput(params.skill);
     const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
     let effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
@@ -2611,8 +2612,6 @@ async function runSinglePath(data, deps) {
         }
         task = result.templates[0];
         const override = result.behaviorOverrides[0];
-        if (override?.model !== undefined)
-            modelOverride = resolveEffectiveSubagentModel(override.model, agentConfig.model, ctx.model, availableModels, currentProvider, { scope: data.modelScope });
         if (override?.output !== undefined)
             effectiveOutput = normalizeSingleOutputOverride(override.output, agentConfig.output);
         if (override?.skills !== undefined)