pi-subagents 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-04-16
+
+### Added
+- Top-level parallel `tasks` mode now supports a per-call `concurrency` override, matching the existing chain parallel-step concurrency control. This ships part of issue `#91`. Thanks @Gabrielgvl.
+
+### Changed
+- Top-level parallel defaults and limits can now be configured through `~/.pi/agent/extensions/subagent/config.json` under `parallel.maxTasks` and `parallel.concurrency`, while keeping the existing defaults of 8 tasks and concurrency 4 when unset. This completes issue `#91`. Thanks @Gabrielgvl.
+
+### Fixed
+- `context: "fork"` sync runs now create child sessions from a throwaway session-manager instance opened on the persisted parent session file, instead of mutating the live parent session manager. This keeps the parent session writing to its own file so the matching `toolResult(subagent)` no longer lands in a descendant session by accident. This fixes issue `#87`. Thanks @asmisha.
+- Project agent and chain discovery now reads both `.agents/` and `.pi/agents/`, while preferring `.pi/agents/` when both locations define the same parsed name and keeping manager writes on the `.pi/agents/` path. This fixes issue `#88`. Thanks @desek.
+- Ctrl+O expanded subagent results now actually show expanded content. Previously the `expanded` flag was received but ignored, so task text and tool-call args were identically truncated in both views. Now expanded mode shows the full task and longer (but still bounded) tool-call previews. Additionally, tool calls are no longer lost after foreground compaction: compact display summaries are preserved and shown in expanded view even after `messages` are stripped. This addresses issue `#90`. Thanks @asagajda.
+
 ## [0.15.0] - 2026-04-16
 
 ### Added

package/README.md

@@ -42,6 +42,8 @@ Agents are markdown files with YAML frontmatter that define specialized subagent
 | User | `~/.pi/agent/agents/{name}.md` | Medium |
 | Project | `.pi/agents/{name}.md` (searches up directory tree) | Highest |
 
+Project discovery also reads legacy `.agents/{name}.md` files. If both `.agents/` and `.pi/agents/` contain a project agent with the same parsed `name`, `.pi/agents/` wins and the agent manager still writes to `.pi/agents/`.
+
 Use `agentScope` parameter to control discovery: `"user"`, `"project"`, or `"both"` (default; project takes priority).
 
 **Builtin agents:** The extension ships with ready-to-use agents — `scout`, `planner`, `worker`, `reviewer`, `context-builder`, `researcher`, and `delegate`. They load at lowest priority so any user or project agent with the same name overrides them.
@@ -255,7 +257,7 @@ Append `[key=value,...]` to any agent name to override its defaults:
 ```
 /chain scout[output=context.md] "scan code" -> planner[reads=context.md] "analyze auth"
 /run scout[model=anthropic/claude-sonnet-4] summarize this codebase
-/parallel scanner[output=scan.md] "find issues" -> reviewer[output=review.md] "check style"
+/parallel scanner[model=anthropic/claude-sonnet-4] "find issues" -> reviewer[skills=code-review+security] "check style"
 ```
 
 | Key | Example | Description |
@@ -359,6 +361,8 @@ Chains are `.chain.md` files stored alongside agent files. They define reusable
 | User | `~/.pi/agent/agents/{name}.chain.md` |
 | Project | `.pi/agents/{name}.chain.md` |
 
