pi-subagents 0.3.3 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [Unreleased]
+
+### Changed
+- Added `pi-package` keyword for npm discoverability (pi v0.50.0 package system)
+
+## [0.4.0] - 2026-01-25
+
+### Added
+- **Clarify TUI for single and parallel modes** - Use `clarify: true` to preview/edit before execution
+  - Single mode: Edit task, model, thinking level, output file
+  - Parallel mode: Edit each task independently, model, thinking level
+  - Navigate between parallel tasks with ↑↓
+- **Mode-aware TUI headers** - Header shows "Agent: X" for single, "Parallel Tasks (N)" for parallel, "Chain: X → Y" for chains
+- **Model override for single/parallel** - TUI model selection now works for all modes
+
+### Fixed
+- **MAX_PARALLEL error mode** - Now correctly returns `mode: 'parallel'` (was incorrectly `mode: 'single'`)
+- **`output: true` handling** - Now correctly treats `true` as "use agent's default output" instead of creating a file literally named "true"
+
+### Changed
+- **Schema description** - `clarify` parameter now documents all modes: "default: true for chains, false for single/parallel"
+
 ## [0.3.3] - 2026-01-25
 
 ### Added

package/README.md

@@ -6,6 +6,8 @@
 
 Pi extension for delegating tasks to subagents with chains, parallel execution, TUI clarification, and async support.
 
