pi-prompt-template-model 0.6.2 → 0.6.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.6.3] - 2026-03-21
+
+### Added
+- Chain step progress now shows in the status bar (e.g., `step 2/3: simplify`) and persists until the chain completes, instead of only appearing as a notification that scrolls away.
+- Added `parallel(...)` chain step support for delegated prompt templates, including parser/frontmatter validation, delegated task fan-out, aggregated result rendering, and per-task progress display.
+
+### Fixed
+- Delegated subagent errors now show as clean notifications instead of extension crash messages with stack traces, matching how other validation errors (missing skill, missing template, etc.) are presented.
+- When no subagent bridge is listening (extension not loaded, name collision with another extension), delegation now fails immediately with a diagnostic message instead of silently waiting 15 seconds before timing out.
+- Timeout error message no longer dumps the full rendered prompt content; uses the agent name instead.
+- Parallel delegated status now prefers aggregate `parallel X/Y running` updates over first-task tool labels, avoiding misleading `running <tool>` status lines during multi-task execution.
+
 ## [0.6.2] - 2026-03-20
 
 ### Added

package/README.md

@@ -301,6 +301,16 @@ chain: double-check --loop 2 -> deslop --loop 2
 
 This registers the file's name as a command that runs `double-check` twice, then `deslop` twice. Per-step `--loop N` repeats that step before moving to the next, with per-step convergence (stops early if no changes, unless the step's template has `converge: false`).
 
+Chain declarations also support parallel groups with `parallel(...)`:
+
+```markdown
+---
+chain: parallel(scan-frontend, scan-backend) -> consolidate
+---
+```
+
+Each entry inside `parallel(...)` runs as a delegated subagent task concurrently. Parallel entries can include per-step args (for example `parallel(scan-frontend, scan-backend "auth")`), but per-step `--loop` is not supported inside parallel groups. Nested `parallel(...)` is rejected. Parallel entries must be delegated templates (`subagent: ...` or runtime `--subagent` override), and all entries in the same parallel group must resolve to the same `inheritContext` mode and `cwd`.
+
 Steps with a `model` field use their own model. Steps without one inherit a snapshot of whatever model was active when the chain started — not the previous step's model. This keeps behavior deterministic regardless of what earlier steps do.
 
 Chain templates support `loop`, `fresh`, `converge`, `restore`, and `cwd` in their frontmatter for controlling the overall execution:
@@ -318,7 +328,15 @@ 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.
 