+Project chain discovery also reads legacy `.agents/{name}.chain.md` files. If both locations define the same parsed chain `name`, `.pi/agents/` wins and manager writes stay in `.pi/agents/`.
+
 **Format:**
 
 ```markdown
@@ -545,6 +549,9 @@ These are the parameters the **LLM agent** passes when it calls the `subagent` t
 // Parallel
 { tasks: [{ agent: "scout", task: "a" }, { agent: "scout", task: "b" }] }
 
+// Parallel with top-level concurrency override
+{ tasks: [{ agent: "scout", task: "a" }, { agent: "reviewer", task: "b" }], concurrency: 2 }
+
 // Parallel with count shorthand (run the same task 3 times)
 { tasks: [{ agent: "scout", task: "audit auth", count: 3 }] }
 
@@ -711,6 +718,7 @@ Notes:
 | `model` | string | agent default | Override model for single agent |
 | `fallbackModels` | `string \| string[]` | agent default | Management/config-only field for ordered backup models. Markdown frontmatter uses a comma-separated string. |
 | `tasks` | `{agent, task, cwd?, count?, skill?}[]` | - | Parallel tasks. Foreground runs directly; background requests are converted to an equivalent chain. `count` repeats one task entry N times with the same settings. |
+| `concurrency` | number | `config.parallel.concurrency` or `4` | Top-level `tasks` mode only: max concurrent tasks. |
 | `worktree` | boolean | false | Create isolated git worktrees for each parallel task. Requires clean git state. Per-worktree diffs included in output. |
 | `chain` | ChainItem[] | - | Sequential steps with behavior overrides (see below) |
 | `context` | `"fresh" \| "fork"` | `fresh` | Execution context mode. `fork` uses a real branched session from the parent's current leaf for each child run |
@@ -845,6 +853,25 @@ This aggregated output becomes `{previous}` for the next step.
 
 `pi-subagents` reads optional JSON config from `~/.pi/agent/extensions/subagent/config.json`.
 
+### `parallel`
+
+`parallel` controls top-level `tasks` mode defaults and limits.
+
+```json
+{
+  "parallel": {
+    "maxTasks": 12,
+    "concurrency": 6
+  }
+}
+```
+
+Fields:
+- `maxTasks` defaults to `8` when unset or invalid
+- `concurrency` defaults to `4` when unset or invalid
+
+Per-call `concurrency` on the `subagent` tool takes precedence over `config.parallel.concurrency` for top-level `tasks` runs.
+
 ### `defaultSessionDir`
 
 `defaultSessionDir` sets the fallback directory used for session logs. Eg:

package/agents.ts

@@ -606,13 +606,20 @@ function isDirectory(p: string): boolean {
 	}
 }
 
-function findNearestProjectAgentsDir(cwd: string): string | null {
+function resolveNearestProjectAgentDirs(cwd: string): { readDirs: string[]; preferredDir: string | null } {
 	const projectRoot = findNearestProjectRoot(cwd);
-	if (!projectRoot) return null;
-	const candidateAlt = path.join(projectRoot, ".agents");
-	if (isDirectory(candidateAlt)) return candidateAlt;
-	const candidate = path.join(projectRoot, ".pi", "agents");
-	return isDirectory(candidate) ? candidate : null;
+	if (!projectRoot) return { readDirs: [], preferredDir: null };
+
+	const legacyDir = path.join(projectRoot, ".agents");
+	const preferredDir = path.join(projectRoot, ".pi", "agents");
+	const readDirs: string[] = [];
+	if (isDirectory(legacyDir)) readDirs.push(legacyDir);
+	if (isDirectory(preferredDir)) readDirs.push(preferredDir);
+
+	return {
+		readDirs,
+		preferredDir,
+	};
 }
 
 const BUILTIN_AGENTS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "agents");
@@ -620,7 +627,7 @@ const BUILTIN_AGENTS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
 	const userDirOld = path.join(os.homedir(), ".pi", "agent", "agents");
 	const userDirNew = path.join(os.homedir(), ".agents");
-	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+	const { readDirs: projectAgentDirs, preferredDir: projectAgentsDir } = resolveNearestProjectAgentDirs(cwd);
 	const userSettingsPath = getUserAgentSettingsPath();
 	const projectSettingsPath = getProjectAgentSettingsPath(cwd);
 
@@ -631,12 +638,12 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
 		userSettingsPath,
 		projectSettingsPath,
 	);
-	
+
 	const userAgentsOld = scope === "project" ? [] : loadAgentsFromDir(userDirOld, "user");
 	const userAgentsNew = scope === "project" ? [] : loadAgentsFromDir(userDirNew, "user");
 	const userAgents = [...userAgentsOld, ...userAgentsNew];
 
-	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+	const projectAgents = scope === "user" ? [] : projectAgentDirs.flatMap((dir) => loadAgentsFromDir(dir, "project"));
 	const agents = mergeAgentsForScope(scope, userAgents, projectAgents, builtinAgents);
 
 	return { agents, projectAgentsDir };
@@ -654,7 +661,7 @@ export function discoverAgentsAll(cwd: string): {
 } {
 	const userDirOld = path.join(os.homedir(), ".pi", "agent", "agents");
 	const userDirNew = path.join(os.homedir(), ".agents");
-	const projectDir = findNearestProjectAgentsDir(cwd);
+	const { readDirs: projectDirs, preferredDir: projectDir } = resolveNearestProjectAgentDirs(cwd);
 	const userSettingsPath = getUserAgentSettingsPath();
 	const projectSettingsPath = getProjectAgentSettingsPath(cwd);
 
@@ -669,11 +676,24 @@ export function discoverAgentsAll(cwd: string): {
 		...loadAgentsFromDir(userDirOld, "user"),
 		...loadAgentsFromDir(userDirNew, "user"),
 	];
-	const project = projectDir ? loadAgentsFromDir(projectDir, "project") : [];
+	const projectMap = new Map<string, AgentConfig>();
+	for (const dir of projectDirs) {
+		for (const agent of loadAgentsFromDir(dir, "project")) {
+			projectMap.set(agent.name, agent);
+		}
+	}
+	const project = Array.from(projectMap.values());
+
+	const chainMap = new Map<string, ChainConfig>();
+	for (const dir of projectDirs) {
+		for (const chain of loadChainsFromDir(dir, "project")) {
+			chainMap.set(chain.name, chain);
+		}
+	}
 	const chains = [
 		...loadChainsFromDir(userDirOld, "user"),
 		...loadChainsFromDir(userDirNew, "user"),
-		...(projectDir ? loadChainsFromDir(projectDir, "project") : []),
+		...Array.from(chainMap.values()),
 	];
 
 	const userDir = fs.existsSync(userDirNew) ? userDirNew : userDirOld;

package/fork-context.ts

@@ -1,9 +1,13 @@
 export type SubagentExecutionContext = "fresh" | "fork";
 
+interface ForkableSessionManagerStatic {
+	open(path: string): { createBranchedSession(leafId: string): string | undefined };
+}
+
 export interface ForkableSessionManager {
 	getSessionFile(): string | undefined;
 	getLeafId(): string | null;
-	createBranchedSession(leafId: string): string | undefined;
+	constructor: ForkableSessionManagerStatic;
 }
 
 export interface ForkContextResolver {
@@ -41,7 +45,8 @@ export function createForkContextResolver(
 			const cached = cachedSessionFiles.get(index);
 			if (cached) return cached;
 			try {
-				const sessionFile = sessionManager.createBranchedSession(leafId);
+				const sourceManager = sessionManager.constructor.open(parentSessionFile);
+				const sessionFile = sourceManager.createBranchedSession(leafId);
 				if (!sessionFile) {
 					throw new Error("Session manager did not return a session file.");
 				}

package/formatters.ts

@@ -83,11 +83,12 @@ export function buildChainSummary(
 /**
  * Format a tool call for display
  */
-export function formatToolCall(name: string, args: Record<string, unknown>): string {
+export function formatToolCall(name: string, args: Record<string, unknown>, expanded = false): string {
 	switch (name) {
 		case "bash": {
 			const command = typeof args.command === "string" ? args.command : "";
-			return `$ ${command.slice(0, 60)}${command.length > 60 ? "..." : ""}`;
+			const maxLength = expanded ? 240 : 60;
+			return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
 		}
 		case "read":
 		case "write":
@@ -101,7 +102,8 @@ export function formatToolCall(name: string, args: Record<string, unknown>): str
 		}
 		default: {
 			const s = JSON.stringify(args);
-			return `${name} ${s.slice(0, 40)}${s.length > 40 ? "..." : ""}`;
+			const maxLength = expanded ? 160 : 40;
+			return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
 		}
 	}
 }

package/index.ts

@@ -253,7 +253,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 EXECUTION (use exactly ONE mode):
 • SINGLE: { agent, task } - one task
 • CHAIN: { chain: [{agent:"scout"}, {parallel:[{agent:"worker",count:3}]}] } - sequential pipeline with optional parallel fan-out
-• PARALLEL: { tasks: [{agent,task,count?}, ...], worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
+• PARALLEL: { tasks: [{agent,task,count?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
 • Optional context: { context: "fresh" | "fork" } (default: "fresh")
 
 CHAIN TEMPLATE VARIABLES (use in task strings):

package/package.json

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

package/render.ts

@@ -101,6 +101,18 @@ function hasEmptyTextOutputWithoutOutputTarget(task: string, output: string): bo
 	return !extractOutputTarget(task);
 }
 
+function getToolCallLines(
+	result: Pick<Details["results"][number], "messages" | "toolCalls">,
+	expanded: boolean,
+): string[] {
+	if (result.messages) {
+		return getDisplayItems(result.messages)
+			.filter((item): item is { type: "tool"; name: string; args: Record<string, unknown> } => item.type === "tool")
+			.map((item) => formatToolCall(item.name, item.args, expanded));
+	}
+	return result.toolCalls?.map((toolCall) => expanded ? toolCall.expandedText : toolCall.text) ?? [];
+}
+
 /**
  * Render the async jobs widget
  */
@@ -165,7 +177,7 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
  */
 export function renderSubagentResult(
 	result: AgentToolResult<Details>,
-	_options: { expanded: boolean },
+	options: { expanded: boolean },
 	theme: Theme,
 ): Component {
 	const d = result.details;
@@ -176,6 +188,7 @@ export function renderSubagentResult(
 		return new Text(truncLine(`${contextPrefix}${text}`, getTermWidth() - 4), 0, 0);
 	}
 
+	const expanded = options.expanded;
 	const mdTheme = getMarkdownTheme();
 
 	if (d.mode === "single" && d.results.length === 1) {
@@ -198,15 +211,17 @@ export function renderSubagentResult(
 				: "";
 
 		const w = getTermWidth() - 4;
+		const fit = (text: string) => expanded ? text : truncLine(text, w);
+		const toolCallLines = getToolCallLines(r, expanded);
 		const c = new Container();
-		c.addChild(new Text(truncLine(`${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${contextBadge}${progressInfo}`, w), 0, 0));
+		c.addChild(new Text(fit(`${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${contextBadge}${progressInfo}`), 0, 0));
 		c.addChild(new Spacer(1));
 		const taskMaxLen = Math.max(20, w - 8);
-		const taskPreview = r.task.length > taskMaxLen
-			? `${r.task.slice(0, taskMaxLen)}...`
-			: r.task;
+		const taskPreview = expanded || r.task.length <= taskMaxLen
+			? r.task
+			: `${r.task.slice(0, taskMaxLen)}...`;
 		c.addChild(
-			new Text(truncLine(theme.fg("dim", `Task: ${taskPreview}`), w), 0, 0),
+			new Text(fit(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0),
 		);
 		c.addChild(new Spacer(1));
 
@@ -214,58 +229,58 @@ export function renderSubagentResult(
 			if (r.progress.currentTool) {
 				const maxToolArgsLen = Math.max(50, w - 20);
 				const toolArgsPreview = r.progress.currentToolArgs
-					? (r.progress.currentToolArgs.length > maxToolArgsLen
-						? `${r.progress.currentToolArgs.slice(0, maxToolArgsLen)}...`
-						: r.progress.currentToolArgs)
+					? (expanded || r.progress.currentToolArgs.length <= maxToolArgsLen
+						? r.progress.currentToolArgs
+						: `${r.progress.currentToolArgs.slice(0, maxToolArgsLen)}...`)
 					: "";
 				const toolLine = toolArgsPreview
 					? `${r.progress.currentTool}: ${toolArgsPreview}`
 					: r.progress.currentTool;
-				c.addChild(new Text(truncLine(theme.fg("warning", `> ${toolLine}`), w), 0, 0));
+				c.addChild(new Text(fit(theme.fg("warning", `> ${toolLine}`)), 0, 0));
 			}
 			if (r.progress.recentTools?.length) {
 				for (const t of r.progress.recentTools.slice(-3)) {
 					const maxArgsLen = Math.max(40, w - 24);
-					const argsPreview = t.args.length > maxArgsLen
-						? `${t.args.slice(0, maxArgsLen)}...`
-						: t.args;
-					c.addChild(new Text(truncLine(theme.fg("dim", `${t.tool}: ${argsPreview}`), w), 0, 0));
+					const argsPreview = expanded || t.args.length <= maxArgsLen
+						? t.args
+						: `${t.args.slice(0, maxArgsLen)}...`;
+					c.addChild(new Text(fit(theme.fg("dim", `${t.tool}: ${argsPreview}`)), 0, 0));
 				}
 			}
 			for (const line of (r.progress.recentOutput ?? []).slice(-5)) {
-				c.addChild(new Text(truncLine(theme.fg("dim", `  ${line}`), w), 0, 0));
+				c.addChild(new Text(fit(theme.fg("dim", `  ${line}`)), 0, 0));
 			}
 			if (r.progress.currentTool || r.progress.recentTools?.length || r.progress.recentOutput?.length) {
 				c.addChild(new Spacer(1));
 			}
 		}
 
-		const items = getDisplayItems(r.messages);
-		for (const item of items) {
-			if (item.type === "tool")
-				c.addChild(new Text(truncLine(theme.fg("muted", formatToolCall(item.name, item.args)), w), 0, 0));
+		if (expanded) {
+			for (const line of toolCallLines) {
+				c.addChild(new Text(fit(theme.fg("muted", line)), 0, 0));
+			}
+			if (toolCallLines.length) c.addChild(new Spacer(1));
 		}
-		if (items.length) c.addChild(new Spacer(1));
 
 		if (output) c.addChild(new Markdown(output, 0, 0, mdTheme));
 		c.addChild(new Spacer(1));
 		if (r.skills?.length) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `Skills: ${r.skills.join(", ")}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `Skills: ${r.skills.join(", ")}`)), 0, 0));
 		}
 		if (r.skillsWarning) {
-			c.addChild(new Text(truncLine(theme.fg("warning", `Warning: ${r.skillsWarning}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("warning", `Warning: ${r.skillsWarning}`)), 0, 0));
 		}
 		if (r.attemptedModels && r.attemptedModels.length > 1) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
 		}
-		c.addChild(new Text(truncLine(theme.fg("dim", formatUsage(r.usage, r.model)), w), 0, 0));
+		c.addChild(new Text(fit(theme.fg("dim", formatUsage(r.usage, r.model))), 0, 0));
 		if (r.sessionFile) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`)), 0, 0));
 		}
 
 		if (r.artifactPaths) {
 			c.addChild(new Spacer(1));
-			c.addChild(new Text(truncLine(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
 		}
 		return c;
 	}
@@ -341,16 +356,17 @@ export function renderSubagentResult(
 		: null;
 
 	const w = getTermWidth() - 4;
+	const fit = (text: string) => expanded ? text : truncLine(text, w);
 	const c = new Container();
 	c.addChild(
 		new Text(
-			truncLine(`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge}${stepInfo}${summaryStr}`, w),
+			fit(`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge}${stepInfo}${summaryStr}`),
 			0,
 			0,
 		),
 	);
 	if (chainVis) {
-		c.addChild(new Text(truncLine(`  ${chainVis}`, w), 0, 0));
+		c.addChild(new Text(fit(`  ${chainVis}`), 0, 0));
 	}
 
 	const useResultsDirectly = hasParallelInChain || !d.chainAgents?.length;
@@ -365,7 +381,7 @@ export function renderSubagentResult(
 			: (d.chainAgents![i] || r?.agent || `step-${i + 1}`);
 
 		if (!r) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `  Step ${i + 1}: ${agentName}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `  Step ${i + 1}: ${agentName}`)), 0, 0));
 			c.addChild(new Text(theme.fg("dim", `    status: pending`), 0, 0));
 			c.addChild(new Spacer(1));
 			continue;
@@ -389,58 +405,66 @@ export function renderSubagentResult(
 		const stepHeader = rRunning
 			? `${statusIcon} Step ${i + 1}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}`
 			: `${statusIcon} Step ${i + 1}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
-		c.addChild(new Text(truncLine(stepHeader, w), 0, 0));
+		const toolCallLines = getToolCallLines(r, expanded);
+		c.addChild(new Text(fit(stepHeader), 0, 0));
 
 		const taskMaxLen = Math.max(20, w - 12);
-		const taskPreview = r.task.length > taskMaxLen
-			? `${r.task.slice(0, taskMaxLen)}...`
-			: r.task;
-		c.addChild(new Text(truncLine(theme.fg("dim", `    task: ${taskPreview}`), w), 0, 0));
+		const taskPreview = expanded || r.task.length <= taskMaxLen
+			? r.task
+			: `${r.task.slice(0, taskMaxLen)}...`;
+		c.addChild(new Text(fit(theme.fg("dim", `    task: ${taskPreview}`)), 0, 0));
 
 		const outputTarget = extractOutputTarget(r.task);
 		if (outputTarget) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `    output: ${outputTarget}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `    output: ${outputTarget}`)), 0, 0));
 		}
 
 		if (r.skills?.length) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `    skills: ${r.skills.join(", ")}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0));
 		}
 		if (r.skillsWarning) {
-			c.addChild(new Text(truncLine(theme.fg("warning", `    Warning: ${r.skillsWarning}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0));
 		}
 		if (r.attemptedModels && r.attemptedModels.length > 1) {
-			c.addChild(new Text(truncLine(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`), w), 0, 0));
+			c.addChild(new Text(fit(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
 		}
 
 		if (rRunning && rProg) {
 			if (rProg.skills?.length) {
-				c.addChild(new Text(truncLine(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`), w), 0, 0));
+				c.addChild(new Text(fit(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`)), 0, 0));
 			}
 			if (rProg.currentTool) {
 				const maxToolArgsLen = Math.max(50, w - 20);
 				const toolArgsPreview = rProg.currentToolArgs
-					? (rProg.currentToolArgs.length > maxToolArgsLen
-						? `${rProg.currentToolArgs.slice(0, maxToolArgsLen)}...`
-						: rProg.currentToolArgs)
+					? (expanded || rProg.currentToolArgs.length <= maxToolArgsLen
+						? rProg.currentToolArgs
+						: `${rProg.currentToolArgs.slice(0, maxToolArgsLen)}...`)
 					: "";
 				const toolLine = toolArgsPreview
 					? `${rProg.currentTool}: ${toolArgsPreview}`
 					: rProg.currentTool;
-				c.addChild(new Text(truncLine(theme.fg("warning", `    > ${toolLine}`), w), 0, 0));
+				c.addChild(new Text(fit(theme.fg("warning", `    > ${toolLine}`)), 0, 0));
 			}
 			if (rProg.recentTools?.length) {
 				for (const t of rProg.recentTools.slice(-3)) {
 					const maxArgsLen = Math.max(40, w - 30);
-					const argsPreview = t.args.length > maxArgsLen
-						? `${t.args.slice(0, maxArgsLen)}...`
-						: t.args;
-					c.addChild(new Text(truncLine(theme.fg("dim", `      ${t.tool}: ${argsPreview}`), w), 0, 0));
+					const argsPreview = expanded || t.args.length <= maxArgsLen
+						? t.args
+						: `${t.args.slice(0, maxArgsLen)}...`;
+					c.addChild(new Text(fit(theme.fg("dim", `      ${t.tool}: ${argsPreview}`)), 0, 0));
 				}
 			}
 			const recentLines = (rProg.recentOutput ?? []).slice(-5);
 			for (const line of recentLines) {
-				c.addChild(new Text(truncLine(theme.fg("dim", `      ${line}`), w), 0, 0));
+				c.addChild(new Text(fit(theme.fg("dim", `      ${line}`)), 0, 0));
+			}
+		}
+
+		if (expanded && !rRunning) {
+			for (const line of toolCallLines) {
+				c.addChild(new Text(fit(theme.fg("muted", `      ${line}`)), 0, 0));
 			}
+			if (toolCallLines.length) c.addChild(new Spacer(1));
 		}
 
 		c.addChild(new Spacer(1));
@@ -448,7 +472,7 @@ export function renderSubagentResult(
 
 	if (d.artifacts) {
 		c.addChild(new Spacer(1));
-		c.addChild(new Text(truncLine(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`), w), 0, 0));
+		c.addChild(new Text(fit(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`)), 0, 0));
 	}
 	return c;
 }

package/schemas.ts

@@ -73,6 +73,7 @@ export const SubagentParams = Type.Object({
 		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent."
 	})),
 	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?}, ...]" })),
