pi-prompt-template-model 0.6.4 → 0.6.6

package/CHANGELOG.md

@@ -1,6 +1,26 @@
 # 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
+
+### Added
+- Added delegated chain-step context summaries via `chainContext: summary` (chain frontmatter), `/chain-prompts ... --chain-context` (command-level), and per-step `--with-context` (single delegated chain steps).
 
 ## [0.6.4] - 2026-03-23
 

package/README.md

@@ -62,13 +62,15 @@ All fields are optional. Templates that don't use any extension features (no `mo
 | `thinking` | — | Thinking level for the model: `off`, `minimal`, `low`, `medium`, `high`, or `xhigh`. |
 | `description` | — | Short text shown next to the command in autocomplete. |
 | `chain` | — | Declares a reusable pipeline of templates (`step -> step`). When set, the body is ignored. See [Chain Templates](#chain-templates). |
+| `chainContext` | — | Chain templates only. Set to `summary` so delegated steps receive a compact summary of what previous steps did. Steps with `inheritContext: true` are excluded. See [Chain context for delegated steps](#chain-context-for-delegated-steps). |
 
 ### Execution Control
 
 | 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. |
 
@@ -240,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`:
@@ -247,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:
@@ -258,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.
 
@@ -270,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:
@@ -328,6 +406,33 @@ This runs the full analyze → fix chain 3 times, with fresh context between ite
 
 When a chain template sets `cwd`, it becomes the default delegated subprocess working directory for all delegated steps in that chain. Runtime `--cwd=<path>` overrides the chain template value.
 
+### Chain context for delegated steps
+
+Delegated chain steps start fresh — they don't see what earlier steps did. Chain context prepends a compact summary of previous steps to each delegated task so later steps can build on earlier work.
+
+Enable it chain-wide with `chainContext: summary` in frontmatter or `--chain-context` on the CLI:
+
+```markdown
+---
+chain: analyze -> fix
+chainContext: summary
+---
+```
+
+```
+/chain-prompts analyze -> fix --chain-context
+```
+
+To enable it for a single step, attach `--with-context` to that step name:
+
+```
+/chain-prompts analyze -> reviewer --with-context -> summarize
+```
+
+Here only `reviewer` receives the summary of `analyze`. The `summarize` step does not.
+
+Steps using `inheritContext: true` already fork the full parent conversation and skip the summary preamble. `--with-context` is not supported inside `parallel(...)` groups. When a chain uses `loop`, summaries reset each iteration.
+
 ### Parallel and looping from the CLI
 
 Parallel groups work in `/chain-prompts` too:
@@ -359,6 +464,7 @@ Once enabled, the agent sees `run-prompt` in its tool list:
 
 ```
 run-prompt({ command: "deslop --loop 5 --fresh" })
+run-prompt({ command: "chain-prompts analyze -> fix --chain-context" })
 run-prompt({ command: "chain-prompts analyze -> fix --loop 3" })
 run-prompt({ command: "deslop --subagent" })
 ```

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 };
 }
 
@@ -163,9 +165,55 @@ export function extractLoopFlags(argsString: string): LoopFlags {
 	return { args: cleaned.trim(), fresh, converge: !noConverge };
 }
 
+export function extractChainContextFlag(argsString: string): { args: string; chainContext: boolean } {
+	let chainContext = false;
+	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 === "--chain-context") {
+			chainContext = true;
+			tokensToRemove.push({ start: tokenStart, end: i });
+		}
+	}
+
+	if (tokensToRemove.length === 0) {
+		return { args: argsString.trim(), chainContext: false };
+	}
+
+	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(), chainContext };
+}
+
 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;
@@ -206,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;
 		}
 	}
 
@@ -217,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,8 @@ import { parseCommandArgs } from "./args.js";
 export interface ChainStep {
 	name: string;
 	args: string[];
-	loopCount?: number;
+	loopCount?: number | null;
+	withContext?: boolean;
 }
 
 export interface ParallelChainStep {
@@ -80,15 +81,23 @@ function scanSegmentTokens(segment: string): SegmentToken[] {
 	return tokens;
 }
 
-function extractStepLoopCount(segment: string): { cleanedSegment: string; loopCount?: number } {
+function extractStepFlags(segment: string): { cleanedSegment: string; loopCount?: number | null; withContext: boolean } {
 	const tokens = scanSegmentTokens(segment);
 	const loopTokenRanges: Array<{ start: number; end: number }> = [];
-	let loopCount: number | undefined;
+	const withContextTokenRanges: Array<{ start: number; end: number }> = [];
+	let loopCount: number | null | undefined;
+	let withContext = false;
 
 	for (let i = 1; i < tokens.length; i++) {
 		const token = tokens[i];
 		if (token.quoted) continue;
 
+		if (token.value === "--with-context") {
+			withContext = true;
+			withContextTokenRanges.push({ start: token.start, end: token.end });
+			continue;
+		}
+
 		if (token.value.startsWith("--loop=")) {
 			loopTokenRanges.push({ start: token.start, end: token.end });
 			const value = token.value.slice("--loop=".length);
@@ -100,31 +109,39 @@ function extractStepLoopCount(segment: string): { cleanedSegment: string; loopCo
 			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;
 		}
 	}
 
-	if (loopCount === undefined || loopTokenRanges.length === 0) {
-		return { cleanedSegment: segment };
+	const loopRangesToRemove = loopCount !== undefined ? loopTokenRanges : [];
+	if (loopRangesToRemove.length === 0 && withContextTokenRanges.length === 0) {
+		return { cleanedSegment: segment, withContext: false };
 	}
 
-	loopTokenRanges.sort((a, b) => b.start - a.start);
+	const rangesToRemove = [...loopRangesToRemove, ...withContextTokenRanges].sort((a, b) => b.start - a.start);
 	let cleanedSegment = segment;
-	for (const { start, end } of loopTokenRanges) {
+	for (const { start, end } of rangesToRemove) {
 		cleanedSegment = `${cleanedSegment.slice(0, start)}${cleanedSegment.slice(end)}`;
 	}
 
-	return { cleanedSegment: cleanedSegment.trim(), loopCount };
+	return { cleanedSegment: cleanedSegment.trim(), loopCount, withContext };
 }
 
 function splitByTopLevelSeparator(input: string, separator: string): string[] {
@@ -192,10 +209,10 @@ function findMatchingParen(segment: string, openIndex: number): number {
 }
 
 function parseSingleStepSegment(segment: string): ChainStep | undefined {
-	const { cleanedSegment, loopCount } = extractStepLoopCount(segment);
+	const { cleanedSegment, loopCount, withContext } = extractStepFlags(segment);
 	const tokens = parseCommandArgs(cleanedSegment);
 	if (tokens.length === 0) return undefined;
-	return { name: tokens[0], args: tokens.slice(1), loopCount };
+	return { name: tokens[0], args: tokens.slice(1), loopCount, ...(withContext ? { withContext: true } : {}) };
 }
 
 function parseParallelStepSegment(segment: string): ParallelChainStep | undefined {

package/index.ts

@@ -1,9 +1,9 @@
 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, extractSubagentOverride, parseCommandArgs, type SubagentOverride } from "./args.js";
+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 { 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),
@@ -195,6 +196,8 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		currentModel: Model<any> | undefined,
 		override?: SubagentOverride,
 		inheritedModel?: Model<any>,
+		taskPreamble?: string,
+		loopContext?: string,
 	): Promise<PromptStepResult | "aborted"> {
 		if (shouldDelegatePrompt(prompt, override)) {
 			try {
@@ -206,6 +209,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					currentModel,
 					override,
 					inheritedModel,
+					taskPreamble,
 				});
 				if (!delegated) {
 					notify(ctx, `Prompt \`${prompt.name}\` is not configured for delegated execution.`, "error");
@@ -214,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 };
 			}
 		}
 
