pi-prompt-template-model 0.6.5 → 0.6.6

package/CHANGELOG.md

@@ -1,6 +1,21 @@
 # Changelog
 
-## [Unreleased]
+## [0.6.6] - 2026-03-28
+
+### Added
+- Added `--model=provider/model-id` runtime flag to override a template's model for a single invocation. Works with single execution, loops, and delegation.
+- Added `--fork` runtime flag to enable `inheritContext` (forked context) at invocation time. Implies `--subagent` if not already set.
+- Inline loop iterations now include a `[Loop 2/5]` prefix so the agent knows it's in a loop and which iteration it's on. Delegated (subagent) loops are unaffected.
+- Added `loop: unlimited` (and `loop: true`) frontmatter for open-ended loops that run until convergence, user interrupt, or the 999-iteration safety cap.
+- Added model rotation for loop iterations via `rotate: true` frontmatter. Cycles through comma-separated models and thinking levels each iteration instead of using fallback semantics.
+
+### Fixed
+- Pressing Escape during a loop or chain iteration now stops the loop. Previously, aborted inline turns were treated as "no changes" and the loop continued.
+- Delegation errors during loop iterations no longer abort the entire loop. The error is reported and the loop continues to the next iteration (useful with model rotation where one model may fail but others succeed).
+- Per-step bare `--loop` in chain declarations (e.g., `double-check --loop -> deslop`) now correctly runs unlimited iterations instead of running once.
+
+### Changed
+- Unlimited loops (`--loop` bare or `loop: unlimited`) no longer force convergence on. Convergence follows the `converge` field like bounded loops. Safety cap raised from 50 to 999.
 
 ## [0.6.5] - 2026-03-24
 

package/README.md

@@ -69,7 +69,8 @@ All fields are optional. Templates that don't use any extension features (no `mo
 | Field | Default | What it does |
 |-------|---------|--------------|
 | `restore` | `true` | After the command finishes, switch back to whatever model and thinking level were active before. Set `false` to stay on the new model. |
