pi-prompt-template-model 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-03-20
+
+### Added
+- Added delegated prompt execution via direct extension event bus communication with `subagent` (`prompt-template:subagent:*` channels), including delegated custom-message persistence for loop summaries and context carry-forward.
+- Added prompt frontmatter support for `subagent` and `inheritContext`, with `inheritContext: true` mapped to delegated fork context.
+- Fork context preamble is handled by the subagent extension directly (via `DEFAULT_FORK_PREAMBLE` in `types.ts`), applying to all fork-context subagent runs universally.
+- Added runtime delegation override flags: `--subagent`, `--subagent=<name>`, and `--subagent:<name>`.
+- Added live progress widget above editor during delegated subagent runs showing elapsed time, tool count, tokens, current tool, and task preview — matching the native subagent tool card layout.
+- Added styled completion card with task preview, tool call history, expandable output (Ctrl+O), and usage stats footer.
+
+### Changed
+- Updated provider priority for ambiguous bare model IDs to prefer `openai-codex` before `anthropic`, `github-copilot`, and `openrouter`.
+- Updated loop convergence and fresh-summary analysis to account for delegated subagent message payloads.
+
+### Fixed
+- Delegated start-time hangs now fail fast with explicit timeout errors when a subagent run never emits a start signal.
+- Delegated runs no longer treat arbitrary escape-sequence-bearing terminal input as an Esc cancellation signal; only literal Esc cancels.
+- Chain and loop restore paths now use live runtime model/thinking state during cleanup, preventing skipped restore on mid-step failures.
+
 ## [0.6.0] - 2026-03-19
 
 ### Changed

package/README.md

@@ -47,6 +47,14 @@ pi install npm:pi-prompt-template-model
 
 Restart pi to load the extension.
 