-### Looping chains from the CLI
+### Parallel and looping from the CLI
+
+Parallel groups work in `/chain-prompts` too:
+
+```
+/chain-prompts parallel(scan-fe, scan-be) -> review
+```
+
+Looping applies to the entire chain:
 
 ```
 /chain-prompts analyze -> fix --loop 3

package/chain-parser.ts

@@ -1,4 +1,4 @@
-import { parseCommandArgs, splitByUnquotedSeparator } from "./args.js";
+import { parseCommandArgs } from "./args.js";
 
 export interface ChainStep {
 	name: string;
@@ -6,14 +6,20 @@ export interface ChainStep {
 	loopCount?: number;
 }
 
+export interface ParallelChainStep {
+	parallel: ChainStep[];
+}
+
+export type ChainStepOrParallel = ChainStep | ParallelChainStep;
+
 export interface ParsedChainSteps {
-	steps: ChainStep[];
+	steps: ChainStepOrParallel[];
 	sharedArgs: string[];
 	invalidSegments: string[];
 }
 
 export interface ParsedChainDeclaration {
-	steps: ChainStep[];
+	steps: ChainStepOrParallel[];
 	invalidSegments: string[];
 }
 
@@ -121,27 +127,130 @@ function extractStepLoopCount(segment: string): { cleanedSegment: string; loopCo
 	return { cleanedSegment: cleanedSegment.trim(), loopCount };
 }
 
+function splitByTopLevelSeparator(input: string, separator: string): string[] {
+	const parts: string[] = [];
+	let start = 0;
+	let inQuote: string | null = null;
+	let parenDepth = 0;
+
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		if (inQuote) {
+			if (char === inQuote) inQuote = null;
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			inQuote = char;
+			continue;
+		}
+		if (char === "(") {
+			parenDepth++;
+			continue;
+		}
+		if (char === ")" && parenDepth > 0) {
+			parenDepth--;
+			continue;
+		}
+
+		if (parenDepth === 0 && i <= input.length - separator.length && input.startsWith(separator, i)) {
+			parts.push(input.slice(start, i));
+			start = i + separator.length;
+			i += separator.length - 1;
+		}
+	}
+
+	parts.push(input.slice(start));
+	return parts;
+}
+
+function findMatchingParen(segment: string, openIndex: number): number {
+	let inQuote: string | null = null;
+	let depth = 0;
+
+	for (let i = openIndex; i < segment.length; i++) {
+		const char = segment[i];
+		if (inQuote) {
+			if (char === inQuote) inQuote = null;
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			inQuote = char;
+			continue;
+		}
+		if (char === "(") {
+			depth++;
+			continue;
+		}
+		if (char !== ")") continue;
+		depth--;
+		if (depth === 0) return i;
+	}
+
+	return -1;
+}
+
+function parseSingleStepSegment(segment: string): ChainStep | undefined {
+	const { cleanedSegment, loopCount } = extractStepLoopCount(segment);
+	const tokens = parseCommandArgs(cleanedSegment);
+	if (tokens.length === 0) return undefined;
+	return { name: tokens[0], args: tokens.slice(1), loopCount };
+}
+
+function parseParallelStepSegment(segment: string): ParallelChainStep | undefined {
+	if (!/^parallel\s*\(/.test(segment)) return undefined;
+	const openIndex = segment.indexOf("(");
+	if (openIndex < 0) return undefined;
+
+	const closeIndex = findMatchingParen(segment, openIndex);
+	if (closeIndex < 0) return undefined;
+	if (segment.slice(closeIndex + 1).trim().length > 0) return undefined;
+
+	const inner = segment.slice(openIndex + 1, closeIndex).trim();
+	if (!inner) return undefined;
+
+	const parsedSteps: ChainStep[] = [];
+	for (const rawEntry of splitByTopLevelSeparator(inner, ",")) {
+		const entry = rawEntry.trim();
+		if (!entry) return undefined;
+		if (/^parallel\s*\(/.test(entry)) return undefined;
+		const parsed = parseSingleStepSegment(entry);
+		if (!parsed) return undefined;
+		parsedSteps.push(parsed);
+	}
+
+	if (parsedSteps.length === 0) return undefined;
+	return { parallel: parsedSteps };
+}
+
+function parseChainSegment(segment: string): ChainStepOrParallel | undefined {
+	const parallelStep = parseParallelStepSegment(segment);
+	if (parallelStep) return parallelStep;
+	if (/^parallel\s*\(/.test(segment)) return undefined;
+	return parseSingleStepSegment(segment);
+}
+
 export function parseChainSteps(args: string): ParsedChainSteps {
-	const sharedArgsSplit = splitByUnquotedSeparator(args, " -- ");
+	const sharedArgsSplit = splitByTopLevelSeparator(args, " -- ");
 	const templatesPart = sharedArgsSplit[0];
 	const argsPart = sharedArgsSplit.length > 1 ? sharedArgsSplit.slice(1).join(" -- ") : "";
 
 	const invalidSegments: string[] = [];
-	const steps: ChainStep[] = [];
+	const steps: ChainStepOrParallel[] = [];
 
-	for (const rawSegment of splitByUnquotedSeparator(templatesPart, "->")) {
+	for (const rawSegment of splitByTopLevelSeparator(templatesPart, "->")) {
 		const segment = rawSegment.trim();
 		if (!segment) {
 			invalidSegments.push(rawSegment);
 			continue;
 		}
-		const { cleanedSegment, loopCount } = extractStepLoopCount(segment);
-		const tokens = parseCommandArgs(cleanedSegment);
-		if (tokens.length === 0) {
+		const parsedSegment = parseChainSegment(segment);
+		if (!parsedSegment) {
 			invalidSegments.push(segment);
 			continue;
 		}
-		steps.push({ name: tokens[0], args: tokens.slice(1), loopCount });
+		steps.push(parsedSegment);
 	}
 
 	return { steps, sharedArgs: parseCommandArgs(argsPart), invalidSegments };
@@ -149,27 +258,20 @@ export function parseChainSteps(args: string): ParsedChainSteps {
 
 export function parseChainDeclaration(chain: string): ParsedChainDeclaration {
 	const invalidSegments: string[] = [];
-	const steps: ChainStep[] = [];
+	const steps: ChainStepOrParallel[] = [];
 
-	for (const rawSegment of splitByUnquotedSeparator(chain, "->")) {
+	for (const rawSegment of splitByTopLevelSeparator(chain, "->")) {
 		const segment = rawSegment.trim();
 		if (!segment) {
 			invalidSegments.push(rawSegment);
 			continue;
 		}
-
-		const { cleanedSegment, loopCount } = extractStepLoopCount(segment);
-		const tokens = parseCommandArgs(cleanedSegment);
-		if (tokens.length === 0) {
+		const parsedSegment = parseChainSegment(segment);
+		if (!parsedSegment) {
 			invalidSegments.push(segment);
 			continue;
 		}
-
-		steps.push({
-			name: tokens[0],
-			args: tokens.slice(1),
-			loopCount,
-		});
+		steps.push(parsedSegment);
 	}
 
 	return { steps, invalidSegments };

package/index.ts

@@ -2,7 +2,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, extractSubagentOverride, parseCommandArgs, type SubagentOverride } from "./args.js";
-import { parseChainSteps, parseChainDeclaration, type ChainStep } from "./chain-parser.js";
+import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.js";
 import { generateIterationSummary, didIterationMakeChanges, getIterationEntries } from "./loop-utils.js";
 import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.js";
 import { preparePromptExecution } from "./prompt-execution.js";
@@ -184,6 +184,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		return prompt.subagent !== undefined || override?.enabled === true;
 	}
 
+	function isParallelChainStep(step: ChainStepOrParallel): step is ParallelChainStep {
+		return "parallel" in step;
+	}
+
 	async function executePromptStep(
 		prompt: PromptWithModel,
 		args: string[],
@@ -193,19 +197,25 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		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.`);
+			try {
+				const delegated = await executeSubagentPromptStep({
+					pi,
+					prompt,
+					args,
+					ctx,
+					currentModel,
+					override,
+					inheritedModel,
+				});
+				if (!delegated) {
+					notify(ctx, `Prompt \`${prompt.name}\` is not configured for delegated execution.`, "error");
+					return "aborted";
+				}
+				return { changed: delegated.changed };
+			} catch (error) {
+				notify(ctx, error instanceof Error ? error.message : String(error), "error");
+				return "aborted";
 			}
