fix(subagent): keep explicit parent pin across provider rebuild

Author: TheGreatAxios

src/subagent/agent-fleet-effort.test.ts

@@ -247,6 +247,63 @@ describe("custom worker efforts", () => {
     expect(worker?.provider.explicitReasoningEffort).toBeUndefined();
   });
 
+  test("explicit parent pin survives the applyResolvedProvider rebuild (CL-10227)", async () => {
+    // A profile/director spawn with a resolving inference rebuilds `provider`
+    // from settings via applyResolvedProvider. That rebuild must not drop the
+    // operator-explicit parent-effort marker — otherwise the operator pin is
+    // demoted to a derived parent and the leaf role default (medium) wins,
+    // violating the CL-10227 fleet-pin contract. Here the model ladder supports
+    // both the parent ("none") and the role default ("medium"), so only the
+    // surviving explicit flag can pick "none".
+    let worker: RunSubAgentParams | undefined;
+    const pinProvider: ProviderCatalogEntry = {
+      ...provider,
+      reasoningEfforts: ["none", "medium", "max"],
+    };
+    const deps = createFleetDeps(
+      async (params) => {
+        worker = params;
+        return { report: "done" };
+      },
+      {
+        settings: { providers: { custom: pinProvider } },
+        catalog: [pinProvider],
+        profiles: [
+          {
+            id: "custom-leaf",
+            inference: {
+              mode: "pin",
+              order: [
+                {
+                  provider: pinProvider.name,
+                  model: "custom-model",
+                },
+              ],
+            },
+          },
+        ],
+      },
+    );
+    deps.provider = {
+      providerName: pinProvider.name,
+      baseURL: pinProvider.baseURL,
+      model: "custom-model",
+      reasoningEffort: "none",
+      explicitReasoningEffort: true,
+    };
+    const result = await callFleetToolRaw(createSpawnAgentTool(deps), {
+      description: "inspect",
+      prompt: "inspect",
+      agent: "custom-leaf",
+    });
+    expect(result.isError).not.toBe(true);
+    await callFleetToolRaw(fleetTools(deps).wait, { timeout_ms: 2000 });
+    // The operator-explicit parent pin ("none") survives the rebuild and beats
+    // the leaf role default ("medium").
+    expect(worker?.provider.reasoningEffort).toBe("none");
+    expect(worker?.provider.explicitReasoningEffort).toBe(true);
+  });
+
   test("explicit effortPin still wins over an explicit parent", async () => {
     // An explicit parent is a fleet pin, but the cascade still lets an explicit
     // effortPin outrank it — the legacy pin-max case stays.

src/subagent/agent-fleet.ts

@@ -1015,6 +1015,11 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
 
       let provider: SubAgentProvider = resolveDep(deps.provider);
       const parentEffort = provider.reasoningEffort;
+      // Operator-chosen parent effort signal, captured BEFORE applyResolvedProvider
+      // may rebuild `provider` from settings (which drops any marker). Read from
+      // this captured value everywhere so the explicit fleet-pin survives the
+      // rebuild; `true` is the only value the type allows.
+      const parentExplicit = provider.explicitReasoningEffort === true;
       const diskSettings =
         deps.settings !== undefined ? resolveDep(deps.settings) : undefined;
       const catalog =
@@ -1067,6 +1072,10 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
             ? { apiKey: providerSettings.apiKey }
             : {}),
           model: resolved.model,
+          // The operator-chosen parent-effort marker is not a provider fact:
+          // it survived the rebuild so an effort-carrying director/profile
+          // spawn keeps its explicit fleet-pin signal (re-read at resolve time).
+          ...(parentExplicit ? { explicitReasoningEffort: true } : {}),
         };
         return null;
       };
@@ -1183,7 +1192,7 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
           ? { roleDefault: resolved.roleDefault }
           : {}),
         ...(parentEffort !== undefined ? { parentEffort } : {}),
-        ...(parentEffort !== undefined && provider.explicitReasoningEffort
+        ...(parentEffort !== undefined && parentExplicit
           ? { explicitParentEffort: true }
           : {}),
         model: provider.model,