oira666_pi-subagent 0.3.4 → 0.3.7

package/README.md

@@ -79,8 +79,9 @@ Built-in agents are only used as a fallback when **all three** locations are emp
 ---
 name: writer
 description: Expert technical writer
-model: anthropic/claude-3-5-sonnet
 thinking: low
+first-layer: enabled
+last-layer: disabled
 tools: read,write
 ---
 
@@ -93,9 +94,11 @@ You are an expert technical writer focused on clarity and conciseness.
 | ------------- | -------- | -------------------- | -------------------------------------------------------- |
 | `name`        | Yes      | —                    | Agent identifier used in tool calls                      |
 | `description` | Yes      | —                    | What the agent does (shown to the main agent)            |
-| `model`       | No       | Pi default           | Override model, e.g. `anthropic/claude-3-5-sonnet`       |
+| `model`       | No       | Current parent model | Legacy fallback only when live parent model context is unavailable |
 | `thinking`    | No       | Pi default           | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`       |
 | `tools`       | No       | `read,bash,edit,write` | Comma-separated built-in tools                         |
+| `first-layer` | No       | `enabled`            | Set to `disabled` to hide/block this agent at depth 1    |
+| `last-layer`  | No       | `enabled`            | Set to `disabled` to hide/block this agent at max depth  |
 
 Available tools: `read`, `bash`, `edit`, `write`.
 
@@ -103,7 +106,7 @@ The Markdown body becomes the agent's system prompt (appended to Pi's default, n
 
 ## Delegation Guards
 
-Depth and cycle guards prevent runaway recursive delegation.
+Depth and cycle guards prevent runaway recursive delegation. Layer availability is evaluated for the child being launched: depth 1 is the first layer, and `PI_SUBAGENT_MAX_DEPTH` is the last layer. The bundled `team-lead` agent sets `last-layer: disabled` so it cannot consume the final delegation layer.
 
 | Config                         | Default | Description                                      |
 | ------------------------------ | ------- | ------------------------------------------------ |
@@ -138,6 +141,8 @@ While a `subagents` tool call is running, mid-stream steering input can be broad
 
 ## Subagent Session Resume
 
+> Requires Pi **0.81.0 or newer**. Crash recovery uses Pi's public full Provider SDK and session-replacement lifecycle.
+
 Subagent subprocesses save sessions in `sessions-subagents`. When a main Pi session is resumed and its latest branch contains an unfinished `subagents` tool call (aborted, errored, or closed by Pi's synthetic unfinished-tool error), the extension can resume that delegation from the saved subagent sessions.
 
 The same detection also runs after navigating the session tree in the TUI (Esc navigation): if you jump back to a point whose branch ends in an unfinished `subagents` call, the extension offers to resume those subagents from their saved sessions.
@@ -146,6 +151,8 @@ The same detection also runs after navigating the session tree in the TUI (Esc n
 - Non-UI modes (`pi -p`, JSON/RPC) resume automatically.
 - Already-finished subagents are reused as completed; unfinished ones continue from their own saved sessions.
 - Nested subagents use the same mechanism recursively.
+- Provider fallback goes through the selected model's effective Pi provider, so custom providers, custom APIs, auth-derived endpoints, headers, and provider-scoped environment are preserved.
+- Pending resume state and delayed callbacks are discarded on `/resume`, `/new`, `/fork`, and `/reload`, preventing stale work from an old runtime from leaking into the replacement session.
 
 | Env Var | Default | Description |
 | --- | --- | --- |
@@ -211,8 +218,7 @@ subagent *instance* by its unique name.
 ## CLI Argument Proxying
 
 Flags passed to the parent `pi` process are forwarded to subagent child
-processes, so they inherit the same provider, API key, model, and other runtime settings. Flags the
-extension manages itself are blocked from being forwarded.
+processes, so they inherit the same provider, API key, and other runtime settings. At every new launch, the extension explicitly passes the parent's currently active model; changing `/model` mid-conversation therefore affects all subsequently started subagents. Flags the extension manages itself are blocked from being forwarded.
 
 **Always forwarded verbatim:**
 
@@ -233,7 +239,7 @@ extension manages itself are blocked from being forwarded.
 
 | Flag | Overridden by |
 | --- | --- |
-| `--model` | `model:` in agent frontmatter |
+| `--model` | Replaced at launch by the parent's currently active model (`model:` is only a no-context compatibility fallback) |
 | `--thinking` | `thinking:` in agent frontmatter |
 | `--tools` / `--no-tools` | `tools:` in agent frontmatter |
 

package/agents/team-lead.md

@@ -1,6 +1,7 @@
 ---
 name: team-lead
 description: "A team of agents with different specializations that can take any complex task, split it into parts, and implement architecture, generation, review, or any other kind of task."
+last-layer: disabled
 ---
 
 You are an experienced team lead, focused on tasks management. You don't do any work yourself. You delegate.

package/agents.ts

@@ -24,6 +24,10 @@ export interface AgentConfig {
 	tools?: string[];
 	model?: string;
 	thinking?: string;
+	/** Whether this agent may be launched at delegation depth 1 (default: true). */
+	firstLayer?: boolean;
+	/** Whether this agent may be launched at the maximum delegation depth (default: true). */
+	lastLayer?: boolean;
 	systemPrompt: string;
 	source: AgentSource;
 	filePath: string;
@@ -63,8 +67,25 @@ function findNearestProjectAgentsDir(cwd: string): string | null {
 	}
 }
 
+function parseLayerSetting(
+	value: unknown,
+	field: "first-layer" | "last-layer",
+	filePath: string,
+): boolean {
+	if (value === undefined) return true;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "enabled") return true;
+		if (normalized === "disabled") return false;
+	}
+	console.warn(
+		`[pi-subagent] Ignoring invalid ${field} field in "${filePath}". Expected enabled or disabled.`,
+	);
+	return true;
+}
+
 /** Parse a single agent markdown file into an AgentConfig. Returns null on skip. */
-function parseAgentFile(filePath: string, source: AgentSource): AgentConfig | null {
+export function parseAgentFile(filePath: string, source: AgentSource): AgentConfig | null {
 	let content: string;
 	try {
 		content = fs.readFileSync(filePath, "utf-8");
@@ -113,6 +134,8 @@ function parseAgentFile(filePath: string, source: AgentSource): AgentConfig | nu
 		tools,
 		model: typeof frontmatter.model === "string" ? frontmatter.model : undefined,
 		thinking: typeof frontmatter.thinking === "string" ? frontmatter.thinking : undefined,
+		firstLayer: parseLayerSetting(frontmatter["first-layer"], "first-layer", filePath),
+		lastLayer: parseLayerSetting(frontmatter["last-layer"], "last-layer", filePath),
 		systemPrompt: body,
 		source,
 		filePath,
@@ -161,6 +184,17 @@ function dedupeAgents(
 // Public API
 // ---------------------------------------------------------------------------
 
+/** Whether an agent is available to be launched at the requested child depth. */
+export function isAgentEnabledAtLayer(
+	agent: AgentConfig,
+	targetDepth: number,
+	maxDepth: number,
+): boolean {
+	if (targetDepth === 1 && agent.firstLayer === false) return false;
+	if (targetDepth === maxDepth && agent.lastLayer === false) return false;
+	return true;
+}
+
 /**
  * Discover all available agents according to the requested scope.
  *

package/index.ts

@@ -10,13 +10,15 @@
 
 import * as fs from "node:fs";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { createFauxCore, fauxAssistantMessage, fauxToolCall } from "@mariozechner/pi-ai";
-// The synthetic resume provider forwards to the real fallback model through a
-// small dispatcher built on stable pi-ai exports. This deliberately avoids the
-// deprecated/temporary `@mariozechner/pi-ai/compat` global `streamSimple`.
-import { streamSimpleForModel as streamModelSimple } from "./resumeStream.js";
+import {
+  createFauxCore,
+  createProvider,
+  fauxAssistantMessage,
+  fauxToolCall,
+  lazyStream,
+} from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
-import { type AgentConfig, discoverAgents } from "./agents.js";
+import { type AgentConfig, discoverAgents, isAgentEnabledAtLayer } from "./agents.js";
 import {
   allocateSubagentNames,
   clearResumeActive,
@@ -98,6 +100,38 @@ const SUBAGENT_STACK_ENV = "PI_SUBAGENT_STACK";
 const SUBAGENT_PREVENT_CYCLES_ENV = "PI_SUBAGENT_PREVENT_CYCLES";
 const SUBAGENT_CONFIRM_PROJECT_AGENTS_ENV = "PI_SUBAGENT_CONFIRM_PROJECT_AGENTS";
 
+const BASE_SUBAGENTS_TOOL_DESCRIPTION = [
+  "Delegate work to specialized subagents running as isolated pi processes.",
+  "",
+  "Pass a `tasks` array. Every task in the same call runs IN PARALLEL.",
+  "  - 1 task  -> single delegation",
+  "  - N tasks -> all N run concurrently in one call",
+  "",
+  "For sequential work (task B depends on task A's output), make separate",
+  "tool calls one after another. Do NOT put dependent tasks in the same array.",
+  "",
+  'Single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }] }',
+  'Parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }] }',
+].join("\n");
+
+const GPT_56_SUBAGENT_GUIDANCE =
+  "Be careful with subagents: use them when the user explicitly asks or when they are truly necessary, because they are expensive. Good cases: running several exploration tasks in parallel, solving several tasks in parallel, or delegating several large tasks to separate subagents. Bad cases (don't do this): creating many nested subagents with similar tasks, using sequential subagents for simple short tasks, running a subagent just to read a file or execute a bash command, or delegating work that does not need a team or parallel execution (unless the user asked you to).";
+
+export function isGpt56Model(model: unknown): boolean {
+  if (typeof model === "string") return model.toLowerCase().includes("gpt-5.6");
+  if (!model || typeof model !== "object") return false;
+  const candidate = model as { id?: unknown; name?: unknown };
+  return [candidate.id, candidate.name].some(
+    (value) => typeof value === "string" && value.toLowerCase().includes("gpt-5.6"),
+  );
+}
+
+export function getSubagentsToolDescription(model?: unknown): string {
+  return isGpt56Model(model)
+    ? `${BASE_SUBAGENTS_TOOL_DESCRIPTION}\n\n${GPT_56_SUBAGENT_GUIDANCE}`
+    : BASE_SUBAGENTS_TOOL_DESCRIPTION;
+}
+
 type ProjectAgentConfirmationSetting = "ask" | "never" | "session";
 type ProjectAgentApproval = "once" | "session" | "no";
 
@@ -385,6 +419,15 @@ function makeDetailsFactory(
   };
 }
 
+function filterAgentsForCurrentLayer(
+  agents: AgentConfig[],
+  currentDepth: number,
+  maxDepth: number,
+): AgentConfig[] {
+  const targetDepth = currentDepth + 1;
+  return agents.filter((agent) => isAgentEnabledAtLayer(agent, targetDepth, maxDepth));
+}
+
 function formatAgentNames(agents: AgentConfig[]): string {
   return agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
 }
@@ -562,7 +605,6 @@ function isStreamingSteerInput(event: any, ctx: { isIdle: () => boolean }): bool
   return !ctx.isIdle();
 }
 
-const RESUME_STATE_KEY = "__piSubagentResumeState";
 const SUBAGENT_FALLBACK_MODEL_ENV = "PI_SUBAGENT_FALLBACK_MODEL";
 const RESUME_INTERACTIVE_DELAY_MS = 50;
 
@@ -572,21 +614,6 @@ type SyntheticResumeState = {
   trigger: "resumePrompt" | "nextRequest";
 };
 
-function clearSyntheticResumeState(): void {
-  const state = getSyntheticResumeState();
-  state.plans = [];
-  state.phase = "tool";
-  state.trigger = "resumePrompt";
-}
-
-function getSyntheticResumeState(): SyntheticResumeState {
-  const g = globalThis as any;
-  if (!g[RESUME_STATE_KEY]) {
-    g[RESUME_STATE_KEY] = { plans: [], phase: "tool", trigger: "resumePrompt" } satisfies SyntheticResumeState;
-  }
-  return g[RESUME_STATE_KEY] as SyntheticResumeState;
-}
-
 // Model definition for the synthetic subagent-resume provider. Shared between
 // the faux core (which produces the canned assistant turn) and the provider
 // registration below.
@@ -654,6 +681,25 @@ function getRestorableModel(ctx: any): any | undefined {
   return findLastNonResumeModel(ctx) ?? getEnvFallbackModel(ctx);
 }
 
+/**
+ * Pick the parent model inherited by a subagent launch.
+ *
+ * A normal tool call was emitted by the current model, so that model is the
+ * authoritative choice. Looking backward in the session is only appropriate
+ * while our own synthetic resume model is active (or no current model exists).
+ */
+export function selectParentModelForSubagent(
+  currentModel: any | undefined,
+  modelBeforeSynthetic: any | undefined,
+  historicalRealModel: any | undefined,
+  lastRestorableModel: any | undefined,
+): any | undefined {
+  if (currentModel?.provider && currentModel.provider !== RESUME_PROVIDER) {
+    return currentModel;
+  }
+  return modelBeforeSynthetic ?? historicalRealModel ?? lastRestorableModel;
+}
+
 // ---------------------------------------------------------------------------
 // Extension entry point
 // ---------------------------------------------------------------------------
@@ -663,23 +709,116 @@ export default function (pi: ExtensionAPI) {
   let lastRestorableModel: any | undefined;
   let latestSessionCtx: any | undefined;
   let pendingInteractiveResumePrompt: string | null = null;
+  let lifecycleGeneration = 0;
+  let sessionActive = false;
+  const scheduledTasks = new Set<ReturnType<typeof setTimeout>>();
+  const resumeState: SyntheticResumeState = {
+    plans: [],
+    phase: "tool",
+    trigger: "resumePrompt",
+  };
+
+  function clearSyntheticResumeState(): void {
+    resumeState.plans = [];
+    resumeState.phase = "tool";
+    resumeState.trigger = "resumePrompt";
+  }
 
-  async function streamWithRealModelFallback(context: any, options: any, fallback: any) {
-    if (!fallback) return null;
-    const auth = resumeModelRegistry
-      ? await resumeModelRegistry.getApiKeyAndHeaders(fallback)
-      : { ok: true, apiKey: undefined, headers: undefined };
-    if (!auth.ok) {
-      throw new Error(auth.error);
+  function getParentModelForSubagent(ctx: any): any | undefined {
+    const currentModel = ctx?.model;
+    // Avoid historical lookup during normal calls: the current assistant
+    // response is the one that emitted the subagents tool call.
+    if (currentModel?.provider && currentModel.provider !== RESUME_PROVIDER) {
+      return currentModel;
     }
-    return streamModelSimple(fallback, context, {
-      ...options,
-      apiKey: auth.apiKey,
-      headers: auth.headers,
+    return selectParentModelForSubagent(
+      currentModel,
+      modelToRestoreAfterResume,
+      findLastNonResumeModel(ctx) ?? getEnvFallbackModel(ctx),
+      lastRestorableModel,
+    );
+  }
+
+  function scheduleSessionTask(callback: () => void, delayMs: number): void {
+    const expectedGeneration = lifecycleGeneration;
+    const timer = setTimeout(() => {
+      scheduledTasks.delete(timer);
+      if (!sessionActive || expectedGeneration !== lifecycleGeneration) return;
+      callback();
+    }, delayMs);
+    scheduledTasks.add(timer);
+  }
+
+  function mergeProviderHeaders(
+    base: Record<string, string | null> | undefined,
+    override: Record<string, string | null> | undefined,
+  ): Record<string, string | null> | undefined {
+    const merged = new Map<string, [string, string | null]>();
+    for (const headers of [base, override]) {
+      for (const [name, value] of Object.entries(headers ?? {})) {
+        const key = name.toLowerCase();
+        if (value === null) merged.delete(key);
+        else merged.set(key, [name, value]);
+      }
+    }
+    return merged.size > 0 ? Object.fromEntries(merged.values()) : undefined;
+  }
+
+  function streamWithRealModelFallback(
+    context: any,
+    options: any,
+    fallback: any,
+    expectedGeneration = lifecycleGeneration,
+  ) {
+    if (!fallback || !resumeModelRegistry) return null;
+
+    // Use pi 0.81's effective Provider instead of dispatching on model.api.
+    // This preserves custom provider streams, provider composition, dynamic
+    // auth base URLs, provider-scoped env, and future/custom API identifiers.
+    return lazyStream(fallback, async () => {
+      if (!sessionActive || expectedGeneration !== lifecycleGeneration) {
+        throw new Error("Subagent resume fallback was cancelled by session replacement.");
+      }
+      const provider = resumeModelRegistry.getProvider?.(fallback.provider);
+      if (!provider || provider.id === RESUME_PROVIDER) {
+        throw new Error(`Subagent resume fallback provider is unavailable: ${fallback.provider}.`);
+      }
+      const [providerResolution, modelResolution] = await Promise.all([
+        resumeModelRegistry.getProviderAuth?.(fallback.provider),
+        resumeModelRegistry.getApiKeyAndHeaders?.(fallback),
+      ]);
+      if (!sessionActive || expectedGeneration !== lifecycleGeneration) {
+        throw new Error("Subagent resume fallback was cancelled by session replacement.");
+      }
+      if (!providerResolution || !modelResolution?.ok) {
+        throw new Error(
+          modelResolution?.error ?? `Provider is not configured: ${fallback.provider}`,
+        );
+      }
+      const providerAuth = providerResolution.auth ?? {};
+      const requestModel = providerAuth.baseUrl
+        ? { ...fallback, baseUrl: providerAuth.baseUrl }
+        : fallback;
+      const requestOptions = {
+        ...options,
+        // Model-aware resolution includes configured/model headers. Never
+        // forward the synthetic provider's no-op credential.
+        apiKey: modelResolution.apiKey,
+        headers: mergeProviderHeaders(modelResolution.headers, options?.headers),
+        env: {
+          ...(providerResolution.env ?? {}),
+          ...(modelResolution.env ?? {}),
+          ...(options?.env ?? {}),
+        },
+      };
+      return provider.streamSimple(requestModel, context, requestOptions);
     });
   }
 
-  async function restoreVisibleModelForResume(): Promise<any | undefined> {
+  async function restoreVisibleModelForResume(
+    expectedGeneration = lifecycleGeneration,
+  ): Promise<any | undefined> {
+    if (!sessionActive || expectedGeneration !== lifecycleGeneration) return undefined;
     const restore = modelToRestoreAfterResume ?? lastRestorableModel;
     if (!restore) return undefined;
     lastRestorableModel = restore;
@@ -687,7 +826,9 @@ export default function (pi: ExtensionAPI) {
       try {
         await pi.setModel(restore);
       } catch (err) {
-        console.error("[pi-subagent] Failed to restore real model during resume:", err);
+        if (sessionActive && expectedGeneration === lifecycleGeneration) {
+          console.error("[pi-subagent] Failed to restore real model during resume:", err);
+        }
       }
     }
     return restore;
@@ -712,12 +853,26 @@ export default function (pi: ExtensionAPI) {
     models: [RESUME_MODEL_DEF],
   });
 
-  pi.registerProvider(RESUME_PROVIDER, {
-    baseUrl: "http://127.0.0.1/pi-subagent-resume",
-    api: "openai-responses",
-    apiKey: "pi-subagent-resume-noop-key",
-    streamSimple: async (model, context, options) => {
-      const state = getSyntheticResumeState();
+  const resumeProvider = createProvider({
+    id: RESUME_PROVIDER,
+    name: "Pi Subagent Resume",
+    auth: {
+      apiKey: {
+        name: "Internal synthetic resume provider",
+        async resolve() {
+          return {
+            auth: { apiKey: "pi-subagent-resume-noop-key" },
+            source: "internal synthetic provider",
+          };
+        },
+      },
+    },
+    models: resumeCore.models,
+    api: {
+      stream: resumeCore.stream,
+      streamSimple: (model, context, options) => {
+      const state = resumeState;
+      const expectedGeneration = lifecycleGeneration;
       const discoveredPlans = state.plans.length > 0
         ? state.plans
         : pendingResumePlans.length > 0
@@ -759,7 +914,7 @@ export default function (pi: ExtensionAPI) {
           .result()
           .catch(() => {})
           .finally(() => {
-            void restoreVisibleModelForResume();
+            void restoreVisibleModelForResume(expectedGeneration);
           });
         return stream;
       }
@@ -768,14 +923,28 @@ export default function (pi: ExtensionAPI) {
       // injection turn (e.g. a request raced ahead of the model restore).
       // Forward the request to the real fallback model instead.
       if (phase === "final") {
-        const restore = await restoreVisibleModelForResume();
-        const delegated = await streamWithRealModelFallback(context, options, restore);
-        if (delegated) return delegated;
+        const delegated = streamWithRealModelFallback(
+          context,
+          options,
+          modelToRestoreAfterResume ?? lastRestorableModel,
+          expectedGeneration,
+        );
+        if (delegated) {
+          void restoreVisibleModelForResume(expectedGeneration);
+          return delegated;
+        }
       }
 
-      const restore = await restoreVisibleModelForResume();
-      const fallback = await streamWithRealModelFallback(context, options, restore ?? lastRestorableModel);
-      if (fallback) return fallback;
+      const fallback = streamWithRealModelFallback(
+        context,
+        options,
+        modelToRestoreAfterResume ?? lastRestorableModel,
+        expectedGeneration,
+      );
+      if (fallback) {
+        void restoreVisibleModelForResume(expectedGeneration);
+        return fallback;
+      }
 
       // No real model to fall back to: surface a clear error turn.
       if (!(plans.length > 0 && phase === "tool")) {
@@ -788,9 +957,10 @@ export default function (pi: ExtensionAPI) {
         () => fauxAssistantMessage([], { stopReason: "error", errorMessage: errorText }),
       ]);
       return resumeCore.streamSimple(model, context, options);
+      },
     },
-    models: [{ ...RESUME_MODEL_DEF, api: "openai-responses" }],
   });
+  pi.registerProvider(resumeProvider);
 
   const depthConfig = resolveDelegationDepthConfig(pi);
   const { currentDepth, maxDepth, canDelegate, ancestorAgentStack, preventCycles } =
@@ -1178,6 +1348,7 @@ export default function (pi: ExtensionAPI) {
   }
 
   async function restoreModelAfterResumeFailure(ctx?: { ui?: { notify?: (message: string, type?: "info" | "warning" | "error") => void } }) {
+    if (!sessionActive) return;
     const restore = modelToRestoreAfterResume;
     modelToRestoreAfterResume = undefined;
     pendingResumePlans = [];
@@ -1221,7 +1392,14 @@ export default function (pi: ExtensionAPI) {
 
   // Auto-discover agents on session start
   pi.on("session_start", async (event, ctx) => {
+    lifecycleGeneration += 1;
+    sessionActive = true;
     latestSessionCtx = ctx;
+    resumeModelRegistry = ctx.modelRegistry;
+    clearSyntheticResumeState();
+    pendingResumePlans = [];
+    pendingInteractiveResumePrompt = null;
+    modelToRestoreAfterResume = undefined;
     updateCombinedUsageStatus(ctx);
     try {
       // Always repair sessions left on the synthetic resume model, even in
@@ -1239,7 +1417,7 @@ export default function (pi: ExtensionAPI) {
       if (!canDelegate) return;
 
       const discovery = discoverAgents(ctx.cwd, "both");
-      discoveredAgents = discovery.agents;
+      discoveredAgents = filterAgentsForCurrentLayer(discovery.agents, currentDepth, maxDepth);
       currentSessionId = ctx.sessionManager.getSessionId?.() ?? "ephemeral";
       currentSubagentSessionRoot = getDefaultSubagentSessionRoot(ctx);
       if (resumableSubagentsDisabled()) {
@@ -1317,6 +1495,24 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
+  // Pi 0.81 replaces and rebinds the entire extension runtime on /resume,
+  // /new, /fork, and /reload. Invalidate every detached callback so it cannot
+  // use stale pi/context objects after the old runtime has been torn down.
+  pi.on("session_shutdown", () => {
+    sessionActive = false;
+    lifecycleGeneration += 1;
+    for (const timer of scheduledTasks) clearTimeout(timer);
+    scheduledTasks.clear();
+    clearSyntheticResumeState();
+    pendingResumePlans = [];
+    pendingInteractiveResumePrompt = null;
+    modelToRestoreAfterResume = undefined;
+    latestSessionCtx = undefined;
+    resumeModelRegistry = undefined;
+    activeSubagentUsageSummaries.clear();
+    activeSubagents.clear();
+  });
+
   /**
    * Detect unfinished subagent calls at the current branch leaf and offer to
    * resume them. Shared between session_start (startup/resume) and
@@ -1373,7 +1569,6 @@ export default function (pi: ExtensionAPI) {
     }
 
     pendingResumePlans = [...plans];
-    const resumeState = getSyntheticResumeState();
     resumeState.plans = [...plans];
     resumeState.phase = "tool";
     // Headless subprocess/RPC subagents cannot answer a visible resume
@@ -1407,7 +1602,7 @@ export default function (pi: ExtensionAPI) {
       // which is the last extension hook before the initial chat render.
       pendingInteractiveResumePrompt = `Resuming ${totalTaskCount} subagents...`;
     } else {
-      setTimeout(() => {
+      scheduleSessionTask(() => {
         try {
           pi.sendUserMessage(`Resuming ${totalTaskCount} subagents...`);
         } catch (err) {
@@ -1452,7 +1647,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("message_end", (_event, ctx) => {
     latestSessionCtx = ctx;
     updateCombinedUsageStatus(ctx);
-    setTimeout(() => updateCombinedUsageStatus(ctx), 0);
+    scheduleSessionTask(() => updateCombinedUsageStatus(ctx), 0);
   });
 
   pi.on("tool_execution_end", (event, ctx) => {
@@ -1460,7 +1655,7 @@ export default function (pi: ExtensionAPI) {
     if (isSubagentToolName(event.toolName)) {
       activeSubagentUsageSummaries.delete(event.toolCallId);
       updateCombinedUsageStatus(ctx);
-      setTimeout(() => updateCombinedUsageStatus(ctx), 0);
+      scheduleSessionTask(() => updateCombinedUsageStatus(ctx), 0);
     }
   });
 
@@ -1468,7 +1663,7 @@ export default function (pi: ExtensionAPI) {
     const prompt = pendingInteractiveResumePrompt;
     if (!prompt) return;
     pendingInteractiveResumePrompt = null;
-    setTimeout(() => {
+    scheduleSessionTask(() => {
       try {
         pi.sendUserMessage(prompt);
       } catch (err) {
@@ -1571,22 +1766,13 @@ keeping their full previous context:
 
   // Register the subagents tool
   if (canDelegate) {
-    pi.registerTool({
+    let registeredForGpt56 = false;
+    const registerSubagentsTool = (model?: unknown) => {
+      registeredForGpt56 = isGpt56Model(model);
+      pi.registerTool({
       name: SUBAGENT_TOOL_NAME,
       label: "Subagents",
-      description: [
-        "Delegate work to specialized subagents running as isolated pi processes.",
-        "",
-        "Pass a `tasks` array. Every task in the same call runs IN PARALLEL.",
-        "  - 1 task  -> single delegation",
-        "  - N tasks -> all N run concurrently in one call",
-        "",
-        "For sequential work (task B depends on task A's output), make separate",
-        "tool calls one after another. Do NOT put dependent tasks in the same array.",
-        "",
-        'Single:   { tasks: [{ agent: "writer", task: "Rewrite README.md" }] }',
-        'Parallel: { tasks: [{ agent: "writer", task: "..." }, { agent: "tester", task: "..." }] }',
-      ].join("\n"),
+      description: getSubagentsToolDescription(model),
       parameters: SubagentParams,
 
       async execute(toolCallId, params, signal, onUpdate, ctx) {
@@ -1594,7 +1780,7 @@ keeping their full previous context:
           recordToolCallStart(toolCallId);
           updateLatestBroadcastTargets(undefined);
           const discovery = discoverAgents(ctx.cwd, "both");
-          const { agents } = discovery;
+          const agents = filterAgentsForCurrentLayer(discovery.agents, currentDepth, maxDepth);
 
           const makeDetails = makeDetailsFactory(
             discovery.projectAgentsDir,
@@ -1732,7 +1918,8 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
                     return {
                       agent: task.agent,
                       task: task.task,
-                      model: agentConfig?.model,
+                      model:
+                        formatModelFlag(getParentModelForSubagent(ctx)) ?? agentConfig?.model,
                       tools: agentConfig?.tools,
                       sessionDir:
                         resumePlan?.details?.results[index]?.sessionDir ??
@@ -1762,11 +1949,9 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               resumePlan?.details?.results[0],
               getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, 0),
               !!resumePlan,
-              // Prefer the pre-resume model (during resume) or the current
-              // active model (normal runs). This prevents children from
-              // defaulting to whatever settings.json says at spawn time, which
-              // can change while the parent session is long-running.
-              formatModelFlag(modelToRestoreAfterResume ?? ctx.model ?? lastRestorableModel),
+              // Normal calls inherit the model that emitted this tool call;
+              // synthetic resume calls recover the preceding real model.
+              formatModelFlag(getParentModelForSubagent(ctx)),
               topLevelBaseId,
               names[0],
             );
@@ -1782,7 +1967,7 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             resumePlan?.details?.results,
             (index) => getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, index),
             !!resumePlan,
-            formatModelFlag(modelToRestoreAfterResume ?? ctx.model ?? lastRestorableModel),
+            formatModelFlag(getParentModelForSubagent(ctx)),
             topLevelBaseId,
             { names },
           );
@@ -1801,6 +1986,19 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
       renderCall: (args, theme, context) => renderCall(args, theme, context),
       renderResult: (result, { expanded }, theme) =>
         renderResult(result, expanded, theme),
+      });
+    };
+
+    registerSubagentsTool(latestSessionCtx?.model);
+    pi.on("model_select", (event) => {
+      if (registeredForGpt56 !== isGpt56Model(event.model)) {
+        registerSubagentsTool(event.model);
+      }
+    });
+    pi.on("before_agent_start", (_event, ctx) => {
+      if (registeredForGpt56 !== isGpt56Model(ctx.model)) {
+        registerSubagentsTool(ctx.model);
+      }
     });
 
     if (!resumableSubagentsDisabled()) pi.registerTool({
@@ -1982,7 +2180,7 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               undefined,
               (index) => targets[index].sessionDir,
               true,
-              formatModelFlag(modelToRestoreAfterResume ?? ctx.model ?? lastRestorableModel),
+              formatModelFlag(getParentModelForSubagent(ctx)),
               topLevelBaseId,
               { names: targets.map((target) => target.name), rawPrompts: true },
             );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.3.4",
+  "version": "0.3.7",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",
@@ -9,7 +9,6 @@
     "agents.ts",
     "runner.ts",
     "resume.ts",
-    "resumeStream.ts",
     "names.ts",
     "shared.ts",
     "render.ts",
@@ -53,10 +52,10 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@mariozechner/pi-agent-core": ">=0.37.0",
-    "@mariozechner/pi-ai": ">=0.37.0",
-    "@mariozechner/pi-coding-agent": ">=0.37.0",
-    "@mariozechner/pi-tui": ">=0.37.0"
+    "@mariozechner/pi-agent-core": ">=0.81.0",
+    "@mariozechner/pi-ai": ">=0.81.0",
+    "@mariozechner/pi-coding-agent": ">=0.81.0",
+    "@mariozechner/pi-tui": ">=0.81.0"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-agent-core": {

package/runner.ts

@@ -542,6 +542,12 @@ export function processJsonLine(line: string, result: SingleResult): boolean {
 // Build pi CLI arguments
 // ---------------------------------------------------------------------------
 
+export function resolveSubagentModel(agentModel?: string, currentParentModel?: string): string | undefined {
+  // The active parent model is authoritative. Agent frontmatter is retained as
+  // a compatibility fallback only for callers that cannot supply live context.
+  return currentParentModel ?? agentModel ?? process.env[SUBAGENT_FALLBACK_MODEL_ENV] ?? _inheritedCliArgs.fallbackModel;
+}
+
 function buildPiArgs(
   agent: AgentConfig,
   systemPromptPath: string | null,
@@ -561,8 +567,9 @@ function buildPiArgs(
   if (sessionDir) args.push("--session-dir", sessionDir);
   if (resumeSession) args.push("--continue");
 
-  // Agent config takes priority; fall back to parent CLI value
-  const model = agent.model ?? fallbackModelOverride ?? process.env[SUBAGENT_FALLBACK_MODEL_ENV] ?? _inheritedCliArgs.fallbackModel;
+  // Always use the model active in the parent at launch time. This matters
+  // when /model changed after the parent process originally started.
+  const model = resolveSubagentModel(agent.model, fallbackModelOverride);
   if (model) args.push("--model", model);
 
   const thinking = agent.thinking ?? _inheritedCliArgs.fallbackThinking;

package/shims.d.ts

@@ -12,6 +12,7 @@ declare module "@mariozechner/pi-ai" {
   export type Message = any;
 
   export function createAssistantMessageEventStream(): any;
+  export function createProvider(options: any): any;
   export function lazyStream(model: any, setup: () => Promise<any>): any;
   export type AssistantMessageEventStream = any;
   export type ProviderStreams = { stream: (...args: any[]) => any; streamSimple: (...args: any[]) => any };
@@ -90,6 +91,7 @@ declare module "@mariozechner/pi-coding-agent" {
   export interface ExtensionAPI {
     registerFlag(name: string, config: any): void;
     getFlag(name: string): unknown;
+    registerProvider(provider: any): void;
     registerProvider(name: string, provider: any): void;
     registerTool(tool: any): void;
     addBeforeAgentStart(hook: (ctx: ExtensionContext) => unknown): void;

package/resumeStream.ts

@@ -1,104 +0,0 @@
-/**
- * Durable model-streaming helper for the synthetic subagent-resume provider.
- *
- * The synthetic resume provider only ever synthesizes an assistant turn that
- * carries the `subagent` tool call(s). But pi may still invoke the provider's
- * `streamSimple` handler in edge/race situations where the real model has not
- * been restored yet (e.g. a request arrives before `pi.setModel(realModel)`
- * has propagated). In that case the handler must forward the request to the
- * real fallback model and return a valid assistant stream.
- *
- * Historically this used the global `streamSimple` dispatcher exported from the
- * `@mariozechner/pi-ai` package root. Pi's provider/model rework moved that
- * dispatcher into the explicitly temporary `@mariozechner/pi-ai/compat`
- * entrypoint ("deleted with the coding-agent ModelManager migration").
- *
- * This module reimplements the same behavior using only stable pi-ai exports:
- *   - the root `lazyStream` helper (returns a stream synchronously while async
- *     setup runs behind it), and
- *   - the per-API `ProviderStreams` factories published under the stable
- *     `@mariozechner/pi-ai/api/*` subpaths.
- *
- * `model.api` selects the concrete API implementation, mirroring exactly what
- * pi core does when it dispatches a stream to the provider that owns a model.
- */
-import { lazyStream } from "@mariozechner/pi-ai";
-import type { AssistantMessageEventStream, ProviderStreams } from "@mariozechner/pi-ai";
-
-type ProviderStreamsFactory = () => ProviderStreams;
-
-/**
- * Lazily import the `ProviderStreams` factory for a given `model.api`.
- *
- * Each entry maps a `KnownApi` id to its stable `/api/*` subpath module and the
- * factory export that module provides. Dynamic `import()` keeps the API modules
- * out of the hot path until a fallback stream is actually needed, and the
- * host's module cache deduplicates repeated loads.
- */
-const API_LOADERS: Record<string, () => Promise<ProviderStreamsFactory>> = {
-  "openai-responses": async () =>
-    (await import("@mariozechner/pi-ai/api/openai-responses.lazy")).openAIResponsesApi,
-  "openai-completions": async () =>
-    (await import("@mariozechner/pi-ai/api/openai-completions.lazy")).openAICompletionsApi,
-  "azure-openai-responses": async () =>
-    (await import("@mariozechner/pi-ai/api/azure-openai-responses.lazy")).azureOpenAIResponsesApi,
-  "openai-codex-responses": async () =>
-    (await import("@mariozechner/pi-ai/api/openai-codex-responses.lazy")).openAICodexResponsesApi,
-  "anthropic-messages": async () =>
-    (await import("@mariozechner/pi-ai/api/anthropic-messages.lazy")).anthropicMessagesApi,
-  "bedrock-converse-stream": async () =>
-    (await import("@mariozechner/pi-ai/api/bedrock-converse-stream.lazy")).bedrockConverseStreamApi,
-  "google-generative-ai": async () =>
-    (await import("@mariozechner/pi-ai/api/google-generative-ai.lazy")).googleGenerativeAIApi,
-  "google-vertex": async () =>
-    (await import("@mariozechner/pi-ai/api/google-vertex.lazy")).googleVertexApi,
-  "mistral-conversations": async () =>
-    (await import("@mariozechner/pi-ai/api/mistral-conversations.lazy")).mistralConversationsApi,
-  "pi-messages": async () =>
-    (await import("@mariozechner/pi-ai/api/pi-messages.lazy")).piMessagesApi,
-};
-
-const providerStreamsCache = new Map<string, ProviderStreams>();
-
-/** API ids for which the resume fallback can forward to a real model. */
-export function getSupportedResumeFallbackApis(): string[] {
-  return Object.keys(API_LOADERS);
-}
-
-/** Load (and cache) the `ProviderStreams` implementation for a `model.api`. */
-export async function resolveProviderStreams(api: string): Promise<ProviderStreams> {
-  const cached = providerStreamsCache.get(api);
-  if (cached) return cached;
-
-  const loader = API_LOADERS[api];
-  if (!loader) {
-    throw new Error(
-      `Subagent resume cannot forward to fallback model: unsupported model API "${api}". ` +
-        `Supported APIs: ${Object.keys(API_LOADERS).join(", ")}.`,
-    );
-  }
-
-  const factory = await loader();
-  const providerStreams = factory();
-  providerStreamsCache.set(api, providerStreams);
-  return providerStreams;
-}
-
-/**
- * Stream a real fallback model through its owning API implementation.
- *
- * Returns synchronously via `lazyStream`; the async API-module load and the
- * underlying provider request run behind the returned stream. `options` is
- * expected to already carry the resolved `apiKey`/`headers` (the extension
- * resolves those through `ctx.modelRegistry.getApiKeyAndHeaders`).
- */
-export function streamSimpleForModel(
-  model: any,
-  context: any,
-  options: any,
-): AssistantMessageEventStream {
-  return lazyStream(model, async () => {
-    const providerStreams = await resolveProviderStreams(model.api);
-    return providerStreams.streamSimple(model, context, options);
-  });
-}