pi-prompt-template-model 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [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
+
+### Fixed
+- Updated skill command resolution to use `sourceInfo.path` instead of the removed `path` field on `SlashCommandInfo`, fixing compatibility with pi-coding-agent 0.62.0 source provenance changes.
+
 ## [0.6.3] - 2026-03-21
 
 ### Added

package/README.md

@@ -62,6 +62,7 @@ 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
 
@@ -328,6 +329,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 +387,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

@@ -163,6 +163,50 @@ 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;

package/chain-parser.ts

@@ -4,6 +4,7 @@ export interface ChainStep {
 	name: string;
 	args: string[];
 	loopCount?: number;
+	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; 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 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);
@@ -114,17 +123,18 @@ function extractStepLoopCount(segment: string): { cleanedSegment: string; loopCo
 		}
 	}
 
-	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 +202,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 } 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";
@@ -131,9 +131,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 		for (const command of pi.getCommands()) {
 			if (command.source !== "skill") continue;
-			if (!command.path) continue;
+			if (!command.sourceInfo.path) continue;
 			if (!candidates.has(command.name)) continue;
-			return command.path;
+			return command.sourceInfo.path;
 		}
 
 		return undefined;
@@ -195,6 +195,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		currentModel: Model<any> | undefined,
 		override?: SubagentOverride,
 		inheritedModel?: Model<any>,
+		taskPreamble?: string,
 	): Promise<PromptStepResult | "aborted"> {
 		if (shouldDelegatePrompt(prompt, override)) {
 			try {
@@ -206,6 +207,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");
@@ -496,6 +498,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		ctx: ExtensionCommandContext,
 		subagentOverride?: SubagentOverride,
 		cwdOverride?: string,
+		chainContextEnabled = false,
 	) {
 		const flattenChainSteps = (): ChainStep[] => {
 			const flattened: ChainStep[] = [];
@@ -524,6 +527,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) {
@@ -599,14 +606,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,
+								stepWithContext: step.withContext === true,
 							},
 						},
 				);
+				const chainStepSummaries: string[] = [];
 				let aborted = false;
 				let iterationChanged = false;
 				let loopPrefix = "";
@@ -619,10 +630,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 +654,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,14 +669,21 @@ 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 stepLoop = singleStep.stepLoop;
+					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;
+					const stepStartId = ctx.sessionManager.getLeafId();
 					if (stepLoop > 1) {
 						loopState = { currentIteration: 1, totalIterations: stepLoop };
 						updateLoopStatus(ctx);
@@ -671,19 +697,27 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 							}
 
 							const iterSuffix = stepLoop > 1 ? ` (iter ${stepIteration + 1}/${stepLoop})` : "";
-							notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: ${template.name}${iterSuffix} ${buildPromptCommandDescription(template)}`, "info");
+							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 stepIterationStartId = ctx.sessionManager.getLeafId();
 							const stepResult = await executePromptStep(
-								template,
+								singleStep.prompt,
 								effectiveArgs,
 								ctx,
 								currentModel,
 								subagentOverride,
 								chainInheritedModel,
+								taskPreamble,
 							);
 							if (stepResult === "aborted") {
 								aborted = true;
@@ -693,11 +727,9 @@ 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 (stepLoop > 1 && singleStep.prompt.converge !== false && !stepIterationChanged) {
 								break;
 							}
 						}
@@ -709,6 +741,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					}
 
 					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 +817,13 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		const argsWithoutSubagent = subagent.args;
 
 		if (prompt.chain) {
-			const loop = extractLoopCount(argsWithoutSubagent);
+			const extracted = extractChainContextFlag(argsWithoutSubagent);
+			const chainContextEnabled = extracted.chainContext || prompt.chainContext === "summary";
+			const loop = extractLoopCount(extracted.args);
 			let totalIterations: number | null = prompt.loop ?? 1;
 			let fresh = false;
 			let converge = true;
-			let cleanedArgs = argsWithoutSubagent;
+			let cleanedArgs = extracted.args;
 
 			if (loop) {
 				totalIterations = loop.loopCount;
@@ -794,7 +831,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,6 +858,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				ctx,
 				subagent.override,
 				cwdOverride,
+				chainContextEnabled,
 			);
 			return;
 		}
@@ -962,8 +1000,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 +1024,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") {

package/package.json

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

package/prompt-loader.ts

@@ -38,6 +38,7 @@ export interface PromptWithModel {
 	content: string;
 	models: string[];
 	chain?: string;
+	chainContext?: "summary";
 	restore: boolean;
 	skill?: string;
 	thinking?: ThinkingLevel;
@@ -432,6 +433,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,
@@ -542,6 +566,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) {
@@ -637,6 +662,7 @@ function loadPromptsWithModelFromDir(
 					content: body,
 					models,
 					chain: chain || undefined,
+					chainContext,
 					restore,
 					skill,
 					thinking,
@@ -721,8 +747,9 @@ 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";

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) => {