+https://github.com/user-attachments/assets/702554ec-faaf-4635-80aa-fb5d6e292fd1
+
 ## Installation
 
 ```bash
@@ -43,18 +45,30 @@ npx pi-subagents --remove
 
 *Chain defaults to sync with TUI clarification. Use `clarify: false` to enable async (sequential-only chains; parallel-in-chain requires sync mode).
 
-**Chain clarification TUI keybindings:**
+**Clarify TUI for single/parallel:**
+
+Single and parallel modes also support the clarify TUI for previewing/editing parameters before execution. Unlike chains, they default to no TUI - use `clarify: true` to enable:
+
+```typescript
+// Single agent with clarify TUI
+{ agent: "scout", task: "Analyze the codebase", clarify: true }
+
+// Parallel tasks with clarify TUI
+{ tasks: [{agent: "scout", task: "Analyze frontend"}, ...], clarify: true }
+```
+
+**Clarification TUI keybindings:**
 
 *Navigation mode:*
-- `Enter` - Run the chain
+- `Enter` - Run
 - `Esc` - Cancel
-- `↑↓` - Navigate between steps
-- `e` - Edit task/template
-- `m` - Select model (fuzzy search with all available models)
-- `t` - Select thinking level (off, minimal, low, medium, high, xhigh)
-- `w` - Edit writes (output file path)
-- `r` - Edit reads list
-- `p` - Toggle progress tracking for ALL steps (chains share one progress.md)
+- `↑↓` - Navigate between steps/tasks (parallel, chain)
+- `e` - Edit task/template (all modes)
+- `m` - Select model (all modes)
+- `t` - Select thinking level (all modes)
+- `w` - Edit writes/output file (single, chain only)
+- `r` - Edit reads list (chain only)
+- `p` - Toggle progress tracking (chain only)
 
 *Model selector mode:*
 - `↑↓` - Navigate model list

package/chain-clarify.ts

@@ -11,6 +11,9 @@ import { matchesKey, visibleWidth, truncateToWidth } from "@mariozechner/pi-tui"
 import type { AgentConfig } from "./agents.js";
 import type { ResolvedStepBehavior } from "./settings.js";
 
+/** Clarify TUI mode */
+export type ClarifyMode = 'single' | 'parallel' | 'chain';
+
 /** Model info for display */
 export interface ModelInfo {
 	provider: string;
@@ -76,10 +79,11 @@ export class ChainClarifyComponent implements Component {
 		private agentConfigs: AgentConfig[],
 		private templates: string[],
 		private originalTask: string,
-		private chainDir: string,
+		private chainDir: string | undefined,  // undefined for single/parallel modes
 		private resolvedBehaviors: ResolvedStepBehavior[],
 		private availableModels: ModelInfo[],
 		private done: (result: ChainClarifyResult) => void,
+		private mode: ClarifyMode = 'chain',   // Mode: 'single', 'parallel', or 'chain'
 	) {
 		// Initialize filtered models
 		this.filteredModels = [...availableModels];
@@ -222,11 +226,17 @@ export class ChainClarifyComponent implements Component {
 		// Header (truncate agent name to prevent overflow)
 		const fieldName = this.editMode === "template" ? "task" : this.editMode;
 		const rawAgentName = this.agentConfigs[this.editingStep!]?.name ?? "unknown";
-		const maxAgentLen = innerW - 30; // Reserve space for " Editing X (Step N: ) "
+		const maxAgentLen = innerW - 30; // Reserve space for " Editing X (Step/Task N: ) "
 		const agentName = rawAgentName.length > maxAgentLen
 			? rawAgentName.slice(0, maxAgentLen - 1) + "…"
 			: rawAgentName;
-		const headerText = ` Editing ${fieldName} (Step ${this.editingStep! + 1}: ${agentName}) `;
+		// Use mode-appropriate terminology
+		const stepLabel = this.mode === 'single' 
+			? agentName 
+			: this.mode === 'parallel' 
+				? `Task ${this.editingStep! + 1}: ${agentName}` 
+				: `Step ${this.editingStep! + 1}: ${agentName}`;
+		const headerText = ` Editing ${fieldName} (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
 		lines.push(this.row(""));
 
@@ -365,26 +375,38 @@ export class ChainClarifyComponent implements Component {
 			return;
 		}
 
-		// 'e' to edit template
+		// 'e' to edit template (all modes)
 		if (data === "e") {
 			this.enterEditMode("template");
 			return;
 		}
 
-		// 'w' to edit writes (output file)
-		if (data === "w") {
+		// 'm' to select model (all modes)
+		if (data === "m") {
+			this.enterModelSelector();
+			return;
+		}
+
+		// 't' to select thinking level (all modes)
+		if (data === "t") {
+			this.enterThinkingSelector();
+			return;
+		}
+
+		// 'w' to edit writes (single and chain only - not parallel)
+		if (data === "w" && this.mode !== 'parallel') {
 			this.enterEditMode("output");
 			return;
 		}
 
-		// 'r' to edit reads
-		if (data === "r") {
+		// 'r' to edit reads (chain only)
+		if (data === "r" && this.mode === 'chain') {
 			this.enterEditMode("reads");
 			return;
 		}
 
-		// 'p' to toggle progress for ALL steps (chains share a single progress.md)
-		if (data === "p") {
+		// 'p' to toggle progress for ALL steps (chain only - chains share a single progress.md)
+		if (data === "p" && this.mode === 'chain') {
 			// Check if any step has progress enabled
 			const anyEnabled = this.agentConfigs.some((_, i) => this.getEffectiveBehavior(i).progress);
 			// Toggle all steps to the opposite state
@@ -395,18 +417,6 @@ export class ChainClarifyComponent implements Component {
 			this.tui.requestRender();
 			return;
 		}
-
-		// 'm' to select model
-		if (data === "m") {
-			this.enterModelSelector();
-			return;
-		}
-
-		// 't' to select thinking level
-		if (data === "t") {
-			this.enterThinkingSelector();
-			return;
-		}
 	}
 
 	private enterEditMode(mode: EditMode): void {
@@ -809,7 +819,12 @@ export class ChainClarifyComponent implements Component {
 			}
 			return this.renderFullEditMode();
 		}
-		return this.renderNavigationMode();
+		// Mode-based navigation rendering
+		switch (this.mode) {
+			case 'single': return this.renderSingleMode();
+			case 'parallel': return this.renderParallelMode();
+			case 'chain': return this.renderChainMode();
+		}
 	}
 
 	/** Render the model selector view */
@@ -818,9 +833,14 @@ export class ChainClarifyComponent implements Component {
 		const th = this.theme;
 		const lines: string[] = [];
 
-		// Header
+		// Header (mode-aware terminology)
 		const agentName = this.agentConfigs[this.editingStep!]?.name ?? "unknown";
-		const headerText = ` Select Model (Step ${this.editingStep! + 1}: ${agentName}) `;
+		const stepLabel = this.mode === 'single' 
+			? agentName 
+			: this.mode === 'parallel' 
+				? `Task ${this.editingStep! + 1}: ${agentName}` 
+				: `Step ${this.editingStep! + 1}: ${agentName}`;
+		const headerText = ` Select Model (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
 		lines.push(this.row(""));
 
@@ -898,9 +918,14 @@ export class ChainClarifyComponent implements Component {
 		const th = this.theme;
 		const lines: string[] = [];
 
-		// Header
+		// Header (mode-aware terminology)
 		const agentName = this.agentConfigs[this.editingStep!]?.name ?? "unknown";
-		const headerText = ` Thinking Level (Step ${this.editingStep! + 1}: ${agentName}) `;
+		const stepLabel = this.mode === 'single' 
+			? agentName 
+			: this.mode === 'parallel' 
+				? `Task ${this.editingStep! + 1}: ${agentName}` 
+				: `Step ${this.editingStep! + 1}: ${agentName}`;
+		const headerText = ` Thinking Level (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
 		lines.push(this.row(""));
 
@@ -947,8 +972,122 @@ export class ChainClarifyComponent implements Component {
 		return lines;
 	}
 
-	/** Render navigation mode (step selection, preview) */
-	private renderNavigationMode(): string[] {
+	/** Get footer text based on mode */
+	private getFooterText(): string {
+		switch (this.mode) {
+			case 'single':
+				return ' [Enter] Run • [Esc] Cancel • [e]dit [m]odel [t]hinking [w]rites ';
+			case 'parallel':
+				return ' [Enter] Run • [Esc] Cancel • [e]dit [m]odel [t]hinking • ↑↓ Navigate ';
+			case 'chain':
+				return ' [Enter] Run • [Esc] Cancel • [e]dit [m]odel [t]hinking [w]rites [r]eads [p]rogress ';
+		}
+	}
+
+	/** Render single agent mode (simplified view) */
+	private renderSingleMode(): string[] {
+		const innerW = this.width - 2;
+		const th = this.theme;
+		const lines: string[] = [];
+
+		// Header with agent name
+		const agentName = this.agentConfigs[0]?.name ?? "unknown";
+		const maxHeaderLen = innerW - 4;
+		const headerText = ` Agent: ${truncateToWidth(agentName, maxHeaderLen - 9)} `;
+		lines.push(this.renderHeader(headerText));
+		lines.push(this.row(""));
+
+		// Single step - always index 0, always selected
+		const config = this.agentConfigs[0]!;
+		const behavior = this.getEffectiveBehavior(0);
+
+		// Agent name with selection indicator
+		const stepLabel = config.name;
+		lines.push(this.row(` ${th.fg("accent", "▶ " + stepLabel)}`));
+
+		// Task line
+		const template = (this.templates[0] ?? "").split("\n")[0] ?? "";
+		const taskLabel = th.fg("dim", "task: ");
+		lines.push(this.row(`     ${taskLabel}${truncateToWidth(template, innerW - 12)}`));
+
+		// Model line
+		const effectiveModel = this.getEffectiveModel(0);
+		const override = this.behaviorOverrides.get(0);
+		const isOverridden = override?.model !== undefined;
+		const modelValue = isOverridden
+			? th.fg("warning", effectiveModel) + th.fg("dim", " ✎")
+			: effectiveModel;
+		const modelLabel = th.fg("dim", "model: ");
+		lines.push(this.row(`     ${modelLabel}${truncateToWidth(modelValue, innerW - 13)}`));
+
+		// Writes line (output file)
+		const writesValue = behavior.output === false
+			? th.fg("dim", "(disabled)")
+			: (behavior.output || th.fg("dim", "(none)"));
+		const writesLabel = th.fg("dim", "writes: ");
+		lines.push(this.row(`     ${writesLabel}${truncateToWidth(writesValue, innerW - 14)}`));
+
+		lines.push(this.row(""));
+
+		// Footer
+		lines.push(this.renderFooter(this.getFooterText()));
+
+		return lines;
+	}
+
+	/** Render parallel mode (multi-task view without chain features) */
+	private renderParallelMode(): string[] {
+		const innerW = this.width - 2;
+		const th = this.theme;
+		const lines: string[] = [];
+
+		// Header with task count
+		const headerText = ` Parallel Tasks (${this.agentConfigs.length}) `;
+		lines.push(this.renderHeader(headerText));
+		lines.push(this.row(""));
+
+		// Each task
+		for (let i = 0; i < this.agentConfigs.length; i++) {
+			const config = this.agentConfigs[i]!;
+			const isSelected = i === this.selectedStep;
+
+			// Task header (truncate agent name to prevent overflow)
+			const color = isSelected ? "accent" : "dim";
+			const prefix = isSelected ? "▶ " : "  ";
+			const taskPrefix = `Task ${i + 1}: `;
+			const maxNameLen = innerW - 4 - prefix.length - taskPrefix.length;
+			const agentName = config.name.length > maxNameLen
+				? config.name.slice(0, maxNameLen - 1) + "…"
+				: config.name;
+			const taskLabel = `${taskPrefix}${agentName}`;
+			lines.push(this.row(` ${th.fg(color, prefix + taskLabel)}`));
+
+			// Task line
+			const template = (this.templates[i] ?? "").split("\n")[0] ?? "";
+			const taskTextLabel = th.fg("dim", "task: ");
+			lines.push(this.row(`     ${taskTextLabel}${truncateToWidth(template, innerW - 12)}`));
+
+			// Model line
+			const effectiveModel = this.getEffectiveModel(i);
+			const override = this.behaviorOverrides.get(i);
+			const isOverridden = override?.model !== undefined;
+			const modelValue = isOverridden
+				? th.fg("warning", effectiveModel) + th.fg("dim", " ✎")
+				: effectiveModel;
+			const modelLabel = th.fg("dim", "model: ");
+			lines.push(this.row(`     ${modelLabel}${truncateToWidth(modelValue, innerW - 13)}`));
+
+			lines.push(this.row(""));
+		}
+
+		// Footer
+		lines.push(this.renderFooter(this.getFooterText()));
+
+		return lines;
+	}
+
+	/** Render chain mode (step selection, preview) */
+	private renderChainMode(): string[] {
 		const innerW = this.width - 2;
 		const th = this.theme;
 		const lines: string[] = [];
@@ -964,7 +1103,8 @@ export class ChainClarifyComponent implements Component {
 		// Original task (truncated) and chain dir
 		const taskPreview = truncateToWidth(this.originalTask, innerW - 16);
 		lines.push(this.row(` Original Task: ${taskPreview}`));
-		const chainDirPreview = truncateToWidth(this.chainDir, innerW - 12);
+		// chainDir is guaranteed to be defined in chain mode
+		const chainDirPreview = truncateToWidth(this.chainDir ?? "", innerW - 12);
 		lines.push(this.row(` Chain Dir: ${th.fg("dim", chainDirPreview)}`));
 
 		// Chain-wide progress setting
@@ -1053,8 +1193,7 @@ export class ChainClarifyComponent implements Component {
 		}
 
 		// Footer with keybindings
-		const footerText = " [Enter] Run • [Esc] Cancel • [e]dit [m]odel [t]hinking [w]rites [r]eads [p]rogress ";
-		lines.push(this.renderFooter(footerText));
+		lines.push(this.renderFooter(this.getFooterText()));
 
 		return lines;
 	}

package/index.ts

@@ -19,7 +19,8 @@ import * as path from "node:path";
 import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
-import { cleanupOldChainDirs, getStepAgents, isParallelStep, type ChainStep, type SequentialStep } from "./settings.js";
+import { cleanupOldChainDirs, getStepAgents, isParallelStep, resolveStepBehavior, type ChainStep, type SequentialStep } from "./settings.js";
+import { ChainClarifyComponent, type ChainClarifyResult, type ModelInfo } from "./chain-clarify.js";
 import { cleanupOldArtifacts, getArtifactsDir } from "./artifacts.js";
 import {
 	type AgentProgress,
@@ -188,8 +189,13 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 			const requestedAsync = params.async ?? asyncByDefault;
 			const parallelDowngraded = hasTasks && requestedAsync;
 			// clarify implies sync mode (TUI is blocking)
-			// If user requested async without explicit clarify: false, downgrade to sync for chains
-			const effectiveAsync = requestedAsync && !hasTasks && (hasChain ? params.clarify === false : true);
+			// - Chains default to TUI (clarify: true), so async requires explicit clarify: false
+			// - Single defaults to no TUI, so async is allowed unless clarify: true is passed
+			const effectiveAsync = requestedAsync && !hasTasks && (
+				hasChain 
+					? params.clarify === false    // chains: only async if TUI explicitly disabled
+					: params.clarify !== true     // single: async unless TUI explicitly enabled
+			);
 
 			const artifactConfig: ArtifactConfig = {
 				...DEFAULT_ARTIFACT_CONFIG,
@@ -336,14 +342,74 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 			}
 
 			if (hasTasks && params.tasks) {
+				// MAX_PARALLEL check first (fail fast before TUI)
 				if (params.tasks.length > MAX_PARALLEL)
 					return {
 						content: [{ type: "text", text: `Max ${MAX_PARALLEL} tasks` }],
 						isError: true,
-						details: { mode: "single" as const, results: [] },
+						details: { mode: "parallel" as const, results: [] },
 					};
+
+				// Validate all agents exist
+				const agentConfigs: AgentConfig[] = [];
+				for (const t of params.tasks) {
+					const config = agents.find(a => a.name === t.agent);
+					if (!config) {
+						return {
+							content: [{ type: "text", text: `Unknown agent: ${t.agent}` }],
+							isError: true,
+							details: { mode: "parallel" as const, results: [] },
+						};
+					}
+					agentConfigs.push(config);
+				}
+
+				// Mutable copies for TUI modifications
+				let tasks = params.tasks.map(t => t.task);
+				const modelOverrides: (string | undefined)[] = new Array(params.tasks.length).fill(undefined);
+
+				// Show clarify TUI if requested
+				if (params.clarify === true && ctx.hasUI) {
+					// Get available models (same pattern as chain-execution.ts)
+					const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map((m) => ({
+						provider: m.provider,
+						id: m.id,
+						fullId: `${m.provider}/${m.id}`,
+					}));
+
+					const behaviors = agentConfigs.map(c => resolveStepBehavior(c, {}));
+
+					const result = await ctx.ui.custom<ChainClarifyResult>(
+						(tui, theme, _kb, done) =>
+							new ChainClarifyComponent(
+								tui, theme,
+								agentConfigs,
+								tasks,
+								'',          // no originalTask for parallel (each task is independent)
+								undefined,   // no chainDir for parallel
+								behaviors,
+								availableModels,
+								done,
+								'parallel',  // mode
+							),
+						{ overlay: true, overlayOptions: { anchor: 'center', width: 84, maxHeight: '80%' } },
+					);
+
+					if (!result || !result.confirmed) {
+						return { content: [{ type: 'text', text: 'Cancelled' }], details: { mode: 'parallel', results: [] } };
+					}
+
+					// Apply TUI overrides
+					tasks = result.templates;
+					for (let i = 0; i < result.behaviorOverrides.length; i++) {
+						const override = result.behaviorOverrides[i];
+						if (override?.model) modelOverrides[i] = override.model;
+					}
+				}
+
+				// Execute with overrides (tasks array has same length as params.tasks)
 				const results = await mapConcurrent(params.tasks, MAX_CONCURRENCY, async (t, i) =>
-					runSync(ctx.cwd, agents, t.agent, t.task, {
+					runSync(ctx.cwd, agents, t.agent, tasks[i]!, {
 						cwd: t.cwd ?? params.cwd,
 						signal,
 						runId,
@@ -353,6 +419,7 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 						artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
 						artifactConfig,
 						maxOutput: params.maxOutput,
+						modelOverride: modelOverrides[i],
 					}),
 				);
 
@@ -377,24 +444,67 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 			if (hasSingle) {
 				// Look up agent config for output handling
 				const agentConfig = agents.find((a) => a.name === params.agent);
-				// Note: runSync already handles unknown agent, but we need config for output
+				if (!agentConfig) {
+					return {
+						content: [{ type: 'text', text: `Unknown agent: ${params.agent}` }],
+						isError: true,
+						details: { mode: 'single', results: [] },
+					};
+				}
 
 				let task = params.task!;
-				let outputPath: string | undefined;
+				let modelOverride: string | undefined;
+				// Normalize output: true means "use default" (same as undefined), false means disable
+				const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
+				let effectiveOutput: string | false | undefined = rawOutput === true ? agentConfig.output : rawOutput;
+
+				// Show clarify TUI if requested
+				if (params.clarify === true && ctx.hasUI) {
+					// Get available models (same pattern as chain-execution.ts)
+					const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map((m) => ({
+						provider: m.provider,
+						id: m.id,
+						fullId: `${m.provider}/${m.id}`,
+					}));
+
+					const behavior = resolveStepBehavior(agentConfig, { output: effectiveOutput });
+
+					const result = await ctx.ui.custom<ChainClarifyResult>(
+						(tui, theme, _kb, done) =>
+							new ChainClarifyComponent(
+								tui, theme,
+								[agentConfig],
+								[task],
+								task,
+								undefined,  // no chainDir for single
+								[behavior],
+								availableModels,
+								done,
+								'single',   // mode
+							),
+						{ overlay: true, overlayOptions: { anchor: 'center', width: 84, maxHeight: '80%' } },
+					);
+
+					if (!result || !result.confirmed) {
+						return { content: [{ type: 'text', text: 'Cancelled' }], details: { mode: 'single', results: [] } };
+					}
 
-				// Check if agent has output and it's not disabled
-				if (agentConfig) {
-					const effectiveOutput =
-						params.output !== undefined ? params.output : agentConfig.output;
+					// Apply TUI overrides
+					task = result.templates[0]!;
+					const override = result.behaviorOverrides[0];
+					if (override?.model) modelOverride = override.model;
+					if (override?.output !== undefined) effectiveOutput = override.output;
+				}
 
-					if (effectiveOutput && effectiveOutput !== false) {
-						const outputDir = `/tmp/pi-${agentConfig.name}-${runId}`;
-						fs.mkdirSync(outputDir, { recursive: true });
-						outputPath = `${outputDir}/${effectiveOutput}`;
+				// Compute output path at runtime (uses effectiveOutput which may be TUI-modified)
+				let outputPath: string | undefined;
+				if (effectiveOutput && effectiveOutput !== false) {
+					const outputDir = `/tmp/pi-${agentConfig.name}-${runId}`;
+					fs.mkdirSync(outputDir, { recursive: true });
+					outputPath = `${outputDir}/${effectiveOutput}`;
 
-						// Inject output instruction into task
-						task += `\n\n---\n**Output:** Write your findings to: ${outputPath}`;
-					}
+					// Inject output instruction into task
+					task += `\n\n---\n**Output:** Write your findings to: ${outputPath}`;
 				}
 
 				const r = await runSync(ctx.cwd, agents, params.agent!, task, {
@@ -407,6 +517,7 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 					artifactConfig,
 					maxOutput: params.maxOutput,
 					onUpdate,
+					modelOverride,
 				});
 
 				if (r.progress) allProgress.push(r.progress);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -13,6 +13,7 @@
     "url": "https://github.com/nicobailon/pi-subagents/issues"
   },
   "keywords": [
+    "pi-package",
     "pi",
     "pi-coding-agent",
     "subagents",

package/schemas.ts

@@ -77,8 +77,8 @@ export const SubagentParams = Type.Object({
 	sessionDir: Type.Optional(
 		Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" }),
 	),
-	// Chain clarification TUI
-	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to clarify chain templates (default: true for chains). Implies sync mode." })),
+	// Clarification TUI
+	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution (default: true for chains, false for single/parallel). Implies sync mode." })),
 	// Solo agent output override
 	output: Type.Optional(Type.Union([
 		Type.String(),