@@ -256,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(
@@ -351,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);
@@ -383,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);
@@ -399,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 };
@@ -412,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);
@@ -422,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;
 
@@ -438,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) {
@@ -496,6 +529,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		ctx: ExtensionCommandContext,
 		subagentOverride?: SubagentOverride,
 		cwdOverride?: string,
+		chainContextEnabled = false,
 	) {
 		const flattenChainSteps = (): ChainStep[] => {
 			const flattened: ChainStep[] = [];
@@ -524,6 +558,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 							notify(ctx, `Step "${parallelStep.name}" in parallel() does not support per-task --loop.`, "error");
 							return false;
 						}
+						if (parallelStep.withContext === true) {
+							notify(ctx, `Step "${parallelStep.name}" in parallel() does not support per-task --with-context.`, "error");
+							return false;
+						}
 						const stepPrompt = prompts.get(parallelStep.name);
 						if (!stepPrompt) continue;
 						if (stepPrompt.chain) {
@@ -560,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
@@ -599,14 +637,18 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 						}
 						: {
 							kind: "single" as const,
-							template: {
-								...prompts.get(step.name)!,
-								...(cwdOverride ? { cwd: cwdOverride } : {}),
+							singleStep: {
+								prompt: {
+									...prompts.get(step.name)!,
+									...(cwdOverride ? { cwd: cwdOverride } : {}),
+								},
 								stepArgs: step.args,
-								stepLoop: step.loopCount ?? 1,
+								stepLoop: step.loopCount !== undefined ? step.loopCount : 1,
+								stepWithContext: step.withContext === true,
 							},
 						},
 				);
+				const chainStepSummaries: string[] = [];
 				let aborted = false;
 				let iterationChanged = false;
 				let loopPrefix = "";
@@ -619,10 +661,17 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					const stepNumber = index + 1;
 					if (stepTemplate.kind === "parallel") {
 						const stepNames = stepTemplate.tasks.map((task) => task.name).join(", ");
+						const stepLabel = `parallel(${stepNames})`;
 						notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: parallel(${stepNames})`, "info");
 						if (ctx.hasUI) {
 							ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: parallel(${stepNames})`));
 						}