+	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4." })),
 	worktree: Type.Optional(Type.Boolean({
 		description: "Create isolated git worktrees for each parallel task. " +
 			"Prevents filesystem conflicts. Requires clean git state. " +

package/slash-commands.ts

@@ -14,7 +14,6 @@ import {
 	finalizeSlashResult,
 } from "./slash-live-state.ts";
 import {
-	MAX_PARALLEL,
 	SLASH_RESULT_TYPE,
 	SLASH_SUBAGENT_CANCEL_EVENT,
 	SLASH_SUBAGENT_REQUEST_EVENT,
@@ -453,22 +452,18 @@ export function registerSlashCommands(
 	pi.registerCommand("parallel", {
 		description: "Run agents in parallel: /parallel scout \"task1\" -> reviewer \"task2\" [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
-			if (!parsed) return;
-			if (parsed.steps.length > MAX_PARALLEL) { ctx.ui.notify(`Max ${MAX_PARALLEL} parallel tasks`, "error"); return; }
-			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
-				agent: name,
-				task: stepTask ?? parsed.task,
-				...(config.output !== undefined ? { output: config.output } : {}),
-				...(config.reads !== undefined ? { reads: config.reads } : {}),
-				...(config.model ? { model: config.model } : {}),
-				...(config.skill !== undefined ? { skill: config.skill } : {}),
-				...(config.progress !== undefined ? { progress: config.progress } : {}),
-			}));
-			const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
-			if (bg) params.async = true;
+			handler: async (args, ctx) => {
+				const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
+				const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
+				if (!parsed) return;
+				const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
+					agent: name,
+					task: stepTask ?? parsed.task,
+					...(config.model ? { model: config.model } : {}),
+					...(config.skill !== undefined ? { skill: config.skill } : {}),
+				}));
+				const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
+				if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
 		},

package/subagent-executor.ts

@@ -45,9 +45,9 @@ import {
 	type SingleResult,
 	type SubagentState,
 	DEFAULT_ARTIFACT_CONFIG,
-	MAX_CONCURRENCY,
-	MAX_PARALLEL,
 	checkSubagentDepth,
+	resolveTopLevelParallelConcurrency,
+	resolveTopLevelParallelMaxTasks,
 	resolveChildMaxSubagentDepth,
 	resolveCurrentMaxSubagentDepth,
 	wrapForkTask,
@@ -60,9 +60,6 @@ interface TaskParam {
 	count?: number;
 	model?: string;
 	skill?: string | string[] | boolean;
-	output?: string | false;
-	reads?: string[] | false;
-	progress?: boolean;
 }
 
 export interface SubagentParamsLike {
@@ -71,6 +68,7 @@ export interface SubagentParamsLike {
 	task?: string;
 	chain?: ChainStep[];
 	tasks?: TaskParam[];
+	concurrency?: number;
 	worktree?: boolean;
 	context?: "fresh" | "fork";
 	async?: boolean;
@@ -113,7 +111,7 @@ interface ExecutionContextData {
 	sessionFileForIndex: (idx?: number) => string | undefined;
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
-	parallelDowngraded: boolean;
+	backgroundRequestedWhileClarifying: boolean;
 	effectiveAsync: boolean;
 }
 
@@ -349,6 +347,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		effectiveAsync,
 	} = data;
 	const hasChain = (params.chain?.length ?? 0) > 0;
+	const hasTasks = (params.tasks?.length ?? 0) > 0;
 	const hasSingle = Boolean(params.agent && params.task);
 	if (!effectiveAsync) return null;
 
@@ -363,6 +362,17 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		}
 	}
 
+	if (hasTasks && params.tasks) {
+		const maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
+		if (params.tasks.length > maxParallelTasks) {
+			return buildParallelModeError(`Max ${maxParallelTasks} tasks`);
+		}
+		if (params.worktree) {
+			const worktreeTaskCwdError = buildParallelWorktreeTaskCwdError(params.tasks, effectiveCwd);
+			if (worktreeTaskCwdError) return buildParallelModeError(worktreeTaskCwdError);
+		}
+	}
+
 	if (!isAsyncAvailable()) {
 		return {
 			content: [{ type: "text", text: "Async mode requires jiti for TypeScript execution but it could not be found. Install globally: npm install -g jiti" }],
@@ -383,6 +393,43 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		fullId: `${m.provider}/${m.id}`,
 	}));
 	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
