pi-subagents 0.14.0 → 0.15.0

package/async-execution.ts

@@ -16,6 +16,7 @@ import { isParallelStep, resolveStepBehavior, type ChainStep, type SequentialSte
 import type { RunnerStep } from "./parallel-utils.ts";
 import { resolvePiPackageRoot } from "./pi-spawn.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "./skills.ts";
+import { resolveChildCwd } from "./utils.ts";
 import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "./model-fallback.ts";
 import {
 	type ArtifactConfig,
@@ -163,6 +164,7 @@ export function executeAsyncChain(
 	} = params;
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
+	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 
 	for (const s of chain) {
 		const stepAgents = isParallelStep(s)
@@ -193,27 +195,27 @@ export function executeAsyncChain(
 
 	const buildSeqStep = (s: SequentialStep, sessionFile?: string) => {
 		const a = agents.find((x) => x.name === s.agent)!;
+		const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
 		const stepSkillInput = normalizeSkillInput(s.skill);
 		const stepOverrides: StepOverrides = { skills: stepSkillInput };
 		const behavior = resolveStepBehavior(a, stepOverrides, chainSkills);
 		const skillNames = behavior.skills === false ? [] : behavior.skills;
-		const skillCwd = s.cwd ?? cwd ?? ctx.cwd;
-		const { resolved: resolvedSkills } = resolveSkillsWithFallback(skillNames, skillCwd, ctx.cwd);
+		const { resolved: resolvedSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd);
 
-		let systemPrompt = a.systemPrompt?.trim() || null;
+		let systemPrompt = a.systemPrompt?.trim() ?? "";
 		if (resolvedSkills.length > 0) {
 			const injection = buildSkillInjection(resolvedSkills);
 			systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
 		}
 
-		const outputPath = resolveSingleOutputPath(s.output, ctx.cwd, s.cwd ?? cwd);
+		const outputPath = resolveSingleOutputPath(s.output, ctx.cwd, stepCwd);
 		const task = injectSingleOutputInstruction(s.task ?? "{previous}", outputPath);
 
 		const primaryModel = resolveModelCandidate(s.model ?? a.model, availableModels, ctx.currentModelProvider);
 		return {
 			agent: s.agent,
 			task,
-			cwd: s.cwd,
+			cwd: stepCwd,
 			model: applyThinkingSuffix(primaryModel, a.thinking),
 			modelCandidates: buildModelCandidates(s.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
 				applyThinkingSuffix(candidate, a.thinking),
@@ -222,6 +224,9 @@ export function executeAsyncChain(
 			extensions: a.extensions,
 			mcpDirectTools: a.mcpDirectTools,
 			systemPrompt,
+			systemPromptMode: a.systemPromptMode,
+			inheritProjectContext: a.inheritProjectContext,
+			inheritSkills: a.inheritSkills,
 			skills: resolvedSkills.map((r) => r.name),
 			outputPath,
 			sessionFile,
@@ -255,7 +260,6 @@ export function executeAsyncChain(
 		return buildSeqStep(s as SequentialStep, nextSessionFile());
 	});
 
-	const runnerCwd = cwd ?? ctx.cwd;
 	let pid: number | undefined;
 	try {
 		pid = spawnRunner(
@@ -340,11 +344,11 @@ export function executeAsyncSingle(
 		worktreeSetupHook,
 		worktreeSetupHookTimeoutMs,
 	} = params;
+	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const skillNames = params.skills ?? agentConfig.skills ?? [];
 	const availableModels = params.availableModels;
-	const skillCwd = cwd ?? ctx.cwd;
-	const { resolved: resolvedSkills } = resolveSkillsWithFallback(skillNames, skillCwd, ctx.cwd);
-	let systemPrompt = agentConfig.systemPrompt?.trim() || null;
+	const { resolved: resolvedSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd);
+	let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
 	if (resolvedSkills.length > 0) {
 		const injection = buildSkillInjection(resolvedSkills);
 		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
@@ -362,8 +366,7 @@ export function executeAsyncSingle(
 		};
 	}
 
-	const runnerCwd = cwd ?? ctx.cwd;
-	const outputPath = resolveSingleOutputPath(params.output, ctx.cwd, cwd);
+	const outputPath = resolveSingleOutputPath(params.output, ctx.cwd, runnerCwd);
 	const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath);
 	let pid: number | undefined;
 	try {
@@ -374,7 +377,7 @@ export function executeAsyncSingle(
 					{
 						agent,
 						task: taskWithOutputInstruction,
-						cwd,
+						cwd: runnerCwd,
 						model: applyThinkingSuffix(resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider), agentConfig.thinking),
 						modelCandidates: buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
 							applyThinkingSuffix(candidate, agentConfig.thinking),
@@ -383,6 +386,9 @@ export function executeAsyncSingle(
 						extensions: agentConfig.extensions,
 						mcpDirectTools: agentConfig.mcpDirectTools,
 						systemPrompt,
+						systemPromptMode: agentConfig.systemPromptMode,
+						inheritProjectContext: agentConfig.inheritProjectContext,
+						inheritSkills: agentConfig.inheritSkills,
 						skills: resolvedSkills.map((r) => r.name),
 						outputPath,
 						sessionFile,

package/async-job-tracker.ts

@@ -1,11 +1,11 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import * as path from "node:path";
-import { renderWidget } from "./render.js";
+import { renderWidget } from "./render.ts";
 import {
 	type SubagentState,
 	POLL_INTERVAL_MS,
-} from "./types.js";
-import { readStatus } from "./utils.js";
+} from "./types.ts";
+import { readStatus } from "./utils.ts";
 
 export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string): {
 	ensurePoller: () => void;

package/async-status.ts

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { formatDuration, formatTokens, shortenPath } from "./formatters.js";
-import { type AsyncStatus, type TokenUsage } from "./types.js";
-import { readStatus } from "./utils.js";
+import { formatDuration, formatTokens, shortenPath } from "./formatters.ts";
+import { type AsyncStatus, type TokenUsage } from "./types.ts";
+import { readStatus } from "./utils.ts";
 
 export interface AsyncRunStepSummary {
 	index: number;

package/chain-clarify.ts

@@ -987,7 +987,7 @@ export class ChainClarifyComponent implements Component {
 				const prefix = isSelected ? th.fg("accent", "→ ") : "  ";
 				const modelText = isSelected ? th.fg("accent", model.id) : model.id;
 				const providerBadge = th.fg("dim", ` [${model.provider}]`);
-				const currentBadge = isCurrent ? th.fg("success", " ✓") : "";
+				const currentBadge = isCurrent ? th.fg("success", " current") : "";
 
 				lines.push(this.row(` ${prefix}${modelText}${providerBadge}${currentBadge}`));
 			}
@@ -1269,7 +1269,7 @@ export class ChainClarifyComponent implements Component {
 		lines.push(this.row(` Chain Dir: ${th.fg("dim", chainDirPreview)}`));
 
 		const progressEnabled = this.agentConfigs.some((_, i) => this.getEffectiveBehavior(i).progress);
-		const progressValue = progressEnabled ? th.fg("success", "✓ enabled") : th.fg("dim", "✗ disabled");
+		const progressValue = progressEnabled ? th.fg("success", "enabled") : th.fg("dim", "disabled");
 		lines.push(this.row(` Progress: ${progressValue} ${th.fg("dim", "(press [p] to toggle)")}`));
 		lines.push(this.row(""));
 
@@ -1331,8 +1331,8 @@ export class ChainClarifyComponent implements Component {
 			if (progressEnabled) {
 				const isFirstStep = i === 0;
 				const progressAction = isFirstStep 
-					? th.fg("success", "●") + th.fg("dim", " creates & updates progress.md")
-					: th.fg("accent", "↔") + th.fg("dim", " reads & updates progress.md");
+					? th.fg("success", "writes progress.md")
+					: th.fg("accent", "reads progress.md");
 				const progressLabel = th.fg("dim", "progress: ");
 				lines.push(this.row(`     ${progressLabel}${progressAction}`));
 			}

package/chain-execution.ts

@@ -28,7 +28,7 @@ import {
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
 import { runSync } from "./execution.ts";
 import { buildChainSummary } from "./formatters.ts";
-import { getSingleResultOutput, mapConcurrent } from "./utils.ts";
+import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, resolveChildCwd } from "./utils.ts";
 import { recordRun } from "./run-history.ts";
 import {
 	cleanupWorktrees,
@@ -38,7 +38,7 @@ import {
 	formatWorktreeDiffSummary,
 	formatWorktreeTaskCwdConflict,
 	type WorktreeSetup,
-} from "./worktree.js";
+} from "./worktree.ts";
 import {
 	type AgentProgress,
 	type ArtifactConfig,
@@ -91,7 +91,7 @@ interface ParallelChainRunInput {
 }
 
 function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
-	return {
+	return compactForegroundDetails({
 		mode: "chain",
 		results: input.results,
 		progress: input.includeProgress ? input.allProgress : undefined,
@@ -99,7 +99,7 @@ function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details
 		chainAgents: input.chainAgents,
 		totalSteps: input.totalSteps,
 		currentStepIndex: input.currentStepIndex,
-	};
+	});
 }
 
 function buildChainExecutionErrorResult(message: string, input: ChainExecutionDetailsInput): ChainExecutionResult {
@@ -181,7 +181,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 
 			const taskCwd = input.worktreeSetup
 				? input.worktreeSetup.worktrees[taskIndex]!.agentCwd
-				: (task.cwd ?? input.cwd);
+				: resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd);
 
 			const outputPath = typeof behavior.output === "string"
 				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(input.chainDir, behavior.output))
@@ -412,7 +412,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 		if (isParallelStep(step)) {
 			const parallelTemplates = stepTemplates as string[];
-			const parallelCwd = step.cwd ?? cwd ?? ctx.cwd;
+			const parallelCwd = resolveChildCwd(cwd ?? ctx.cwd, step.cwd);
 			let worktreeSetup: WorktreeSetup | undefined;
 			if (step.worktree) {
 				const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(step.parallel, parallelCwd);
@@ -605,7 +605,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			const maxSubagentDepth = resolveChildMaxSubagentDepth(params.maxSubagentDepth, agentConfig.maxSubagentDepth);
 
 			const r = await runSync(ctx.cwd, agents, seqStep.agent, stepTask, {
-				cwd: seqStep.cwd ?? cwd,
+				cwd: resolveChildCwd(cwd ?? ctx.cwd, seqStep.cwd),
 				signal,
 				runId,
 				index: globalTaskIndex,
@@ -670,15 +670,16 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				});
 				return {
 					content: [{ type: "text", text: summary }],
-					details: {
-						mode: "chain",
+					details: buildChainExecutionDetails({
 						results,
-						progress: includeProgress ? allProgress : undefined,
-						artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+						includeProgress,
+						allProgress,
+						allArtifactPaths,
+						artifactsDir,
 						chainAgents,
 						totalSteps,
 						currentStepIndex: stepIndex,
-					},
+					}),
 					isError: true,
 				};
 			}
@@ -691,13 +692,14 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 	return {
 		content: [{ type: "text", text: summary }],
-		details: {
-			mode: "chain",
+		details: buildChainExecutionDetails({
 			results,
-			progress: includeProgress ? allProgress : undefined,
-			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+			includeProgress,
+			allProgress,
+			allArtifactPaths,
+			artifactsDir,
 			chainAgents,
 			totalSteps,
-		},
+		}),
 	};
 }

package/execution.ts

@@ -72,7 +72,6 @@ async function runSingleAttempt(
 	shared: {
 		sessionEnabled: boolean;
 		systemPrompt: string;
-		skillNames: string[];
 		resolvedSkillNames?: string[];
 		skillsWarning?: string;
 		jsonlPath?: string;
@@ -89,9 +88,11 @@ async function runSingleAttempt(
 		sessionFile: options.sessionFile,
 		model,
 		thinking: agent.thinking,
+		systemPromptMode: agent.systemPromptMode,
+		inheritProjectContext: agent.inheritProjectContext,
+		inheritSkills: agent.inheritSkills,
 		tools: agent.tools,
 		extensions: agent.extensions,
-		skills: shared.skillNames,
 		systemPrompt: shared.systemPrompt,
 		mcpDirectTools: agent.mcpDirectTools,
 		promptFileStem: agent.name,
@@ -413,7 +414,6 @@ export async function runSync(
 		const result = await runSingleAttempt(runtimeCwd, agent, task, candidate, options, {
 			sessionEnabled,
 			systemPrompt,
-			skillNames,
 			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
 			skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
 			jsonlPath,

package/formatters.ts

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Usage, SingleResult } from "./types.ts";
-import type { ChainStep, SequentialStep } from "./settings.ts";
+import type { ChainStep } from "./settings.ts";
 import { isParallelStep } from "./settings.ts";
 
 /**
@@ -49,16 +49,13 @@ export function buildChainSummary(
 	status: "completed" | "failed",
 	failedStep?: { index: number; error: string },
 ): string {
-	// Build step names for display
 	const stepNames = steps
-		.map((s) => (isParallelStep(s) ? `parallel[${s.parallel.length}]` : (s as SequentialStep).agent))
+		.map((step) => (isParallelStep(step) ? `parallel[${step.parallel.length}]` : step.agent))
 		.join(" → ");
 
-	// Calculate total duration from results
 	const totalDuration = results.reduce((sum, r) => sum + (r.progress?.durationMs || 0), 0);
 	const durationStr = formatDuration(totalDuration);
 
-	// Check for progress.md
 	const progressPath = path.join(chainDir, "progress.md");
 	const hasProgress = fs.existsSync(progressPath);
 	const allSkills = new Set<string>();
@@ -88,14 +85,20 @@ export function buildChainSummary(
  */
 export function formatToolCall(name: string, args: Record<string, unknown>): string {
 	switch (name) {
-		case "bash":
-			return `$ ${((args.command as string) || "").slice(0, 60)}${(args.command as string)?.length > 60 ? "..." : ""}`;
+		case "bash": {
+			const command = typeof args.command === "string" ? args.command : "";
+			return `$ ${command.slice(0, 60)}${command.length > 60 ? "..." : ""}`;
+		}
 		case "read":
-			return `read ${shortenPath((args.path || args.file_path || "") as string)}`;
 		case "write":
-			return `write ${shortenPath((args.path || args.file_path || "") as string)}`;
-		case "edit":
-			return `edit ${shortenPath((args.path || args.file_path || "") as string)}`;
+		case "edit": {
+			const target = typeof args.path === "string"
+				? args.path
+				: typeof args.file_path === "string"
+					? args.file_path
+					: "";
+			return `${name} ${shortenPath(target)}`;
+		}
 		default: {
 			const s = JSON.stringify(args);
 			return `${name} ${s.slice(0, 40)}${s.length > 40 ? "..." : ""}`;
@@ -108,7 +111,6 @@ export function formatToolCall(name: string, args: Record<string, unknown>): str
  */
 export function shortenPath(p: string): string {
 	const home = process.env.HOME;
-	// Only shorten if HOME is defined and non-empty, and path starts with it
 	if (home && p.startsWith(home)) {
 		return `~${p.slice(home.length)}`;
 	}

package/index.ts

@@ -266,7 +266,7 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 MANAGEMENT (use action field, omit agent/task/chain/tasks):
 • { action: "list" } - discover agents/chains
 • { action: "get", agent: "name" } - full agent detail
-• { action: "create", config: { name, systemPrompt, ... } }
+• { action: "create", config: { name, systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, ... } }
 • { action: "update", agent: "name", config: { ... } } - merge
 • { action: "delete", agent: "name" }
 • Use chainName for chain operations`,

package/install.mjs

@@ -38,7 +38,7 @@ if (isRemove) {
 	if (fs.existsSync(EXTENSION_DIR)) {
 		console.log(`Removing ${EXTENSION_DIR}...`);
 		fs.rmSync(EXTENSION_DIR, { recursive: true });
-		console.log("✓ pi-subagents removed");
+		console.log("pi-subagents removed");
 	} else {
 		console.log("pi-subagents is not installed");
 	}
@@ -61,7 +61,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 		console.log("Updating existing installation...");
 		try {
 			execSync("git pull", { cwd: EXTENSION_DIR, stdio: "inherit" });
-			console.log("\n✓ pi-subagents updated");
+			console.log("\npi-subagents updated");
 		} catch (err) {
 			console.error("Failed to update. Try removing and reinstalling:");
 			console.error("  npx pi-subagents --remove && npx pi-subagents");
@@ -77,7 +77,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 	console.log(`Cloning to ${EXTENSION_DIR}...`);
 	try {
 		execSync(`git clone ${REPO_URL} "${EXTENSION_DIR}"`, { stdio: "inherit" });
-		console.log("\n✓ pi-subagents installed");
+		console.log("\npi-subagents installed");
 	} catch (err) {
 		console.error("Failed to clone repository");
 		process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/parallel-utils.ts

@@ -1,10 +1,3 @@
-/**
- * Parallel execution utilities for the async runner.
- * Kept minimal and self-contained so the standalone runner can use them
- * without pulling in the full extension dependency tree.
- */
-
-/** A single agent step in the runner config */
 export interface RunnerSubagentStep {
 	agent: string;
 	task: string;
@@ -15,13 +8,15 @@ export interface RunnerSubagentStep {
 	extensions?: string[];
 	mcpDirectTools?: string[];
 	systemPrompt?: string | null;
+	systemPromptMode?: "append" | "replace";
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
 	skills?: string[];
 	outputPath?: string;
 	sessionFile?: string;
 	maxSubagentDepth?: number;
 }
 
-/** Parallel step group — multiple agents running concurrently */
 export interface ParallelStepGroup {
 	parallel: RunnerSubagentStep[];
 	concurrency?: number;
@@ -32,10 +27,9 @@ export interface ParallelStepGroup {
 export type RunnerStep = RunnerSubagentStep | ParallelStepGroup;
 
 export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
-	return "parallel" in step && Array.isArray((step as ParallelStepGroup).parallel);
+	return "parallel" in step && Array.isArray(step.parallel);
 }
 
-/** Flatten runner steps into individual SubagentSteps for status tracking */
 export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
 	const flat: RunnerSubagentStep[] = [];
 	for (const step of steps) {
@@ -48,16 +42,12 @@ export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
 	return flat;
 }
 
-/** Run async tasks with bounded concurrency, preserving result order.
- *  `staggerMs` adds a small delay between each worker's start to avoid
- *  file-lock contention when multiple subagents read shared config. */
 export async function mapConcurrent<T, R>(
 	items: T[],
 	limit: number,
 	fn: (item: T, i: number) => Promise<R>,
 	staggerMs = 150,
 ): Promise<R[]> {
-	// Clamp to at least 1; NaN/undefined/0/negative all become 1
 	const safeLimit = Math.max(1, Math.floor(limit) || 1);
 	const results: R[] = new Array(items.length);
 	let next = 0;
@@ -90,7 +80,6 @@ export interface ParallelTaskResult {
 	outputTargetExists?: boolean;
 }
 
-/** Aggregate outputs from parallel tasks into a single string for {previous} */
 export function aggregateParallelOutputs(
 	results: ParallelTaskResult[],
 	headerFormat: (index: number, agent: string) => string = (i, agent) =>
@@ -102,15 +91,15 @@ export function aggregateParallelOutputs(
 			const hasOutput = Boolean(r.output?.trim());
 			const status =
 				r.exitCode === -1
-					? "⏭️ SKIPPED"
+					? "SKIPPED"
 					: r.exitCode !== 0 && r.exitCode !== null
-						? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+						? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
 						: r.error
-							? `⚠️ WARNING: ${r.error}`
+							? `WARNING: ${r.error}`
 							: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-								? `⚠️ EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+								? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
 								: !hasOutput && !r.outputTargetPath
-									? "⚠️ EMPTY OUTPUT (no textual response returned)"
+									? "EMPTY OUTPUT (no textual response returned)"
 							: "";
 			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
 			return `${header}\n${body}`;

package/pi-args.ts

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const TASK_ARG_LIMIT = 8000;
+const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
 
 export interface BuildPiArgsInput {
 	baseArgs: string[];
@@ -13,9 +15,11 @@ export interface BuildPiArgsInput {
 	sessionFile?: string;
 	model?: string;
 	thinking?: string;
+	systemPromptMode?: "append" | "replace";
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
 	tools?: string[];
 	extensions?: string[];
-	skills?: string[];
 	systemPrompt?: string | null;
 	mcpDirectTools?: string[];
 	promptFileStem?: string;
@@ -69,28 +73,29 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		}
 	}
 
+	const runtimeExtensions = [PROMPT_RUNTIME_EXTENSION_PATH];
 	if (input.extensions !== undefined) {
 		args.push("--no-extensions");
-		for (const extPath of input.extensions) {
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...input.extensions])]) {
 			args.push("--extension", extPath);
 		}
 	} else {
-		for (const extPath of toolExtensionPaths) {
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths])]) {
 			args.push("--extension", extPath);
 		}
 	}
 
-	if ((input.skills?.length ?? 0) > 0) {
+	if (!input.inheritSkills) {
 		args.push("--no-skills");
 	}
 
 	let tempDir: string | undefined;
-	if (input.systemPrompt) {
+	if (input.systemPrompt !== undefined && input.systemPrompt !== null) {
 		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
 		const stem = (input.promptFileStem ?? "prompt").replace(/[^\w.-]/g, "_");
 		const promptPath = path.join(tempDir, `${stem}.md`);
 		fs.writeFileSync(promptPath, input.systemPrompt, { mode: 0o600 });
-		args.push("--append-system-prompt", promptPath);
+		args.push(input.systemPromptMode === "replace" ? "--system-prompt" : "--append-system-prompt", promptPath);
 	}
 
 	if (input.task.length > TASK_ARG_LIMIT) {
@@ -105,6 +110,8 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	}
 
 	const env: Record<string, string | undefined> = {};
+	env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
+	env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
 	if (input.mcpDirectTools?.length) {
 		env.MCP_DIRECT_TOOLS = input.mcpDirectTools.join(",");
 	} else {

package/prompt-template-bridge.ts

@@ -78,6 +78,7 @@ interface PromptTemplateBridgeResult {
 		results?: Array<{
 			agent?: string;
 			messages?: unknown[];
+			finalOutput?: string;
 			exitCode?: number;
 			error?: string;
 			model?: string;
@@ -180,12 +181,13 @@ function sanitizeRecentTools(
 	tools: Array<{ tool?: string; args?: string }> | undefined,
 ): Array<{ tool: string; args: string }> | undefined {
 	if (!tools || tools.length === 0) return undefined;
-	const sanitized = tools
-		.filter((entry) => typeof entry.tool === "string" && entry.tool.trim().length > 0)
-		.map((entry) => ({
-			tool: entry.tool as string,
+	const sanitized = tools.flatMap((entry) => {
+		if (typeof entry.tool !== "string" || entry.tool.trim().length === 0) return [];
+		return [{
+			tool: entry.tool,
 			args: typeof entry.args === "string" ? entry.args : String(entry.args ?? ""),
-		}));
+		}];
+	});
 	return sanitized.length > 0 ? sanitized : undefined;
 }
 
@@ -207,6 +209,15 @@ function resolveProgressModel(
 	return firstWithModel?.model;
 }
 
+function buildDelegationMessages(result: { messages?: unknown[]; finalOutput?: string }, fallbackText?: string): unknown[] {
+	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
+	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
+		? result.finalOutput.trim()
+		: fallbackText;
+	if (!text) return [];
+	return [{ role: "assistant", content: [{ type: "text", text }] }];
+}
+
 function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
 	const progress = update.details?.progress?.[0];
 	const taskProgress = update.details?.progress?.map((entry) => {
@@ -324,7 +335,8 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
 				},
 			);
-			const messages = result.details?.results?.[0]?.messages ?? [];
+			const contentText = firstTextContent(result.content);
+			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
 			const parallelResults = request.tasks
 				? request.tasks.map<PromptTemplateDelegationParallelResult>((task, index) => {
 					const step = result.details?.results?.[index];
@@ -340,13 +352,12 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					const errorText = step.error;
 					return {
 						agent: step.agent ?? task.agent,
-						messages: step.messages ?? [],
+						messages: buildDelegationMessages(step),
 						isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
 						errorText: errorText || undefined,
 					};
 				})
 				: undefined;
-			const contentText = firstTextContent(result.content);
 			const response: PromptTemplateDelegationResponse = {
 				...request,
 				messages,