+						const stepStartId = ctx.sessionManager.getLeafId();
+						let taskPreamble: string | undefined;
+						const isForkedParallelContext = stepTemplate.tasks.some((task) => task.prompt.inheritContext === true);
+						if (chainContextEnabled && !isForkedParallelContext && chainStepSummaries.length > 0) {
+							taskPreamble = `[Previous chain steps]\n\n${chainStepSummaries.join("\n\n")}`;
+						}
 
 						let delegated;
 						try {
@@ -636,6 +685,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 									prompt: task.prompt,
 									args: task.args.length > 0 ? task.args : sharedArgs,
 								})),
+								taskPreamble,
 							});
 						} catch (error) {
 							notify(ctx, error instanceof Error ? error.message : String(error), "error");
@@ -650,40 +700,65 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 						currentModel = getCurrentModel(ctx);
 						currentThinking = pi.getThinkingLevel();
-						if (delegated.changed) iterationChanged = true;
+						const stepEntries = getIterationEntries(ctx, stepStartId);
+						if (didIterationMakeChanges(stepEntries)) iterationChanged = true;
+						chainStepSummaries.push(generateChainStepSummary(stepEntries, stepLabel, stepNumber));
 						continue;
 					}
 
-					const template = stepTemplate.template;
-					const stepLoop = template.stepLoop;
-					const effectiveArgs = template.stepArgs.length > 0 ? template.stepArgs : sharedArgs;
+					const singleStep = stepTemplate.singleStep;
+					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) &&
+						singleStep.prompt.inheritContext !== true &&
+						(chainContextEnabled || singleStep.stepWithContext === true);
 					const outerLoopState = loopState ? { ...loopState } : null;