-			return { changed: delegated.changed };
 		}
 
 		const prepared =
@@ -477,7 +487,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	}
 
 	async function runSharedChainExecution(
-		steps: ChainStep[],
+		steps: ChainStepOrParallel[],
 		sharedArgs: string[],
 		totalIterations: number | null,
 		fresh: boolean,
@@ -487,14 +497,47 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		subagentOverride?: SubagentOverride,
 		cwdOverride?: string,
 	) {
+		const flattenChainSteps = (): ChainStep[] => {
+			const flattened: ChainStep[] = [];
+			for (const step of steps) {
+				if (isParallelChainStep(step)) {
+					flattened.push(...step.parallel);
+				} else {
+					flattened.push(step);
+				}
+			}
+			return flattened;
+		};
+
 		const validateChainSteps = (): boolean => {
-			const missingTemplates = steps.filter((step) => !prompts.has(step.name));
+			const flattened = flattenChainSteps();
+			const missingTemplates = flattened.filter((step) => !prompts.has(step.name));
 			if (missingTemplates.length > 0) {
 				notify(ctx, `Templates not found: ${missingTemplates.map((step) => step.name).join(", ")}`, "error");
 				return false;
 			}
 
 			for (const step of steps) {
+				if (isParallelChainStep(step)) {
+					for (const parallelStep of step.parallel) {
+						if (parallelStep.loopCount !== undefined) {
+							notify(ctx, `Step "${parallelStep.name}" in parallel() does not support per-task --loop.`, "error");
+							return false;
+						}
+						const stepPrompt = prompts.get(parallelStep.name);
+						if (!stepPrompt) continue;
+						if (stepPrompt.chain) {
+							notify(ctx, `Step "${parallelStep.name}" is a chain template. Chain nesting is not supported.`, "error");
+							return false;
+						}
+						if (!shouldDelegatePrompt(stepPrompt, subagentOverride)) {
+							notify(ctx, `Step "${parallelStep.name}" in parallel() must use delegated execution (subagent).`, "error");
+							return false;
+						}
+					}
+					continue;
+				}
+
 				const stepPrompt = prompts.get(step.name);
 				if (!stepPrompt) continue;
 				if (stepPrompt.chain) {
@@ -509,7 +552,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		if (!validateChainSteps()) return;
 
 		const originalModel = getCurrentModel(ctx);
-		const chainInheritedModel = getCurrentModel(ctx);
+		const chainInheritedModel = originalModel;
 		const originalThinking = pi.getThinkingLevel();
 		let currentModel = originalModel;
 		let currentThinking = originalThinking;
@@ -520,7 +563,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const useConverge = isUnlimited ? true : converge;
 
 		const anchorId = fresh ? ctx.sessionManager.getLeafId() : null;
-		const chainStepNames = steps.map((step) => step.name).join(" -> ");
+		const chainStepNames = steps
+			.map((step) => (isParallelChainStep(step) ? `parallel(${step.parallel.map((item) => item.name).join(", ")})` : step.name))
+			.join(" -> ");
 		let completedIterations = 0;
 		let converged = false;
 		let chainErrorState: ExecutionErrorState = { hasError: false, error: undefined };
@@ -539,17 +584,77 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					if (!validateChainSteps()) break;
 				}
 
-				const templates = steps.map((step) => ({
-					...prompts.get(step.name)!,
-					...(cwdOverride ? { cwd: cwdOverride } : {}),
-					stepArgs: step.args,
-					stepLoop: step.loopCount ?? 1,
-				}));
+				const templates = steps.map((step) =>
+					isParallelChainStep(step)
+						? {
+							kind: "parallel" as const,
+							tasks: step.parallel.map((item) => ({
+								name: item.name,
+								args: item.args,
+								prompt: {
+									...prompts.get(item.name)!,
+									...(cwdOverride ? { cwd: cwdOverride } : {}),
+								},
+							})),
+						}
+						: {
+							kind: "single" as const,
+							template: {
+								...prompts.get(step.name)!,
+								...(cwdOverride ? { cwd: cwdOverride } : {}),
+								stepArgs: step.args,
+								stepLoop: step.loopCount ?? 1,
+							},
+						},
+				);
 				let aborted = false;
 				let iterationChanged = false;
+				let loopPrefix = "";
+				if (effectiveMax > 1) {
+					const label = totalIterations !== null ? `${iteration + 1}/${totalIterations}` : `${iteration + 1}`;
+					loopPrefix = `Loop ${label}, `;
+				}
 
-				for (const [index, template] of templates.entries()) {
+				for (const [index, stepTemplate] of templates.entries()) {
 					const stepNumber = index + 1;
+					if (stepTemplate.kind === "parallel") {
+						const stepNames = stepTemplate.tasks.map((task) => task.name).join(", ");
+						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})`));
+						}
+
+						let delegated;
+						try {
+							delegated = await executeSubagentPromptStep({
+								pi,
+								ctx,
+								currentModel,
+								override: subagentOverride,
+								inheritedModel: chainInheritedModel,
+								parallel: stepTemplate.tasks.map((task) => ({
+									prompt: task.prompt,
+									args: task.args.length > 0 ? task.args : sharedArgs,
+								})),
+							});
+						} catch (error) {
+							notify(ctx, error instanceof Error ? error.message : String(error), "error");
+							aborted = true;
+							break;
+						}
+						if (!delegated) {
+							notify(ctx, "Parallel chain step was not delegated.", "error");
+							aborted = true;
+							break;
+						}
+
+						currentModel = getCurrentModel(ctx);
+						currentThinking = pi.getThinkingLevel();
+						if (delegated.changed) iterationChanged = true;
+						continue;
+					}
+
+					const template = stepTemplate.template;
 					const stepLoop = template.stepLoop;
 					const effectiveArgs = template.stepArgs.length > 0 ? template.stepArgs : sharedArgs;
 					const outerLoopState = loopState ? { ...loopState } : null;
@@ -565,14 +670,11 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								updateLoopStatus(ctx);
 							}
 
-							const loopPrefix =
-								effectiveMax > 1
-									? totalIterations !== null
-										? `Loop ${iteration + 1}/${totalIterations}, `
-										: `Loop ${iteration + 1}, `
-									: "";
 							const iterSuffix = stepLoop > 1 ? ` (iter ${stepIteration + 1}/${stepLoop})` : "";
 							notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: ${template.name}${iterSuffix} ${buildPromptCommandDescription(template)}`, "info");
+							if (ctx.hasUI) {
+								ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: ${template.name}`));
+							}
 
 							const stepIterationStartId = ctx.sessionManager.getLeafId();
 							const stepResult = await executePromptStep(
@@ -648,6 +750,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			freshCollapse = null;
 			accumulatedSummaries = [];
 			updateLoopStatus(ctx);
+			if (ctx.hasUI) {
+				ctx.ui.setStatus("prompt-chain", undefined);
+			}
 
 			if (!chainErrorState.hasError) {
 				notifyLoopCompletion(ctx, completedIterations, totalIterations, effectiveMax, converged, true);

package/loop-utils.ts

@@ -4,6 +4,7 @@ import { PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.js";
 
 interface DelegatedMessageDetails {
 	messages?: Message[];
+	parallelResults?: Array<{ messages?: Message[] }>;
 }
 
 function collectAssistantActions(messages: Message[], filesRead: Set<string>, filesWritten: Set<string>): { commandCount: number; lastText: string } {
@@ -55,10 +56,16 @@ export function generateIterationSummary(entries: SessionEntry[], task: string,
 		}
 
 		const delegated = delegatedDetails(entry);
-		if (!delegated?.messages) continue;
-		const collected = collectAssistantActions(delegated.messages, filesRead, filesWritten);
-		commandCount += collected.commandCount;
-		if (collected.lastText) lastAssistantText = collected.lastText;
+		if (!delegated) continue;
+		const messageGroups =
+			delegated.parallelResults && delegated.parallelResults.length > 0
+				? delegated.parallelResults.map((result) => result.messages ?? [])
+				: delegated.messages ? [delegated.messages] : [];
+		for (const messages of messageGroups) {
+			const collected = collectAssistantActions(messages, filesRead, filesWritten);
+			commandCount += collected.commandCount;
+			if (collected.lastText) lastAssistantText = collected.lastText;
+		}
 	}
 
 	let summary = totalIterations !== null ? `[Loop iteration ${iteration}/${totalIterations}]\nTask: "${task}"` : `[Loop iteration ${iteration}]\nTask: "${task}"`;
@@ -92,12 +99,18 @@ export function didIterationMakeChanges(entries: SessionEntry[]): boolean {
 		}
 
 		const delegated = delegatedDetails(entry);
-		if (!delegated?.messages) continue;
-		for (const message of delegated.messages) {
-			if (message.role !== "assistant") continue;
-			for (const block of (message as AssistantMessage).content) {
-				if (block.type !== "toolCall") continue;
-				if (block.name === "write" || block.name === "edit") return true;
+		if (!delegated) continue;
+		const delegatedGroups =
+			delegated.parallelResults && delegated.parallelResults.length > 0
+				? delegated.parallelResults.map((result) => result.messages ?? [])
+				: [delegated.messages ?? []];
+		for (const messages of delegatedGroups) {
+			for (const message of messages) {
+				if (message.role !== "assistant") continue;
+				for (const block of (message as AssistantMessage).content) {
+					if (block.type !== "toolCall") continue;
+					if (block.name === "write" || block.name === "edit") return true;
+				}
 			}
 		}
 	}

package/package.json

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

package/prompt-loader.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
+import { parseChainDeclaration } from "./chain-parser.js";
 
 const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 export const RESERVED_COMMAND_NAMES = new Set([
@@ -541,6 +542,20 @@ function loadPromptsWithModelFromDir(
 				if (!frontmatter) continue;
 				const { body } = parsed;
 				const chain = normalizeChain(frontmatter.chain, fullPath, source, diagnostics);
+				if (chain && /\bparallel\s*\(/.test(chain)) {
+					const parsedChain = parseChainDeclaration(chain);
+					if (parsedChain.invalidSegments.length > 0 || parsedChain.steps.length === 0) {
+						diagnostics.push(
+							createDiagnostic(
+								"invalid-chain-declaration",
+								fullPath,
+								source,
+								`Skipping prompt template at ${fullPath}: invalid chain declaration segment ${JSON.stringify(parsedChain.invalidSegments[0] ?? chain)}.`,
+							),
+						);
+						continue;
+					}
+				}
 				let subagent = normalizeSubagent(frontmatter.subagent, fullPath, source, diagnostics);
 				const cwd = normalizeCwd(frontmatter.cwd, fullPath, source, diagnostics);
 				const inheritContext = normalizeInheritContext(frontmatter.inheritContext, fullPath, source, diagnostics);