pi-subagents 0.74.0 → 0.75.0

package/src/runs/background/async-execution.js

@@ -15,6 +15,7 @@ import { currentCompletionOwnerId } from "../../shared/completion-owner.js";
 import { planChildLaunch, projectChainOutputSchemas, resolveStepBehavior, suppressProgressForReadOnlyTask } from "../shared/child-launch-plan.js";
 import { formatHerdrMachineRunnerUnsupported, resolveHerdrMachinePlacement } from "../shared/herdr-machine.js";
 import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/child-tool-plan.js";
+import { assertClaudeCodeModelScope, isClaudeCodeAdapterId, resolveClaudeCodeOverride } from "../shared/claude-code-adapter.js";
 import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import { applyWatchdogLaunchRules, sendRuleViolationWarning } from "../../watchdog/rules.js";
 import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveExistingReadInstructionPaths, resolveExistingReadPaths, writeInitialProgressFile } from "../../shared/settings.js";
@@ -57,7 +58,7 @@ import { resolvePermissionRules } from "../shared/permissions.js";
 import { normalizeExtensionBindings, omitExtensionBindingsEnv } from "../shared/extension-bindings.js";
 import { omitGitRoutingEnv } from "../shared/git-environment.js";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
-import { resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
+import { assertRequiredChildExtensionsAdmitted, resolveRequiredChildExtensions, writeRetainedRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 const require = nodeModule.createRequire(import.meta.url);
 const piPackageRoot = resolveAsyncPiPackageRoot();
 /**
@@ -629,6 +630,22 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
         return { error: error instanceof Error ? error.message : String(error) };
     }
 }
+/**
+ * An explicit `thinking: false` clears the level, so only `undefined` falls
+ * through to the agent's own value. Treating `false` as absent would silently
+ * apply the agent default the caller just cleared.
+ */
+export function resolveClaudeCodeThinking(source, fallback) {
+    const value = source === undefined ? fallback : source;
+    return typeof value === "string" ? value : undefined;
+}
+/** A pinned Claude Code model cannot survive pane-native saved-machine placement, which
+ * owns the remote model registry, so the combination fails instead of losing both flags. */
+export function assertClaudeCodeOverrideIsLocal(agent, machine, override) {
+    if (!machine || !override)
+        return;
+    throw new Error(`Agent '${agent}' requested machine '${machine}', but a Claude Code model or thinking level cannot be honored on a saved machine. Remove the model or thinking request, or run the agent locally.`);
+}
 function formatAsyncStartError(mode, message) {
     return {
         content: [{ type: "text", text: message }],
@@ -725,6 +742,13 @@ export function buildAsyncRunnerSteps(id, params) {
         const machineUnsupported = formatHerdrMachineRunnerUnsupported({ machine: requestedMachine, agentName: a.name, runnerType: a.runner?.type, adapter: a.runner?.type === "external-cli" ? a.runner.adapter : undefined, worktree: s.worktree });
         if (machineUnsupported)
             throw new AsyncStartValidationError(machineUnsupported);
+        const registeredExtensions = resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
+        try {
+            assertRequiredChildExtensionsAdmitted([params.requiredExtensions, ctx.childRuntime?.requiredExtensions, registeredExtensions], { agent: a.name, runnerType: a.runner?.type, machine: requestedMachine });
+        }
+        catch (error) {
+            throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+        }
         let machine;
         let machineEnv;
         if (requestedMachine) {
@@ -737,9 +761,12 @@ export function buildAsyncRunnerSteps(id, params) {
                 throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
             }
         }
+        // A code-owned Claude Code adapter owns its argv, but it does accept an explicit
+        // model/thinking request; those become --model/--effort on the launch below.
+        const claudeCodeAdapter = a.runner?.type === "external-cli" && isClaudeCodeAdapterId(a.runner.adapter);
         if (externalRunner) {
             const unsupported = [];
-            if (s.model !== undefined)
+            if (s.model !== undefined && !claudeCodeAdapter)
                 unsupported.push("model override");
             if (effectiveBehavior.outputSchema !== undefined)
                 unsupported.push("structured output");
@@ -811,6 +838,24 @@ export function buildAsyncRunnerSteps(id, params) {
         const primaryModelFromParent = modelOrigin === "inherited";
         const primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(s.model, a.model, ctx.currentModel, availableModels, a.modelProvider ?? ctx.currentModelProvider, { scope: modelScopes, source: modelOrigin === "explicit" ? "explicit" : "inherited" });
         const thinkingOverride = flatIndex === undefined ? undefined : thinkingOverridesByFlatIndex?.[flatIndex];
+        let claudeCodeOverride;
+        if (claudeCodeAdapter) {
+            try {
+                claudeCodeOverride = resolveClaudeCodeOverride({
+                    model: typeof s.model === "string" ? s.model : undefined,
+                    agent: a,
+                    thinking: resolveClaudeCodeThinking(thinkingOverride, a.thinking),
+                    thinkingCeiling: intersectThinkingCeilings(params.thinkingCeiling, a.maxThinking, ctx.childRuntime?.thinkingCeiling),
+                    agentName: a.name,
+                    runId: id,
+                });
+                assertClaudeCodeModelScope({ scopes: modelScopes, model: claudeCodeOverride?.model, agent: a.name, runId: id });
+                assertClaudeCodeOverrideIsLocal(a.name, machine ? requestedMachine : undefined, claudeCodeOverride);
+            }
+            catch (error) {
+                throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+            }
+        }
         const effectiveThinking = externalRunner ? undefined : thinkingOverride ?? a.thinking;
         const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== undefined);
         const contextLimit = model ? findModelInfo(model, availableModels, a.modelProvider ?? ctx.currentModelProvider)?.contextWindow : undefined;
@@ -846,7 +891,7 @@ export function buildAsyncRunnerSteps(id, params) {
         if (launchRuleError)
             throw new AsyncStartValidationError(launchRuleError);
         const fast = s.fast ?? params.fast ?? a.fast;
-        const requiredExtensions = externalRunner ? [] : ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
+        const requiredExtensions = externalRunner ? [] : params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? registeredExtensions;
         const toolPlan = resolvePiLaunchToolPlan({
             tools: a.tools,
             excludeTools: a.excludeTools,
@@ -878,6 +923,7 @@ export function buildAsyncRunnerSteps(id, params) {
             agent: s.agent,
             task,
             ...(a.runner ? { runner: a.runner } : {}),
+            ...(claudeCodeOverride ? { claudeCodeOverrideArgs: claudeCodeOverride.args } : {}),
             ...(machine ? { machine } : {}),
             ...(machineEnv ? { machineEnv } : {}),
             ...(params.contextForAgent ? { context: params.contextForAgent(s.agent) } : {}),
@@ -1150,6 +1196,7 @@ export function executeAsyncChain(id, params) {
         toolTimeoutMsEnv: params.toolTimeoutMsEnv ?? toolTimeoutFromEnv(),
         capabilityCeiling,
         thinkingCeiling: params.thinkingCeiling,
+        requiredExtensions: params.requiredExtensions,
     });
     if ("error" in built) {
         try {
@@ -1196,6 +1243,13 @@ export function executeAsyncChain(id, params) {
     const initialStatusAt = Date.now();
     const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
     const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
+    try {
+        writeRetainedRequiredChildExtensions(asyncDir, params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(launchParentSessionId ?? undefined));
+    }
+    catch (error) {
+        fs.rmSync(asyncDir, { recursive: true, force: true });
+        return formatAsyncStartError(resultMode, `Failed to record required child extensions: ${error instanceof Error ? error.message : String(error)}`);
+    }
     let spawnResult = {};
     try {
         spawnResult = spawnRunner({
@@ -1416,13 +1470,16 @@ export function executeAsyncSingle(id, params) {
     const externalRunner = agentConfig.runner?.type === "external-cli" || agentConfig.runner?.type === "external-job";
     const externalRunnerType = agentConfig.runner?.type;
     const permissionRules = resolvePermissionRules(ctx.permissions, agentConfig.permissions);
+    // See the chain path: the Claude Code adapter accepts an explicit model/thinking
+    // request even though no other external runner does.
+    const claudeCodeAdapter = agentConfig.runner?.type === "external-cli" && isClaudeCodeAdapterId(agentConfig.runner.adapter);
     if (externalRunner) {
         const unsupported = [];
-        if (params.modelOverride !== undefined)
+        if (params.modelOverride !== undefined && !claudeCodeAdapter)
             unsupported.push("model override");
         if ((params.fast ?? agentConfig.fast) === true)
             unsupported.push("fast mode");
-        if (params.thinkingOverride !== undefined)
+        if (params.thinkingOverride !== undefined && !claudeCodeAdapter)
             unsupported.push("thinking override");
         if (params.structuredOutputSchema !== undefined)
             unsupported.push("structured output");
@@ -1453,6 +1510,13 @@ export function executeAsyncSingle(id, params) {
     const machineUnsupported = formatHerdrMachineRunnerUnsupported({ machine: requestedMachine, agentName: agentConfig.name, runnerType: agentConfig.runner?.type, adapter: agentConfig.runner?.type === "external-cli" ? agentConfig.runner.adapter : undefined, worktree: params.worktree });
     if (machineUnsupported)
         return formatAsyncStartError("single", machineUnsupported);
+    const registeredExtensions = resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
+    try {
+        assertRequiredChildExtensionsAdmitted([params.requiredExtensions, ctx.childRuntime?.requiredExtensions, registeredExtensions], { agent: agentConfig.name, runnerType: agentConfig.runner?.type, machine: requestedMachine });
+    }
+    catch (error) {
+        return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+    }
     let machine;
     let machineEnv;
     if (requestedMachine) {
@@ -1546,6 +1610,24 @@ export function executeAsyncSingle(id, params) {
     catch (error) {
         return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
     }
+    let singleClaudeCodeOverride;
+    if (claudeCodeAdapter) {
+        try {
+            singleClaudeCodeOverride = resolveClaudeCodeOverride({
+                model: typeof params.modelOverride === "string" ? params.modelOverride : undefined,
+                agent: agentConfig,
+                thinking: resolveClaudeCodeThinking(params.thinkingOverride, agentConfig.thinking),
+                thinkingCeiling: intersectThinkingCeilings(params.thinkingCeiling, agentConfig.maxThinking, ctx.childRuntime?.thinkingCeiling),
+                agentName: agentConfig.name,
+                runId: id,
+            });
+            assertClaudeCodeModelScope({ scopes: modelScopes, model: singleClaudeCodeOverride?.model, agent: agentConfig.name, runId: id });
+            assertClaudeCodeOverrideIsLocal(agentConfig.name, machine ? requestedMachine : undefined, singleClaudeCodeOverride);
+        }
+        catch (error) {
+            return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+        }
+    }
     const effectiveThinking = externalRunner ? undefined : params.thinkingOverride ?? agentConfig.thinking;
     const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
     const contextLimit = model ? findModelInfo(model, availableModels, agentConfig.modelProvider ?? ctx.currentModelProvider)?.contextWindow : undefined;
@@ -1599,7 +1681,7 @@ export function executeAsyncSingle(id, params) {
             return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
         }
     }
-    const requiredExtensions = externalRunner ? [] : params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
+    const requiredExtensions = externalRunner ? [] : params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? registeredExtensions;
     const toolPlan = resolvePiLaunchToolPlan({
         tools: agentConfig.tools,
         excludeTools: agentConfig.excludeTools,
@@ -1725,6 +1807,7 @@ export function executeAsyncSingle(id, params) {
                     agent,
                     task: taskText,
                     ...(agentConfig.runner ? { runner: agentConfig.runner } : {}),
+                    ...(singleClaudeCodeOverride ? { claudeCodeOverrideArgs: singleClaudeCodeOverride.args } : {}),
                     ...(machine ? { machine } : {}),
                     ...(!externalRunner && machine && params.reads !== undefined ? { remoteReads: params.reads } : {}),
                     ...(machineEnv ? { machineEnv } : {}),