-| `loop` | — | Run this template multiple times by default (1–999). CLI `--loop` overrides this. See [Loop Execution](#loop-execution). |
+| `loop` | — | Run this template multiple times by default (1–999, `true`, or `unlimited`). CLI `--loop` overrides this. See [Loop Execution](#loop-execution). |
+| `rotate` | `false` | When `true` and looping, cycle through models in the `model` list instead of using fallback semantics. Thinking levels can also be comma-separated to pair with each model. |
 | `fresh` | `false` | When looping, collapse the conversation between iterations to a brief summary instead of carrying the full context forward. Saves tokens on long loops. |
 | `converge` | `true` | When looping, stop early if an iteration makes no file changes. Set `false` to always run every iteration. |
 
@@ -241,6 +242,17 @@ During execution, a live progress widget appears above the editor showing elapse
 
 You can override delegation at runtime per invocation with `--subagent`, `--subagent=<name>`, `--subagent:<name>`, or `--cwd=<path>`. `--cwd=<path>` must be absolute after optional `~/...` expansion. Runtime flags take precedence for that invocation only.
 
+Two additional runtime flags work for any prompt (not just delegated ones):
+
+- `--model=provider/model-id` — override the template's `model` for this invocation. Works with single execution, loops, and delegation.
+- `--fork` — run with `inheritContext` (forked context). Implies `--subagent` if not already set.
+
+```
+/double-check --model=anthropic/claude-opus-4-6
+/double-check --fork --subagent:worker
+/deslop --model=openai/gpt-5.4 --loop 3
+```
+
 ## Loop Execution
 
 Run a template multiple times with `--loop`:
@@ -248,7 +260,7 @@ Run a template multiple times with `--loop`:
 ```
 /deslop --loop 5
 /deslop --loop=5
-/deslop --loop          # unlimited — runs until convergence (50-iteration cap)
+/deslop --loop          # unlimited — runs until convergence or cap (999)
 ```
 
 You can also set a default in frontmatter. CLI `--loop` always overrides:
@@ -259,11 +271,22 @@ loop: 5
 ---
 ```
 
+Use `loop: unlimited` (or `loop: true`) for open-ended loops that run until convergence, user interrupt, or the safety cap of 999 iterations:
+
+```markdown
+---
+loop: unlimited
+converge: false
+fresh: true
+subagent: true
+---
+```
+
 ### How looping works
 
 Each iteration runs the same prompt. By default, context accumulates — iteration 3 sees the full conversation from iterations 1 and 2 and builds on that work.
 
-**Convergence**: If an iteration makes no file changes (no `write` or `edit` tool calls), the loop stops early. This is on by default. Use `--no-converge` or `converge: false` to always run every iteration. Bare `--loop` (unlimited) always forces convergence on, since its whole purpose is "run until nothing changes."
+**Convergence**: If an iteration makes no file changes (no `write` or `edit` tool calls), the loop stops early. This is on by default. Use `--no-converge` or `converge: false` to always run every iteration.
 
 **Fresh context**: Add `--fresh` (or `fresh: true` in frontmatter) to collapse the conversation between iterations. Each iteration gets a clean slate with only brief summaries of what previous iterations did. Good for long loops where accumulated context would blow up the token count.
 
@@ -271,6 +294,60 @@ Each iteration runs the same prompt. By default, context accumulates — iterati
 
 Model, thinking level, and skill are maintained throughout. If `restore: true` (the default), everything is restored after the final iteration.
 
+## Model Rotation
+
+`rotate: true` turns a comma-separated `model` list from a fallback chain into a cycling list. Each loop iteration uses the next model in the list, wrapping around:
+
+```markdown
+---
+model: claude-opus-4-6, gpt-5.4, gpt-5.3-codex
+thinking: high, xhigh, off
+loop: 9
+rotate: true
+fresh: true
+---
+Review and fix issues in this codebase.
+```
+
+Iteration 1 runs Opus + `high`, iteration 2 runs GPT-5.4 + `xhigh`, iteration 3 runs Codex + `off`, then wraps back to Opus. The status bar shows which model is active: `loop 2/9 · gpt-5.4 xhigh`.
+
+This is especially useful for [ralph-style loops](https://ghuntley.com/ralph/) where different models catch different things. The `subagent` examples below require [pi-subagents](https://github.com/nicobailon/pi-subagents/). A single-model ralph loop that delegates with fresh context each iteration:
+
+```markdown
+---
+model: claude-sonnet-4-20250514
+subagent: true
+inheritContext: true
+loop: 5
+fresh: true
+---
+Simplify this code: $@
+```
+
+Add `rotate` and multiple models to cycle different perspectives on each pass:
+
+```markdown
+---
+model: claude-opus-4-6, gpt-5.4, gpt-5.3-codex
+thinking: xhigh, high, high
+loop: 9
+rotate: true
+fresh: true
+subagent: true
+---
+Review and fix issues in this codebase.
+```
+
+Each iteration gets fresh context, a different model, and its own thinking level. Convergence stops the loop when an iteration makes no file changes — use `converge: false` to guarantee every model gets at least one shot.
+
+`thinking` pairing with `rotate: true`:
+
+- Single value (`thinking: high`) — applied to every model.
+- Comma-separated (`thinking: high, xhigh, off`) — positional, must match the number of models.
+- Omitted — each iteration inherits the session default.
+
+Without `loop`, `rotate` has no effect and comma-separated `model` keeps normal fallback behavior.
+
 ## Chaining Templates
 
 `/chain-prompts` runs multiple templates in sequence. Each step uses its own model, skill, and thinking level, while conversation context flows between them:

package/args.ts

@@ -20,6 +20,8 @@ export interface SubagentOverrideExtraction {
 	args: string;
 	override?: SubagentOverride;
 	cwd?: string;
+	model?: string;
+	fork?: boolean;
 }
 
 export function extractLoopCount(argsString: string): LoopExtraction | null {
@@ -113,7 +115,7 @@ export function extractLoopCount(argsString: string): LoopExtraction | null {
 		cleaned = cleaned.slice(0, start) + cleaned.slice(end);
 	}
 
-	const converge = loopCount === null ? true : !noConverge;
+	const converge = !noConverge;
 	return { args: cleaned.trim(), loopCount, fresh, converge };
 }
 
@@ -210,6 +212,8 @@ export function extractChainContextFlag(argsString: string): { args: string; cha
 export function extractSubagentOverride(argsString: string): SubagentOverrideExtraction {
 	let override: SubagentOverride | undefined;
 	let cwdRaw: string | undefined;
+	let modelRaw: string | undefined;
+	let fork = false;
 	const tokensToRemove: Array<{ start: number; end: number }> = [];
 
 	let i = 0;
@@ -250,6 +254,20 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 			tokensToRemove.push({ start: tokenStart, end: i });
 			const value = token.slice("--cwd=".length);
 			cwdRaw = value || undefined;
+			continue;
+		}
+
+		if (token.startsWith("--model=")) {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			const value = token.slice("--model=".length);
+			modelRaw = value || undefined;
+			continue;
+		}
+
+		if (token === "--fork") {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			fork = true;
+			continue;
 		}
 	}
 
@@ -261,10 +279,14 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 		cleaned = cleaned.slice(0, start) + cleaned.slice(end);
 	}
 
+	if (fork && !override) override = { enabled: true };
+
 	return {
 		args: cleaned.trim(),
 		...(override ? { override } : {}),
 		...(cwdRaw !== undefined ? { cwd: cwdRaw } : {}),
+		...(modelRaw !== undefined ? { model: modelRaw } : {}),
+		...(fork ? { fork: true } : {}),
 	};
 }
 

package/chain-parser.ts

@@ -3,7 +3,7 @@ import { parseCommandArgs } from "./args.js";
 export interface ChainStep {
 	name: string;
 	args: string[];
-	loopCount?: number;
+	loopCount?: number | null;
 	withContext?: boolean;
 }
 
@@ -81,11 +81,11 @@ function scanSegmentTokens(segment: string): SegmentToken[] {
 	return tokens;
 }
 
-function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?: number; withContext: boolean } {
+function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?: number | null; withContext: boolean } {
 	const tokens = scanSegmentTokens(segment);
 	const loopTokenRanges: Array<{ start: number; end: number }> = [];
 	const withContextTokenRanges: Array<{ start: number; end: number }> = [];
-	let loopCount: number | undefined;
+	let loopCount: number | null | undefined;
 	let withContext = false;
 
 	for (let i = 1; i < tokens.length; i++) {
@@ -109,17 +109,24 @@ function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?
 			continue;
 		}
 
-		if (token.value === "--loop" && i + 1 < tokens.length) {
-			const next = tokens[i + 1];
-			if (!next.quoted && /^\d+$/.test(next.value)) {
-				loopTokenRanges.push({ start: token.start, end: token.end }, { start: next.start, end: next.end });
-				const parsed = parseInt(next.value, 10);
-				if (parsed >= 1 && parsed <= 999 && loopCount === undefined) {
-					loopCount = parsed;
+		if (token.value === "--loop") {
+			loopTokenRanges.push({ start: token.start, end: token.end });
+			if (i + 1 < tokens.length) {
+				const next = tokens[i + 1];
+				if (!next.quoted && /^\d+$/.test(next.value)) {
+					loopTokenRanges.push({ start: next.start, end: next.end });
+					const parsed = parseInt(next.value, 10);
+					if (parsed >= 1 && parsed <= 999 && loopCount === undefined) {
+						loopCount = parsed;
+					}
+					i++;
+					continue;
 				}
-				i++;
-				continue;
 			}
+			if (loopCount === undefined) {
+				loopCount = null;
+			}
+			continue;
 		}
 	}
 

package/index.ts

@@ -3,7 +3,7 @@ import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@m
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 import { extractChainContextFlag, extractLoopCount, extractLoopFlags, extractSubagentOverride, parseCommandArgs, type SubagentOverride } from "./args.js";
 import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.js";
-import { generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries } from "./loop-utils.js";
+import { generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries, wasIterationAborted } from "./loop-utils.js";
 import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.js";
 import { preparePromptExecution } from "./prompt-execution.js";
 import { buildPromptCommandDescription, expandCwdPath, loadPromptsWithModel, readSkillContent, resolveSkillPath, type PromptWithModel } from "./prompt-loader.js";
@@ -16,6 +16,7 @@ import { renderDelegatedSubagentResult } from "./subagent-renderer.js";
 interface LoopState {
 	currentIteration: number;
 	totalIterations: number | null;
+	rotationLabel?: string;
 }
 
 interface FreshCollapse {
@@ -58,7 +59,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	let accumulatedSummaries: string[] = [];
 	let lastDiagnostics = "";
 	let storedCommandCtx: ExtensionCommandContext | null = null;
-	const UNLIMITED_LOOP_CAP = 50;
+	const UNLIMITED_LOOP_CAP = 999;
 
 	const toolManager = createToolManager(pi, {
 		isActive: () => !!(loopState || chainActive),
@@ -196,6 +197,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		override?: SubagentOverride,
 		inheritedModel?: Model<any>,
 		taskPreamble?: string,
+		loopContext?: string,
 	): Promise<PromptStepResult | "aborted"> {
 		if (shouldDelegatePrompt(prompt, override)) {
 			try {
@@ -216,7 +218,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				return { changed: delegated.changed };
 			} catch (error) {
 				notify(ctx, error instanceof Error ? error.message : String(error), "error");
-				return "aborted";
+				return { changed: false };
 			}
 		}
 
@@ -258,10 +260,14 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
 
 		const startId = ctx.sessionManager.getLeafId();
-		pi.sendUserMessage(prepared.content);
+		const content = loopContext ? `[${loopContext}]\n\n${prepared.content}` : prepared.content;
+		pi.sendUserMessage(content);
 		await waitForTurnStart(ctx);
 		await ctx.waitForIdle();
-		return { changed: didIterationMakeChanges(getIterationEntries(ctx, startId)) };
+
+		const entries = getIterationEntries(ctx, startId);
+		if (wasIterationAborted(entries)) return "aborted";
+		return { changed: didIterationMakeChanges(entries) };
 	}
 
 	async function restoreSessionState(
@@ -353,10 +359,11 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	function updateLoopStatus(ctx: ExtensionContext) {
 		if (!ctx.hasUI) return;
 		if (loopState) {
+			const suffix = loopState.rotationLabel ? ` · ${loopState.rotationLabel}` : "";
 			const label =
 				loopState.totalIterations !== null
-					? `loop ${loopState.currentIteration}/${loopState.totalIterations}`
-					: `loop ${loopState.currentIteration}`;
+					? `loop ${loopState.currentIteration}/${loopState.totalIterations}${suffix}`
+					: `loop ${loopState.currentIteration}${suffix}`;
 			ctx.ui.setStatus("prompt-loop", ctx.ui.theme.fg("warning", label));
 		} else {
 			ctx.ui.setStatus("prompt-loop", undefined);
@@ -385,6 +392,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		ctx: ExtensionCommandContext,
 		subagentOverride?: SubagentOverride,
 		cwdOverride?: string,
+		promptOverrides?: Partial<Pick<PromptWithModel, "models" | "inheritContext">>,
 	) {
 		refreshPrompts(ctx.cwd, ctx);
 		const initialPrompt = prompts.get(name);
@@ -401,7 +409,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const useFresh = freshFlag || initialPrompt.fresh === true;
 		const effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP;
 		const isUnlimited = totalIterations === null;
-		const useConverge = isUnlimited ? true : converge && initialPrompt.converge !== false;
+		const useConverge = converge && initialPrompt.converge !== false;
 		const anchorId = useFresh ? ctx.sessionManager.getLeafId() : null;
 
 		loopState = { currentIteration: 1, totalIterations };
@@ -414,9 +422,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		try {
 			for (let i = 0; i < effectiveMax; i++) {
 				loopState.currentIteration = i + 1;
-				updateLoopStatus(ctx);
 				const iterationLabel = totalIterations !== null ? `${i + 1}/${totalIterations}` : `${i + 1}`;
-				notify(ctx, `Loop ${iterationLabel}: ${name}`, "info");
 
 				refreshPrompts(ctx.cwd, ctx);
 				const prompt = prompts.get(name);
@@ -424,15 +430,40 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					notify(ctx, `Prompt "${name}" no longer exists`, "error");
 					break;
 				}
-				const effectivePrompt = cwdOverride ? { ...prompt, cwd: cwdOverride } : prompt;
+				const effectivePrompt = { ...prompt, ...(cwdOverride ? { cwd: cwdOverride } : {}), ...promptOverrides };
+				let iterationPrompt = effectivePrompt;
+				loopState!.rotationLabel = undefined;
+				if (effectivePrompt.rotate && effectivePrompt.models.length > 1) {
+					const rotationIndex = i % effectivePrompt.models.length;
+					const rotatedThinking = effectivePrompt.thinkingLevels
+						? effectivePrompt.thinkingLevels[rotationIndex]
+						: effectivePrompt.thinking;
+					iterationPrompt = {
+						...effectivePrompt,
+						models: [effectivePrompt.models[rotationIndex]],
+						thinking: rotatedThinking,
+					};
+					const shortModel = effectivePrompt.models[rotationIndex].split("/").pop() || effectivePrompt.models[rotationIndex];
+					const thinkingLabel = rotatedThinking ? ` ${rotatedThinking}` : "";
+					loopState!.rotationLabel = `${shortModel}${thinkingLabel}`;
+				}
+				updateLoopStatus(ctx);
+				const rotationSuffix = loopState!.rotationLabel ? ` [${loopState!.rotationLabel}]` : "";
+				notify(ctx, `Loop ${iterationLabel}: ${name}${rotationSuffix}`, "info");
 
+				const loopContext = loopState!.rotationLabel
+					? `Loop ${iterationLabel} · ${loopState!.rotationLabel}`
+					: `Loop ${iterationLabel}`;
 				const iterationStartId = ctx.sessionManager.getLeafId();
 				const stepResult = await executePromptStep(
-					effectivePrompt,
+					iterationPrompt,
 					parseCommandArgs(cleanedArgs),
 					ctx,
 					currentModel,
 					subagentOverride,
+					undefined,
+					undefined,
+					loopContext,
 				);
 				if (stepResult === "aborted") break;
 
@@ -440,7 +471,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				currentThinking = pi.getThinkingLevel();
 				completedIterations++;
 
-				const iterationChanged = shouldDelegatePrompt(effectivePrompt, subagentOverride)
+				const iterationChanged = shouldDelegatePrompt(iterationPrompt, subagentOverride)
 					? stepResult.changed
 					: didIterationMakeChanges(getIterationEntries(ctx, iterationStartId));
 				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
@@ -567,7 +598,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		pendingSkillMessage = undefined;
 		const effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP;
 		const isUnlimited = totalIterations === null;
-		const useConverge = isUnlimited ? true : converge;
+		const useConverge = converge;
 
 		const anchorId = fresh ? ctx.sessionManager.getLeafId() : null;
 		const chainStepNames = steps
@@ -612,7 +643,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 									...(cwdOverride ? { cwd: cwdOverride } : {}),
 								},
 								stepArgs: step.args,
-								stepLoop: step.loopCount ?? 1,
+								stepLoop: step.loopCount !== undefined ? step.loopCount : 1,
 								stepWithContext: step.withContext === true,
 							},
 						},
@@ -676,7 +707,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					}
 
 					const singleStep = stepTemplate.singleStep;
-					const stepLoop = singleStep.stepLoop;
+					const stepLoopTotal = singleStep.stepLoop;
+					const stepLoopMax = stepLoopTotal ?? UNLIMITED_LOOP_CAP;
+					const isStepLooping = stepLoopMax > 1;
 					const effectiveArgs = singleStep.stepArgs.length > 0 ? singleStep.stepArgs : sharedArgs;
 					const shouldInjectSummary =
 						shouldDelegatePrompt(singleStep.prompt, subagentOverride) &&
@@ -684,19 +717,23 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 						(chainContextEnabled || singleStep.stepWithContext === true);
 					const outerLoopState = loopState ? { ...loopState } : null;
 					const stepStartId = ctx.sessionManager.getLeafId();
-					if (stepLoop > 1) {
-						loopState = { currentIteration: 1, totalIterations: stepLoop };
+					if (isStepLooping) {
+						loopState = { currentIteration: 1, totalIterations: stepLoopTotal };
 						updateLoopStatus(ctx);
 					}
 
 					try {
-						for (let stepIteration = 0; stepIteration < stepLoop; stepIteration++) {
-							if (stepLoop > 1) {
-								loopState = { currentIteration: stepIteration + 1, totalIterations: stepLoop };
+						for (let stepIteration = 0; stepIteration < stepLoopMax; stepIteration++) {
+							if (isStepLooping) {
+								loopState = { currentIteration: stepIteration + 1, totalIterations: stepLoopTotal };
 								updateLoopStatus(ctx);
 							}
 
-							const iterSuffix = stepLoop > 1 ? ` (iter ${stepIteration + 1}/${stepLoop})` : "";
+							const iterSuffix = isStepLooping
+								? stepLoopTotal !== null
+									? ` (iter ${stepIteration + 1}/${stepLoopTotal})`
+									: ` (iter ${stepIteration + 1})`
+								: "";
 							notify(
 								ctx,
 								`${loopPrefix}Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix} ${buildPromptCommandDescription(singleStep.prompt)}`,
@@ -709,6 +746,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								? `[Previous chain steps]\n\n${chainStepSummaries.join("\n\n")}`
 								: undefined;
 
+							const stepLoopContext = isStepLooping
+								? `Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix}`
+								: undefined;
 							const stepIterationStartId = ctx.sessionManager.getLeafId();
 							const stepResult = await executePromptStep(
 								singleStep.prompt,
@@ -718,6 +758,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								subagentOverride,
 								chainInheritedModel,
 								taskPreamble,
+								stepLoopContext,
 							);
 							if (stepResult === "aborted") {
 								aborted = true;
@@ -729,12 +770,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 							const stepIterationEntries = getIterationEntries(ctx, stepIterationStartId);
 							const stepIterationChanged = didIterationMakeChanges(stepIterationEntries);
-							if (stepLoop > 1 && singleStep.prompt.converge !== false && !stepIterationChanged) {
+							if (isStepLooping && singleStep.prompt.converge !== false && !stepIterationChanged) {
 								break;
 							}
 						}
 					} finally {
-						if (stepLoop > 1) {
+						if (isStepLooping) {
 							loopState = outerLoopState ? { ...outerLoopState } : null;
 							updateLoopStatus(ctx);
 						}
@@ -817,10 +858,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const argsWithoutSubagent = subagent.args;
 
 		if (prompt.chain) {
+			if (subagent.model) notify(ctx, `--model is not supported on chain prompts (ignored)`, "warning");
+			if (subagent.fork) notify(ctx, `--fork is not supported on chain prompts (ignored)`, "warning");
 			const extracted = extractChainContextFlag(argsWithoutSubagent);
 			const chainContextEnabled = extracted.chainContext || prompt.chainContext === "summary";
 			const loop = extractLoopCount(extracted.args);
-			let totalIterations: number | null = prompt.loop ?? 1;
+			let totalIterations: number | null = prompt.loop !== undefined ? prompt.loop : 1;
 			let fresh = false;
 			let converge = true;
 			let cleanedArgs = extracted.args;
@@ -863,19 +906,24 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			return;
 		}
 
+		const promptOverrides: Partial<Pick<PromptWithModel, "models" | "inheritContext">> = {
+			...(subagent.model ? { models: [subagent.model] } : {}),
+			...(subagent.fork ? { inheritContext: true } : {}),
+		};
+
 		const loop = extractLoopCount(argsWithoutSubagent);
 		if (loop) {
-			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override, runtimeCwd);
+			await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
 			return;
 		}
 
 		if (prompt.loop !== undefined) {
 			const flags = extractLoopFlags(argsWithoutSubagent);
-			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override, runtimeCwd);
+			await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
 			return;
 		}
 
-		const effectivePrompt = runtimeCwd ? { ...prompt, cwd: runtimeCwd } : prompt;
+		const effectivePrompt = { ...prompt, ...(runtimeCwd ? { cwd: runtimeCwd } : {}), ...promptOverrides };
 		const savedModel = getCurrentModel(ctx);
 		const savedThinking = pi.getThinkingLevel();
 		const stepResult = await executePromptStep(

package/loop-utils.ts

@@ -153,3 +153,11 @@ export function getIterationEntries(ctx: Pick<ExtensionContext, "sessionManager"
 	if (startIdx < 0) return branch;
 	return branch.slice(startIdx + 1);
 }
+
+export function wasIterationAborted(entries: SessionEntry[]): boolean {
+	for (const entry of entries) {
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		if ((entry.message as AssistantMessage).stopReason === "aborted") return true;
+	}
+	return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",

package/prompt-loader.ts

@@ -42,8 +42,10 @@ export interface PromptWithModel {
 	restore: boolean;
 	skill?: string;
 	thinking?: ThinkingLevel;
+	thinkingLevels?: ThinkingLevel[];
+	rotate?: boolean;
 	fresh?: boolean;
-	loop?: number;
+	loop?: number | null;
 	converge?: boolean;
 	subagent?: true | string;
 	inheritContext?: boolean;
@@ -243,14 +245,43 @@ function normalizeFresh(
 	return false;
 }
 
+function normalizeRotate(
+	value: unknown,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): boolean {
+	if (value === undefined) return false;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "true") return true;
+		if (normalized === "false") return false;
+	}
+
+	diagnostics.push(
+		createDiagnostic(
+			"invalid-rotate",
+			filePath,
+			source,
+			`Using default rotate=false for ${filePath}: frontmatter field "rotate" must be true or false.`,
+		),
+	);
+	return false;
+}
+
 function normalizeLoop(
 	value: unknown,
 	filePath: string,
 	source: PromptSource,
 	diagnostics: PromptLoaderDiagnostic[],
-): number | undefined {
+): number | null | undefined {
 	if (value === undefined) return undefined;
 
+	if (value === true || (typeof value === "string" && value.trim().toLowerCase() === "unlimited")) {
+		return null;
+	}
+
 	let normalizedValue: number | undefined;
 	if (typeof value === "number") {
 		normalizedValue = value;
@@ -267,7 +298,7 @@ function normalizeLoop(
 			"invalid-loop",
 			filePath,
 			source,
-			`Ignoring invalid loop value in ${filePath}: frontmatter field "loop" must be an integer between 1 and 999.`,
+			`Ignoring invalid loop value in ${filePath}: frontmatter field "loop" must be an integer between 1 and 999, true, or "unlimited".`,
 		),
 	);
 	return undefined;
@@ -481,6 +512,48 @@ function normalizeThinking(
 	return undefined;
 }
 
+function normalizeThinkingLevels(
+	value: unknown,
+	modelCount: number,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): ThinkingLevel[] | undefined {
+	if (typeof value !== "string") return undefined;
+
+	const levels = value
+		.split(",")
+		.map((item) => item.trim())
+		.filter(Boolean);
+
+	const invalidLevel = levels.find((level) => !(VALID_THINKING_LEVELS as readonly string[]).includes(level.toLowerCase()));
+	if (invalidLevel) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-thinking-levels",
+				filePath,
+				source,
+				`Ignoring invalid thinking level in ${filePath}: ${JSON.stringify(invalidLevel)}.`,
+			),
+		);
+		return undefined;
+	}
+
+	if (levels.length !== modelCount) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-thinking-level-count",
+				filePath,
+				source,
+				`Ignoring comma-separated thinking levels in ${filePath}: expected ${modelCount} entries to match frontmatter field "model".`,
+			),
+		);
+		return undefined;
+	}
+
+	return levels.map((level) => level.toLowerCase() as ThinkingLevel);
+}
+
 function loadPromptsWithModelFromDir(
 	dir: string,
 	source: PromptSource,
@@ -619,6 +692,7 @@ function loadPromptsWithModelFromDir(
 				const parsedModels = chain ? [] : normalizeModelSpecs(frontmatter.model, fullPath, source, diagnostics);
 				if (!chain && hasModelField && !parsedModels) continue;
 				const models = chain ? [] : (parsedModels ?? []);
+				const rotate = chain ? false : normalizeRotate(frontmatter.rotate, fullPath, source, diagnostics);
 
 				const name = entry.name.slice(0, -3);
 				if (RESERVED_COMMAND_NAMES.has(name)) {
@@ -637,7 +711,15 @@ function loadPromptsWithModelFromDir(
 				const safeCwd = (chain || subagent !== undefined) ? cwd : undefined;
 				const description = normalizeStringField("description", frontmatter.description, fullPath, source, diagnostics) ?? "";
 				const skill = chain ? undefined : normalizeStringField("skill", frontmatter.skill, fullPath, source, diagnostics);
-				const thinking = chain ? undefined : normalizeThinking(frontmatter.thinking, fullPath, source, diagnostics);
+				let thinking: ThinkingLevel | undefined;
+				let thinkingLevels: ThinkingLevel[] | undefined;
+				if (!chain) {
+					if (rotate && typeof frontmatter.thinking === "string" && frontmatter.thinking.includes(",")) {
+						thinkingLevels = normalizeThinkingLevels(frontmatter.thinking, models.length, fullPath, source, diagnostics);
+					} else {
+						thinking = normalizeThinking(frontmatter.thinking, fullPath, source, diagnostics);
+					}
+				}
 				const restore = normalizeRestore(frontmatter.restore, fullPath, source, diagnostics);
 				const fresh = normalizeFresh(frontmatter.fresh, fullPath, source, diagnostics);
 				const loop = normalizeLoop(frontmatter.loop, fullPath, source, diagnostics);
@@ -666,8 +748,10 @@ function loadPromptsWithModelFromDir(
 					restore,
 					skill,
 					thinking,
+					thinkingLevels,
+					rotate: rotate || undefined,
 					fresh: fresh || undefined,
-					loop: loop || undefined,
+					loop: loop !== undefined ? loop : undefined,
 					converge: converge === false ? false : undefined,
 					subagent,
 					inheritContext: safeInheritContext || undefined,
@@ -753,13 +837,15 @@ export function buildPromptCommandDescription(prompt: PromptWithModel): string {
 		return prompt.description ? `${prompt.description} ${details}` : details;
 	}
 	const modelLabel = prompt.models.length > 0 ? prompt.models.map((model) => model.split("/").pop() || model).join("|") : "current";
+	const rotateLabel = prompt.rotate ? " rotate" : "";
 	const skillLabel = prompt.skill ? ` +${prompt.skill}` : "";
-	const thinkingLabel = prompt.thinking ? ` ${prompt.thinking}` : "";
-	const loopLabel = prompt.loop ? ` loop:${prompt.loop}` : "";
+	const thinkingValue = prompt.thinkingLevels ? prompt.thinkingLevels.join(",") : prompt.thinking;
+	const thinkingLabel = thinkingValue ? ` ${thinkingValue}` : "";
+	const loopLabel = prompt.loop !== undefined ? ` loop:${prompt.loop === null ? "unlimited" : prompt.loop}` : "";
 	const subagentLabel = prompt.subagent ? ` subagent:${prompt.subagent === true ? "delegate" : prompt.subagent}` : "";
 	const cwdLabel = prompt.cwd ? ` cwd:${prompt.cwd}` : "";
 	const inheritContextLabel = prompt.inheritContext ? " fork" : "";
-	const details = `[${modelLabel}${thinkingLabel}${skillLabel}${loopLabel}${subagentLabel}${cwdLabel}${inheritContextLabel}] ${sourceLabel}`;
+	const details = `[${modelLabel}${rotateLabel}${thinkingLabel}${skillLabel}${loopLabel}${subagentLabel}${cwdLabel}${inheritContextLabel}] ${sourceLabel}`;
 	return prompt.description ? `${prompt.description} ${details}` : details;
 }