+	const currentProvider = ctx.model?.provider;
+
+	if (hasTasks && params.tasks) {
+		const agentConfigs = params.tasks.map((task) => agents.find((agent) => agent.name === task.agent));
+		const modelOverrides = params.tasks.map((task, index) =>
+			resolveModelCandidate(task.model ?? agentConfigs[index]?.model, availableModels, currentProvider),
+		);
+		const skillOverrides = params.tasks.map((task) => normalizeSkillInput(task.skill));
+		const parallelTasks = params.tasks.map((task, index) => ({
+			agent: task.agent,
+			task: params.context === "fork" ? wrapForkTask(task.task) : task.task,
+			cwd: task.cwd,
+			...(modelOverrides[index] ? { model: modelOverrides[index] } : {}),
+			...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
+		}));
+		return executeAsyncChain(id, {
+			chain: [{
+				parallel: parallelTasks,
+				concurrency: resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency),
+				worktree: params.worktree,
+			}],
+			agents,
+			ctx: asyncCtx,
+			availableModels,
+			cwd: effectiveCwd,
+			maxOutput: params.maxOutput,
+			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+			artifactConfig,
+			shareEnabled,
+			sessionRoot,
+			chainSkills: [],
+			sessionFilesByFlatIndex: params.tasks.map((_, index) => sessionFileForIndex(index)),
+			maxSubagentDepth: currentMaxSubagentDepth,
+			worktreeSetupHook: deps.config.worktreeSetupHook,
+			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
+		});
+	}
 
 	if (hasChain && params.chain) {
 		const normalized = normalizeSkillInput(params.skill);
@@ -421,7 +468,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		const normalizedSkills = normalizeSkillInput(params.skill);
 		const skills = normalizedSkills === false ? [] : normalizedSkills;
 		const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
-		const modelOverride = resolveModelCandidate((params.model as string | undefined) ?? a.model, availableModels, ctx.model?.provider);
+		const modelOverride = resolveModelCandidate((params.model as string | undefined) ?? a.model, availableModels, currentProvider);
 		return executeAsyncSingle(id, {
 			agent: params.agent!,
 			task: params.context === "fork" ? wrapForkTask(params.task!) : params.task!,
@@ -551,6 +598,7 @@ interface ForegroundParallelRunInput {
 	modelOverrides: (string | undefined)[];
 	skillOverrides: (string[] | false | undefined)[];
 	behaviors: Array<ReturnType<typeof resolveStepBehavior>>;
+	concurrencyLimit: number;
 	liveResults: (SingleResult | undefined)[];
 	liveProgress: (AgentProgress | undefined)[];
 	onUpdate?: (r: AgentToolResult<Details>) => void;
@@ -634,7 +682,7 @@ function buildParallelWorktreeSuffix(
 }
 
 async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Promise<SingleResult[]> {
-	return mapConcurrent(input.tasks, MAX_CONCURRENCY, async (task, index) => {
+	return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
 		const overrideSkills = input.skillOverrides[index];
 		const effectiveSkills = overrideSkills === undefined ? input.behaviors[index]?.skills : overrideSkills;
 		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
@@ -690,17 +738,19 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		shareEnabled,
 		artifactConfig,
 		artifactsDir,
-		parallelDowngraded,
+		backgroundRequestedWhileClarifying,
 		onUpdate,
 		sessionRoot,
 	} = data;
 	const allProgress: AgentProgress[] = [];
 	const allArtifactPaths: ArtifactPaths[] = [];
 	const tasks = params.tasks!;
+	const maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
+	const parallelConcurrency = resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency);
 
-	if (tasks.length > MAX_PARALLEL)
+	if (tasks.length > maxParallelTasks)
 		return {
-			content: [{ type: "text", text: `Max ${MAX_PARALLEL} tasks` }],
+			content: [{ type: "text", text: `Max ${maxParallelTasks} tasks` }],
 			isError: true,
 			details: { mode: "parallel" as const, results: [] },
 		};
@@ -800,7 +850,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
 			}));
 			return executeAsyncChain(id, {
-				chain: [{ parallel: parallelTasks, worktree: params.worktree }],
+				chain: [{ parallel: parallelTasks, concurrency: parallelConcurrency, worktree: params.worktree }],
 				agents,
 				ctx: asyncCtx,
 				availableModels,
@@ -857,6 +907,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 			modelOverrides,
 			skillOverrides,
 			behaviors,
+			concurrencyLimit: parallelConcurrency,
 			maxSubagentDepths,
 			liveResults,
 			liveProgress,
@@ -875,7 +926,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 
 		const worktreeSuffix = buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks);
 		const ok = results.filter((result) => result.exitCode === 0).length;
-		const downgradeNote = parallelDowngraded ? " (async not supported for parallel)" : "";
+		const downgradeNote = backgroundRequestedWhileClarifying ? " (background requested, but clarify kept this run foreground)" : "";
 		const aggregatedOutput = aggregateParallelOutputs(
 			results.map((result) => ({
 				agent: result.agent,
@@ -1200,11 +1251,9 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		}
 
 		const requestedAsync = normalizedParams.async ?? deps.asyncByDefault;
-		const parallelDowngraded = hasTasks && requestedAsync;
-		let effectiveAsync = false;
-		if (requestedAsync && !hasTasks) {
-			effectiveAsync = hasChain ? normalizedParams.clarify === false : normalizedParams.clarify !== true;
-		}
+		const backgroundRequestedWhileClarifying = hasTasks && requestedAsync && normalizedParams.clarify === true;
+		const effectiveAsync = requestedAsync
+			&& (hasChain ? normalizedParams.clarify === false : normalizedParams.clarify !== true);
 
 		const artifactConfig: ArtifactConfig = {
 			...DEFAULT_ARTIFACT_CONFIG,
@@ -1251,7 +1300,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 			sessionFileForIndex,
 			artifactConfig,
 			artifactsDir,
-			parallelDowngraded,
+			backgroundRequestedWhileClarifying,
 			effectiveAsync,
 		};
 

package/types.ts

@@ -61,6 +61,11 @@ export interface AgentProgress {
 	failedTool?: string;
 }
 
+export interface ToolCallSummary {
+	text: string;
+	expandedText: string;
+}
+
 export interface ProgressSummary {
 	toolCount: number;
 	tokens: number;
@@ -96,6 +101,7 @@ export interface SingleResult {
 	skillsWarning?: string;
 	progress?: AgentProgress;
 	progressSummary?: ProgressSummary;
+	toolCalls?: ToolCallSummary[];
 	artifactPaths?: ArtifactPaths;
 	truncation?: TruncationResult;
 	finalOutput?: string;
@@ -273,10 +279,16 @@ export interface IntercomBridgeConfig {
 	instructionFile?: string;
 }
 
+export interface TopLevelParallelConfig {
+	maxTasks?: number;
+	concurrency?: number;
+}
+
 export interface ExtensionConfig {
 	asyncByDefault?: boolean;
 	defaultSessionDir?: string;
 	maxSubagentDepth?: number;
+	parallel?: TopLevelParallelConfig;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	intercomBridge?: IntercomBridgeConfig;
@@ -376,6 +388,25 @@ export const DEFAULT_FORK_PREAMBLE =
 	"Your sole job is to execute the task below. Do not continue or respond to the prior conversation " +
 	"— focus exclusively on completing this task using your tools.";
 
+function normalizeTopLevelParallelValue(value: unknown): number | undefined {
+	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+	if (!Number.isInteger(parsed) || parsed < 1) return undefined;
+	return parsed;
+}
+
+export function resolveTopLevelParallelMaxTasks(value: unknown): number {
+	return normalizeTopLevelParallelValue(value) ?? MAX_PARALLEL;
+}
+
+export function resolveTopLevelParallelConcurrency(
+	override: unknown,
+	configValue: unknown,
+): number {
+	return normalizeTopLevelParallelValue(override)
+		?? normalizeTopLevelParallelValue(configValue)
+		?? MAX_CONCURRENCY;
+}
+
 export function getAsyncConfigPath(suffix: string): string {
 	return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
 }

package/utils.ts

@@ -6,7 +6,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@mariozechner/pi-ai";
-import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
+import { formatToolCall } from "./formatters.ts";
+import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult, ToolCallSummary } from "./types.ts";
 
 // ============================================================================
 // File System Utilities
@@ -242,12 +243,33 @@ function compactCompletedProgress(progress: AgentProgress): AgentProgress {
 	};
 }
 
+export function extractToolCallSummaries(messages: Message[] | undefined): ToolCallSummary[] {
+	if (!messages?.length) return [];
+	const summaries: ToolCallSummary[] = [];
+	for (const msg of messages) {
+		if (msg.role !== "assistant") continue;
+		for (const part of msg.content) {
+			if (part.type !== "toolCall") continue;
+			const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments)
+				? part.arguments
+				: {};
+			summaries.push({
+				text: formatToolCall(part.name, args),
+				expandedText: formatToolCall(part.name, args, true),
+			});
+		}
+	}
+	return summaries;
+}
+
 export function compactForegroundResult(result: SingleResult): SingleResult {
 	if (result.progress?.status === "running") return result;
+	const toolCalls = result.toolCalls?.length ? result.toolCalls : extractToolCallSummaries(result.messages);
 	return {
 		...result,
 		messages: undefined,
 		progress: undefined,
+		toolCalls: toolCalls.length ? toolCalls : undefined,
 	};
 }