-					if (stepLoop > 1) {
-						loopState = { currentIteration: 1, totalIterations: stepLoop };
+					const stepStartId = ctx.sessionManager.getLeafId();
+					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})` : "";
-							notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: ${template.name}${iterSuffix} ${buildPromptCommandDescription(template)}`, "info");
+							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)}`,
+								"info",
+							);
 							if (ctx.hasUI) {
-								ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: ${template.name}`));
+								ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}`));
 							}
+							const taskPreamble = shouldInjectSummary && chainStepSummaries.length > 0
+								? `[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(
-								template,
+								singleStep.prompt,
 								effectiveArgs,
 								ctx,
 								currentModel,
 								subagentOverride,
 								chainInheritedModel,
+								taskPreamble,
+								stepLoopContext,
 							);
 							if (stepResult === "aborted") {
 								aborted = true;
@@ -693,22 +768,23 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 							currentModel = getCurrentModel(ctx);
 							currentThinking = pi.getThinkingLevel();
 
-							const stepChanged = shouldDelegatePrompt(template, subagentOverride)
-								? stepResult.changed
-								: didIterationMakeChanges(getIterationEntries(ctx, stepIterationStartId));
-							if (stepChanged) iterationChanged = true;
-							if (stepLoop > 1 && template.converge !== false && !stepChanged) {
+							const stepIterationEntries = getIterationEntries(ctx, stepIterationStartId);
+							const stepIterationChanged = didIterationMakeChanges(stepIterationEntries);
+							if (isStepLooping && singleStep.prompt.converge !== false && !stepIterationChanged) {
 								break;
 							}
 						}
 					} finally {
-						if (stepLoop > 1) {
+						if (isStepLooping) {
 							loopState = outerLoopState ? { ...outerLoopState } : null;
 							updateLoopStatus(ctx);
 						}
 					}
 
 					if (aborted) break;
+					const stepEntries = getIterationEntries(ctx, stepStartId);
+					if (didIterationMakeChanges(stepEntries)) iterationChanged = true;
+					chainStepSummaries.push(generateChainStepSummary(stepEntries, singleStep.prompt.name, stepNumber));
 				}
 
 				if (aborted) break;
@@ -782,11 +858,15 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const argsWithoutSubagent = subagent.args;
 
 		if (prompt.chain) {
-			const loop = extractLoopCount(argsWithoutSubagent);
-			let totalIterations: number | null = prompt.loop ?? 1;
+			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 !== undefined ? prompt.loop : 1;
 			let fresh = false;
 			let converge = true;
-			let cleanedArgs = argsWithoutSubagent;
+			let cleanedArgs = extracted.args;
 
 			if (loop) {
 				totalIterations = loop.loopCount;
@@ -794,7 +874,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				converge = loop.converge;
 				cleanedArgs = loop.args;
 			} else if (prompt.loop !== undefined) {
-				const flags = extractLoopFlags(argsWithoutSubagent);
+				const flags = extractLoopFlags(extracted.args);
 				fresh = flags.fresh;
 				converge = flags.converge;
 				cleanedArgs = flags.args;
@@ -821,23 +901,29 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				ctx,
 				subagent.override,
 				cwdOverride,
+				chainContextEnabled,
 			);
 			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(
@@ -962,8 +1048,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			notify(ctx, `Invalid --cwd path: must be absolute`, "error");
 			return;
 		}
-		const loop = extractLoopCount(subagent.args);
-		const cleanedArgs = loop ? loop.args : subagent.args;
+		const extracted = extractChainContextFlag(subagent.args);
+		const loop = extractLoopCount(extracted.args);
+		const cleanedArgs = loop ? loop.args : extracted.args;
 
 		const { steps, sharedArgs, invalidSegments } = parseChainSteps(cleanedArgs);
 		if (invalidSegments.length > 0) {
@@ -985,6 +1072,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			ctx,
 			subagent.override,
 			runtimeCwd,
+			extracted.chainContext,
 		);
 	}
 

package/loop-utils.ts

@@ -7,6 +7,13 @@ interface DelegatedMessageDetails {
 	parallelResults?: Array<{ messages?: Message[] }>;
 }
 
+interface CollectedSummaryData {
+	filesRead: Set<string>;
+	filesWritten: Set<string>;
+	commandCount: number;
+	lastAssistantText: string;
+}
+
 function collectAssistantActions(messages: Message[], filesRead: Set<string>, filesWritten: Set<string>): { commandCount: number; lastText: string } {
 	let commandCount = 0;
 	let lastText = "";
@@ -39,7 +46,7 @@ function delegatedDetails(entry: SessionEntry): DelegatedMessageDetails | undefi
 	return entry.details as DelegatedMessageDetails;
 }
 
-export function generateIterationSummary(entries: SessionEntry[], task: string, iteration: number, totalIterations: number | null): string {
+function collectSummaryData(entries: SessionEntry[]): CollectedSummaryData {
 	const filesRead = new Set<string>();
 	const filesWritten = new Set<string>();
 	let commandCount = 0;
@@ -68,7 +75,18 @@ export function generateIterationSummary(entries: SessionEntry[], task: string,
 		}
 	}
 
-	let summary = totalIterations !== null ? `[Loop iteration ${iteration}/${totalIterations}]\nTask: "${task}"` : `[Loop iteration ${iteration}]\nTask: "${task}"`;
+	return {
+		filesRead,
+		filesWritten,
+		commandCount,
+		lastAssistantText,
+	};
+}
+
+function formatSummary(header: string, entries: SessionEntry[]): string {
+	const { filesRead, filesWritten, commandCount, lastAssistantText } = collectSummaryData(entries);
+
+	let summary = header;
 
 	const actionParts: string[] = [];
 	if (filesRead.size > 0) actionParts.push(`read ${filesRead.size} file(s)`);
@@ -87,6 +105,17 @@ export function generateIterationSummary(entries: SessionEntry[], task: string,
 	return summary;
 }
 
+export function generateIterationSummary(entries: SessionEntry[], task: string, iteration: number, totalIterations: number | null): string {
+	const header = totalIterations !== null
+		? `[Loop iteration ${iteration}/${totalIterations}]\nTask: "${task}"`
+		: `[Loop iteration ${iteration}]\nTask: "${task}"`;
+	return formatSummary(header, entries);
+}
+
+export function generateChainStepSummary(entries: SessionEntry[], stepLabel: string, stepNumber: number): string {
+	return formatSummary(`Step ${stepNumber} — ${stepLabel}:`, entries);
+}
+
 export function didIterationMakeChanges(entries: SessionEntry[]): boolean {
 	for (const entry of entries) {
 		if (entry.type === "message") {
@@ -124,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.4",
+  "version": "0.6.6",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",

package/prompt-loader.ts

@@ -38,11 +38,14 @@ export interface PromptWithModel {
 	content: string;
 	models: string[];
 	chain?: string;
+	chainContext?: "summary";
 	restore: boolean;
 	skill?: string;
 	thinking?: ThinkingLevel;
+	thinkingLevels?: ThinkingLevel[];
+	rotate?: boolean;
 	fresh?: boolean;
-	loop?: number;
+	loop?: number | null;
 	converge?: boolean;
 	subagent?: true | string;
 	inheritContext?: boolean;
@@ -242,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;
@@ -266,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;
@@ -432,6 +464,29 @@ function normalizeChain(
 	return undefined;
 }
 
+function normalizeChainContext(
+	value: unknown,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): "summary" | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "summary") return "summary";
+	}
+
+	diagnostics.push(
+		createDiagnostic(
+			"invalid-chain-context",
+			filePath,
+			source,
+			`Ignoring invalid chainContext value in ${filePath}: frontmatter field "chainContext" must be "summary".`,
+		),
+	);
+	return undefined;
+}
+
 function normalizeThinking(
 	value: unknown,
 	filePath: string,
@@ -457,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,
@@ -542,6 +639,7 @@ function loadPromptsWithModelFromDir(
 				if (!frontmatter) continue;
 				const { body } = parsed;
 				const chain = normalizeChain(frontmatter.chain, fullPath, source, diagnostics);
+				const chainContext = chain ? normalizeChainContext(frontmatter.chainContext, fullPath, source, diagnostics) : undefined;
 				if (chain && /\bparallel\s*\(/.test(chain)) {
 					const parsedChain = parseChainDeclaration(chain);
 					if (parsedChain.invalidSegments.length > 0 || parsedChain.steps.length === 0) {
@@ -594,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)) {
@@ -612,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);
@@ -637,11 +744,14 @@ function loadPromptsWithModelFromDir(
 					content: body,
 					models,
 					chain: chain || undefined,
+					chainContext,
 					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,
@@ -721,18 +831,21 @@ export function loadPromptsWithModel(cwd: string): LoadPromptsWithModelResult {
 export function buildPromptCommandDescription(prompt: PromptWithModel): string {
 	const sourceLabel = prompt.subdir ? `(${prompt.source}:${prompt.subdir})` : `(${prompt.source})`;
 	if (prompt.chain) {
+		const chainContextLabel = prompt.chainContext ? ` ${prompt.chainContext}` : "";
 		const cwdLabel = prompt.cwd ? ` cwd:${prompt.cwd}` : "";
-		const details = `[chain: ${prompt.chain}${cwdLabel}] ${sourceLabel}`;
+		const details = `[chain: ${prompt.chain}${chainContextLabel}${cwdLabel}] ${sourceLabel}`;
 		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;
 }
 

package/subagent-step.ts

@@ -38,6 +38,7 @@ interface DelegatedPromptBaseOptions {
 	override?: SubagentOverride;
 	signal?: AbortSignal;
 	inheritedModel?: Model<any>;
+	taskPreamble?: string;
 }
 
 interface DelegatedSinglePromptOptions extends DelegatedPromptBaseOptions {
@@ -156,6 +157,7 @@ async function prepareDelegatedTask(
 	currentModel: Model<any> | undefined,
 	override: SubagentOverride | undefined,
 	inheritedModel: Model<any> | undefined,
+	taskPreamble: string | undefined,
 	runtime: Awaited<ReturnType<typeof ensureSubagentRuntime>>,
 ): Promise<PreparedDelegatedTask> {
 	const requestedAgent = resolveDelegationName(task.prompt, override);
@@ -183,11 +185,15 @@ async function prepareDelegatedTask(
 	if (effectiveCwd !== ctx.cwd && !existsSync(effectiveCwd)) {
 		throw new Error(`cwd directory does not exist: ${effectiveCwd}`);
 	}
+	let taskText = prepared.content;
+	if (!task.prompt.inheritContext && taskPreamble) {
+		taskText = `${taskPreamble}\n\n---\n\n${prepared.content}`;
+	}
 
 	return {
 		promptName: task.prompt.name,
 		agent,
-		task: prepared.content,
+		task: taskText,
 		context: task.prompt.inheritContext ? "fork" : "fresh",
 		model: `${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`,
 		cwd: effectiveCwd,
@@ -429,7 +435,7 @@ async function requestDelegatedRun(
 }
 
 export async function executeSubagentPromptStep(options: DelegatedPromptOptions): Promise<DelegatedPromptOutcome | undefined> {
-	const { pi, ctx, currentModel, override, signal, inheritedModel } = options;
+	const { pi, ctx, currentModel, override, signal, inheritedModel, taskPreamble } = options;
 	const runtime = await ensureSubagentRuntime(ctx.cwd);
 	const isParallelRequest = "parallel" in options;
 
@@ -440,7 +446,7 @@ export async function executeSubagentPromptStep(options: DelegatedPromptOptions)
 
 	const preparedTasks: PreparedDelegatedTask[] = [];
 	for (const task of tasks) {
-		const preparedTask = await prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, runtime);
+		const preparedTask = await prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, taskPreamble, runtime);
 		preparedTasks.push(preparedTask);
 	}
 

package/tool-manager.ts

@@ -61,10 +61,10 @@ export function createToolManager(pi: ExtensionAPI, deps: ToolManagerDeps) {
 				"Supports --loop for loops (e.g. 'deslop --loop 5', 'deslop --loop=5', 'deslop --loop' for unlimited until convergence with a 50-iteration cap), " +
 				"--fresh for context collapse between iterations, and --no-converge to disable early stopping for bounded loops. " +
 				"Supports runtime delegation override via --subagent, --subagent=<name>, or --subagent:<name>. " +
-				"Use 'chain-prompts template1 -> template2' for chaining.",
+				"Use 'chain-prompts template1 -> template2' for chaining and add --chain-context to pass previous step summaries into delegated steps.",
 			parameters: Type.Object({
 				command: Type.String({
-					description: "Template name and arguments (e.g. 'deslop --loop 5 --fresh', 'deslop --subagent:worker', 'deslop --subagent', 'chain-prompts analyze -> fix --loop=3')",
+					description: "Template name and arguments (e.g. 'deslop --loop 5 --fresh', 'deslop --subagent:worker', 'deslop --subagent', 'chain-prompts analyze -> fix --chain-context', 'chain-prompts analyze -> fix --loop=3')",
 				}),
 			}),
 			execute: async (_id, params) => {