+For delegated subagent execution (`subagent` and `inheritContext` frontmatter), install [pi-subagents](https://github.com/nicobailon/pi-subagents/) separately:
+
+```bash
+pi install npm:pi-subagents
+```
+
+pi-subagents is optional — everything else works without it. If you use `subagent: true` in a prompt template without pi-subagents installed, execution fails fast with a clear error.
+
 ## Quick Start
 
 Add `model` (or omit it to inherit the current session model) and optionally `skill` to any prompt template:
@@ -82,6 +90,43 @@ $@
 
 Here `skill: surf` loads `~/.pi/agent/skills/surf/SKILL.md` and injects its content as a context message on the next turn before the agent handles your task. No decision-making, no read tool, just immediate expertise. It's a forcing function for when you know exactly what workflow the agent needs.
 
+## Delegated Subagent Execution
+
+You can delegate a prompt template directly to the `subagent` extension without metaprompted tool-call instructions.
+
+```markdown
+---
+model: anthropic/claude-sonnet-4-20250514
+subagent: true
+---
+Review and simplify this code: $@
+```
+
+`subagent: true` uses the default `worker` agent. To target a specific agent, set a string value:
+
+```markdown
+---
+model: anthropic/claude-sonnet-4-20250514
+subagent: reviewer
+inheritContext: true
+---
+Audit this diff for correctness and edge cases: $@
+```
+
+`inheritContext: true` maps to delegated `context: "fork"`. It is valid only when `subagent` is configured.
+
+Forked subagents receive a default preamble (from the subagent extension's `DEFAULT_FORK_PREAMBLE`) that anchors them to the task and prevents them from continuing the parent conversation.
+
+During execution, a live progress widget appears above the editor showing elapsed time, tool count, token usage, and the current/last tool — matching the native subagent tool card layout. The widget updates in real-time and clears when the run completes, replaced by a styled completion card with task preview, tool call history, output, and usage stats.
+
+You can override delegation at runtime per invocation:
+
+- `--subagent`
+- `--subagent=<name>`
+- `--subagent:<name>`
+
+Runtime flags take precedence for that invocation only. Bare `--subagent` keeps template agent when present, otherwise defaults to `worker`.
+
 ## Frontmatter Fields
 
 | Field | Required | Default | Description |
@@ -90,6 +135,9 @@ Here `skill: surf` loads `~/.pi/agent/skills/surf/SKILL.md` and injects its cont
 | `chain` | Conditional | - | Chain declaration (`step -> step --loop 2`) for orchestration templates; body is ignored |
 | `skill` | No | - | Skill name to inject as next-turn context message |
 | `thinking` | No | - | Thinking level: `off`, `minimal`, `low`, `medium`, `high`, `xhigh` |
+| `subagent` | No | - | Delegate execution to subagent mode (`true` for default `worker`, or explicit agent name string) |
+| `inheritContext` | No | `false` | Only with `subagent`; when `true`, delegates with subagent `context: "fork"` |
+
 | `description` | No | - | Shown in autocomplete |
 | `restore` | No | `true` | Restore previous model and thinking level after response |
 | `fresh` | No | `false` | Collapse context between loop iterations (applies when looping via `--loop` or frontmatter `loop`) |
@@ -469,6 +517,8 @@ Once enabled, the agent sees `run-prompt` in its tool list and can call it with
 ```
 run-prompt({ command: "deslop --loop 5 --fresh" })
 run-prompt({ command: "deslop --loop" })
+run-prompt({ command: "deslop --subagent" })
+run-prompt({ command: "deslop --subagent:reviewer" })
 run-prompt({ command: "chain-prompts analyze -> fix --loop 3" })
 ```
 
@@ -514,4 +564,5 @@ The model switches, a skill context message is injected, the agent responds, and
 - Model restore state is in-memory. Closing pi mid-response loses restore state.
 - Model-less templates are only managed by this extension when they use extension features (for example `skill`, `thinking`, loop flags, or inline `<if-model ...>`). Plain prompt templates without extension features stay with pi's default prompt loader to avoid command conflicts.
 - In chains, model-less steps inherit the chain-start model snapshot, not the immediately previous step model. This is intentional for deterministic behavior.
+- Delegated `subagent` prompts require [pi-subagents](https://github.com/nicobailon/pi-subagents/) (`pi install npm:pi-subagents`).
 - The `run-prompt` tool must be explicitly enabled with `/prompt-tool on` before the agent can use it.

package/args.ts

@@ -11,6 +11,16 @@ export interface LoopFlags {
 	converge: boolean;
 }
 
+export interface SubagentOverride {
+	enabled: true;
+	agent?: string;
+}
+
+export interface SubagentOverrideExtraction {
+	args: string;
+	override?: SubagentOverride;
+}
+
 export function extractLoopCount(argsString: string): LoopExtraction | null {
 	let loopCount: number | null = null;
 	let loopFound = false;
@@ -152,6 +162,58 @@ export function extractLoopFlags(argsString: string): LoopFlags {
 	return { args: cleaned.trim(), fresh, converge: !noConverge };
 }
 
+export function extractSubagentOverride(argsString: string): SubagentOverrideExtraction {
+	let override: SubagentOverride | undefined;
+	const tokensToRemove: Array<{ start: number; end: number }> = [];
+
+	let i = 0;
+	while (i < argsString.length) {
+		const char = argsString[i];
+
+		if (char === '"' || char === "'") {
+			const quote = char;
+			i++;
+			while (i < argsString.length && argsString[i] !== quote) i++;
+			if (i < argsString.length) i++;
+			continue;
+		}
+
+		if (/\s/.test(char)) {
+			i++;
+			continue;
+		}
+
+		const tokenStart = i;
+		while (i < argsString.length && !/\s/.test(argsString[i])) i++;
+		const token = argsString.slice(tokenStart, i);
+
+		if (token === "--subagent") {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			override = { enabled: true };
+			continue;
+		}
+
+		if (token.startsWith("--subagent=") || token.startsWith("--subagent:")) {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			const value = token.includes("=") ? token.slice("--subagent=".length) : token.slice("--subagent:".length);
+			override = value ? { enabled: true, agent: value } : { enabled: true };
+		}
+	}
+
+	if (!override) return { args: argsString.trim() };
+
+	tokensToRemove.sort((a, b) => b.start - a.start);
+	let cleaned = argsString;
+	for (const { start, end } of tokensToRemove) {
+		cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+	}
+
+	return {
+		args: cleaned.trim(),
+		override,
+	};
+}
+
 export function splitByUnquotedSeparator(input: string, separator: string): string[] {
 	const parts: string[] = [];
 	let start = 0;

package/chain-parser.ts

@@ -135,12 +135,13 @@ export function parseChainSteps(args: string): ParsedChainSteps {
 			invalidSegments.push(rawSegment);
 			continue;
 		}
-		const tokens = parseCommandArgs(segment);
+		const { cleanedSegment, loopCount } = extractStepLoopCount(segment);
+		const tokens = parseCommandArgs(cleanedSegment);
 		if (tokens.length === 0) {
 			invalidSegments.push(segment);
 			continue;
 		}
-		steps.push({ name: tokens[0], args: tokens.slice(1) });
+		steps.push({ name: tokens[0], args: tokens.slice(1), loopCount });
 	}
 
 	return { steps, sharedArgs: parseCommandArgs(argsPart), invalidSegments };

package/index.ts

@@ -1,7 +1,7 @@
 import type { Model } from "@mariozechner/pi-ai";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
-import { extractLoopCount, extractLoopFlags, parseCommandArgs } from "./args.js";
+import { extractLoopCount, extractLoopFlags, extractSubagentOverride, parseCommandArgs, type SubagentOverride } from "./args.js";
 import { parseChainSteps, parseChainDeclaration, type ChainStep } from "./chain-parser.js";
 import { generateIterationSummary, didIterationMakeChanges, getIterationEntries } from "./loop-utils.js";
 import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.js";
@@ -9,6 +9,9 @@ import { preparePromptExecution } from "./prompt-execution.js";
 import { buildPromptCommandDescription, loadPromptsWithModel, readSkillContent, resolveSkillPath, type PromptWithModel } from "./prompt-loader.js";
 import { renderSkillLoaded, type SkillLoadedDetails } from "./skill-loaded-renderer.js";
 import { createToolManager } from "./tool-manager.js";
+import { executeSubagentPromptStep } from "./subagent-step.js";
+import { PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.js";
+import { renderDelegatedSubagentResult } from "./subagent-renderer.js";
 
 interface LoopState {
 	currentIteration: number;
@@ -39,6 +42,10 @@ interface ExecutionErrorState {
 	error: unknown;
 }
 
+interface PromptStepResult {
+	changed: boolean;
+}
+
 export default function promptModelExtension(pi: ExtensionAPI) {
 	let prompts = new Map<string, PromptWithModel>();
 	let previousModel: Model<any> | undefined;
@@ -72,6 +79,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	}
 
 	pi.registerMessageRenderer<SkillLoadedDetails>("skill-loaded", renderSkillLoaded);
+	pi.registerMessageRenderer(PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE, renderDelegatedSubagentResult);
 
 	function registerPromptCommand(name: string) {
 		pi.registerCommand(name, {
@@ -172,6 +180,78 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		}
 	}
 
+	function shouldDelegatePrompt(prompt: PromptWithModel, override?: SubagentOverride): boolean {
+		return prompt.subagent !== undefined || override?.enabled === true;
+	}
+
+	async function executePromptStep(
+		prompt: PromptWithModel,
+		args: string[],
+		ctx: ExtensionCommandContext,
+		currentModel: Model<any> | undefined,
+		override?: SubagentOverride,
+		inheritedModel?: Model<any>,
+	): Promise<PromptStepResult | "aborted"> {
+		if (shouldDelegatePrompt(prompt, override)) {
+			const delegated = await executeSubagentPromptStep({
+				pi,
+				prompt,
+				args,
+				ctx,
+				currentModel,
+				override,
+				inheritedModel,
+			});
+			if (!delegated) {
+				throw new Error(`Prompt \`${prompt.name}\` is not configured for delegated execution.`);
+			}
+			return { changed: delegated.changed };
+		}
+
+		const prepared =
+			inheritedModel === undefined
+				? await preparePromptExecution(prompt, args, currentModel, ctx.modelRegistry)
+				: await preparePromptExecution(prompt, args, currentModel, ctx.modelRegistry, { inheritedModel });
+		if (!prepared) {
+			notify(ctx, `No available model from: ${prompt.models.join(", ")}`, "error");
+			return "aborted";
+		}
+		if ("message" in prepared) {
+			if (prepared.warning) notify(ctx, prepared.warning, "warning");
+			notify(ctx, prepared.message, "error");
+			return "aborted";
+		}
+		if (prepared.warning) {
+			notify(ctx, prepared.warning, "warning");
+		}
+
+		const skillResolution = resolveSkillMessage(prompt.skill, ctx.cwd);
+		if (skillResolution.kind === "error") {
+			notify(ctx, skillResolution.error, "error");
+			return "aborted";
+		}
+
+		if (!prepared.selectedModel.alreadyActive) {
+			const switched = await pi.setModel(prepared.selectedModel.model);
+			if (!switched) {
+				notify(ctx, `Failed to switch to model ${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`, "error");
+				return "aborted";
+			}
+			runtimeModel = prepared.selectedModel.model;
+		}
+
+		if (prompt.thinking) {
+			pi.setThinkingLevel(prompt.thinking);
+		}
+		pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
+
+		const startId = ctx.sessionManager.getLeafId();
+		pi.sendUserMessage(prepared.content);
+		await waitForTurnStart(ctx);
+		await ctx.waitForIdle();
+		return { changed: didIterationMakeChanges(getIterationEntries(ctx, startId)) };
+	}
+
 	async function restoreSessionState(
 		ctx: ExtensionContext,
 		originalModel: Model<any> | undefined,
@@ -291,6 +371,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		freshFlag: boolean,
 		converge: boolean,
 		ctx: ExtensionCommandContext,
+		subagentOverride?: SubagentOverride,
 	) {
 		refreshPrompts(ctx.cwd, ctx);
 		const initialPrompt = prompts.get(name);
@@ -331,51 +412,24 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					break;
 				}
 
-				const prepared = await preparePromptExecution(prompt, parseCommandArgs(cleanedArgs), currentModel, ctx.modelRegistry);
-				if (!prepared) {
-					notify(ctx, `No available model from: ${prompt.models.join(", ")}`, "error");
-					break;
-				}
-				if ("message" in prepared) {
-					if (prepared.warning) notify(ctx, prepared.warning, "warning");
-					notify(ctx, prepared.message, "error");
-					break;
-				}
-				if (prepared.warning) {
-					notify(ctx, prepared.warning, "warning");
-				}
-
-				const skillResolution = resolveSkillMessage(prompt.skill, ctx.cwd);
-				if (skillResolution.kind === "error") {
-					notify(ctx, skillResolution.error, "error");
-					break;
-				}
-
-				if (!prepared.selectedModel.alreadyActive) {
-					const switched = await pi.setModel(prepared.selectedModel.model);
-					if (!switched) {
-						notify(ctx, `Failed to switch to model ${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`, "error");
-						break;
-					}
-					runtimeModel = prepared.selectedModel.model;
-				}
-				currentModel = prepared.selectedModel.model;
-				currentThinking = pi.getThinkingLevel();
-
-				if (prompt.thinking) {
-					pi.setThinkingLevel(prompt.thinking);
-					currentThinking = pi.getThinkingLevel();
-				}
-
-				pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
 				const iterationStartId = ctx.sessionManager.getLeafId();
+				const stepResult = await executePromptStep(
+					prompt,
+					parseCommandArgs(cleanedArgs),
+					ctx,
+					currentModel,
+					subagentOverride,
+				);
+				if (stepResult === "aborted") break;
 
-				pi.sendUserMessage(prepared.content);
-				await waitForTurnStart(ctx);
-				await ctx.waitForIdle();
+				currentModel = getCurrentModel(ctx);
+				currentThinking = pi.getThinkingLevel();
 				completedIterations++;
 
-				if (useConverge && (isUnlimited || effectiveMax > 1) && !didIterationMakeChanges(getIterationEntries(ctx, iterationStartId))) {
+				const iterationChanged = shouldDelegatePrompt(prompt, subagentOverride)
+					? stepResult.changed
+					: didIterationMakeChanges(getIterationEntries(ctx, iterationStartId));
+				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
 					converged = true;
 					break;
 				}
@@ -398,8 +452,8 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				shouldRestore,
 				savedModel,
 				savedThinking,
-				currentModel,
-				currentThinking,
+				getCurrentModel(ctx),
+				pi.getThinkingLevel(),
 				loopErrorState,
 				"loop",
 			);
@@ -428,6 +482,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		converge: boolean,
 		shouldRestore: boolean,
 		ctx: ExtensionCommandContext,
+		subagentOverride?: SubagentOverride,
 	) {
 		const validateChainSteps = (): boolean => {
 			const missingTemplates = steps.filter((step) => !prompts.has(step.name));
@@ -481,13 +536,13 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					if (!validateChainSteps()) break;
 				}
 
-				const iterationStartId = ctx.sessionManager.getLeafId();
 				const templates = steps.map((step) => ({
 					...prompts.get(step.name)!,
 					stepArgs: step.args,
 					stepLoop: step.loopCount ?? 1,
 				}));
 				let aborted = false;
+				let iterationChanged = false;
 
 				for (const [index, template] of templates.entries()) {
 					const stepNumber = index + 1;
@@ -515,63 +570,28 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 							const iterSuffix = stepLoop > 1 ? ` (iter ${stepIteration + 1}/${stepLoop})` : "";
 							notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: ${template.name}${iterSuffix} ${buildPromptCommandDescription(template)}`, "info");
 
-							const prepared = await preparePromptExecution(template, effectiveArgs, currentModel, ctx.modelRegistry, {
-								inheritedModel: chainInheritedModel,
-							});
-							if (!prepared) {
-								notify(
-									ctx,
-									`Step ${stepNumber}/${templates.length} failed: no available model from ${template.models.join(", ")}`,
-									"error",
-								);
-								aborted = true;
-								break;
-							}
-							if ("message" in prepared) {
-								if (prepared.warning) notify(ctx, prepared.warning, "warning");
-								notify(ctx, `Step ${stepNumber}/${templates.length} failed: ${prepared.message}`, "error");
-								aborted = true;
-								break;
-							}
-							if (prepared.warning) {
-								notify(ctx, prepared.warning, "warning");
-							}
-
-							const skillResolution = resolveSkillMessage(template.skill, ctx.cwd);
-							if (skillResolution.kind === "error") {
-								notify(ctx, `Step ${stepNumber}/${templates.length} failed: ${skillResolution.error}`, "error");
+							const stepIterationStartId = ctx.sessionManager.getLeafId();
+							const stepResult = await executePromptStep(
+								template,
+								effectiveArgs,
+								ctx,
+								currentModel,
+								subagentOverride,
+								chainInheritedModel,
+							);
+							if (stepResult === "aborted") {
 								aborted = true;
 								break;
 							}
 
-							if (!prepared.selectedModel.alreadyActive) {
-								const switched = await pi.setModel(prepared.selectedModel.model);
-								if (!switched) {
-									notify(
-										ctx,
-										`Step ${stepNumber}/${templates.length} failed: could not switch to ${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`,
-										"error",
-									);
-									aborted = true;
-									break;
-								}
-								runtimeModel = prepared.selectedModel.model;
-							}
-
-							currentModel = prepared.selectedModel.model;
+							currentModel = getCurrentModel(ctx);
 							currentThinking = pi.getThinkingLevel();
-							if (template.thinking) {
-								pi.setThinkingLevel(template.thinking);
-								currentThinking = pi.getThinkingLevel();
-							}
-							pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
-
-							const stepIterationStartId = ctx.sessionManager.getLeafId();
-							pi.sendUserMessage(prepared.content);
-							await waitForTurnStart(ctx);
-							await ctx.waitForIdle();
 
-							if (stepLoop > 1 && template.converge !== false && !didIterationMakeChanges(getIterationEntries(ctx, stepIterationStartId))) {
+							const stepChanged = shouldDelegatePrompt(template, subagentOverride)
+								? stepResult.changed
+								: didIterationMakeChanges(getIterationEntries(ctx, stepIterationStartId));
+							if (stepChanged) iterationChanged = true;
+							if (stepLoop > 1 && template.converge !== false && !stepChanged) {
 								break;
 							}
 						}
@@ -588,7 +608,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				if (aborted) break;
 				completedIterations++;
 
-				if (useConverge && (isUnlimited || effectiveMax > 1) && !didIterationMakeChanges(getIterationEntries(ctx, iterationStartId))) {
+				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
 					converged = true;
 					break;
 				}
@@ -612,8 +632,8 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				shouldRestore,
 				originalModel,
 				originalThinking,
-				currentModel,
-				currentThinking,
+				getCurrentModel(ctx),
+				pi.getThinkingLevel(),
 				chainErrorState,
 				"chain",
 			);
@@ -644,12 +664,15 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			return;
 		}
 
+		const subagent = extractSubagentOverride(args);
+		const argsWithoutSubagent = subagent.args;
+
 		if (prompt.chain) {
-			const loop = extractLoopCount(args);
+			const loop = extractLoopCount(argsWithoutSubagent);
 			let totalIterations: number | null = prompt.loop ?? 1;
 			let fresh = false;
 			let converge = true;
-			let cleanedArgs = args;
+			let cleanedArgs = argsWithoutSubagent;
 
 			if (loop) {
 				totalIterations = loop.loopCount;
@@ -657,7 +680,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				converge = loop.converge;
 				cleanedArgs = loop.args;
 			} else if (prompt.loop !== undefined) {
-				const flags = extractLoopFlags(args);
+				const flags = extractLoopFlags(argsWithoutSubagent);
 				fresh = flags.fresh;
 				converge = flags.converge;
 				cleanedArgs = flags.args;
@@ -681,68 +704,44 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				converge && prompt.converge !== false,
 				prompt.restore,
 				ctx,
+				subagent.override,
 			);
 			return;
 		}
 
-		const loop = extractLoopCount(args);
+		const loop = extractLoopCount(argsWithoutSubagent);
 		if (loop) {
-			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx);
+			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override);
 			return;
 		}
 
 		if (prompt.loop !== undefined) {
-			const flags = extractLoopFlags(args);
-			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx);
+			const flags = extractLoopFlags(argsWithoutSubagent);
+			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override);
 			return;
 		}
 
 		const savedModel = getCurrentModel(ctx);
 		const savedThinking = pi.getThinkingLevel();
-		const prepared = await preparePromptExecution(prompt, parseCommandArgs(args), savedModel, ctx.modelRegistry);
-		if (!prepared) {
-			notify(ctx, `No available model from: ${prompt.models.join(", ")}`, "error");
-			return;
-		}
-		if ("message" in prepared) {
-			if (prepared.warning) notify(ctx, prepared.warning, "warning");
-			notify(ctx, prepared.message, "error");
-			return;
-		}
-		if (prepared.warning) {
-			notify(ctx, prepared.warning, "warning");
-		}
-
-		const skillResolution = resolveSkillMessage(prompt.skill, ctx.cwd);
-		if (skillResolution.kind === "error") {
-			notify(ctx, skillResolution.error, "error");
-			return;
-		}
+		const stepResult = await executePromptStep(
+			prompt,
+			parseCommandArgs(argsWithoutSubagent),
+			ctx,
+			savedModel,
+			subagent.override,
+		);
+		if (stepResult === "aborted") return;
 
-		if (!prepared.selectedModel.alreadyActive) {
-			const switched = await pi.setModel(prepared.selectedModel.model);
-			if (!switched) {
-				notify(ctx, `Failed to switch to model ${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`, "error");
-				return;
+		if (!shouldDelegatePrompt(prompt, subagent.override) && prompt.restore) {
+			const currentModel = getCurrentModel(ctx);
+			if (savedModel && currentModel && !sameModel(savedModel, currentModel)) {
+				previousModel = savedModel;
+				previousThinking = savedThinking;
 			}
-			runtimeModel = prepared.selectedModel.model;
-		}
-
-		if (prompt.restore && !prepared.selectedModel.alreadyActive) {
-			previousModel = savedModel;
-			previousThinking = savedThinking;
-		}
-		if (prompt.thinking) {
-			if (prompt.restore && previousThinking === undefined && prompt.thinking !== savedThinking) {
+			if (prompt.thinking && previousThinking === undefined && prompt.thinking !== savedThinking) {
 				previousThinking = savedThinking;
 			}
-			pi.setThinkingLevel(prompt.thinking);
 		}
-		pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
-
-		pi.sendUserMessage(prepared.content);
-		await waitForTurnStart(ctx);
-		await ctx.waitForIdle();
 	}
 
 	function resetSessionScopedState(ctx: ExtensionContext) {
@@ -840,8 +839,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		storedCommandCtx = ctx;
 		refreshPrompts(ctx.cwd, ctx);
 
-		const loop = extractLoopCount(args);
-		const cleanedArgs = loop ? loop.args : args;
+		const subagent = extractSubagentOverride(args);
+		const loop = extractLoopCount(subagent.args);
+		const cleanedArgs = loop ? loop.args : subagent.args;
 
 		const { steps, sharedArgs, invalidSegments } = parseChainSteps(cleanedArgs);
 		if (invalidSegments.length > 0) {
@@ -853,7 +853,16 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			return;
 		}
 
-		await runSharedChainExecution(steps, sharedArgs, loop ? loop.loopCount : 1, loop?.fresh === true, loop?.converge ?? true, true, ctx);
+		await runSharedChainExecution(
+			steps,
+			sharedArgs,
+			loop ? loop.loopCount : 1,
+			loop?.fresh === true,
+			loop?.converge ?? true,
+			true,
+			ctx,
+			subagent.override,
+		);
 	}
 
 	refreshPrompts(process.cwd());