pi-subagents 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.23.0] - 2026-05-02
+
+### Fixed
+- Detect `pi-intercom` when installed through the documented `pi install npm:pi-intercom` package flow, instead of only checking the legacy local extension path.
+
+### Changed
+- Store and discover saved chain workflows from dedicated chain directories: user chains in `~/.pi/agent/chains/**/*.chain.md` and project chains in `.pi/chains/**/*.chain.md`.
+- Retry foreground subagent fallback models when Pi reports a retryable provider error, such as 429/quota, even if the child process exits successfully.
+- Align single-run async subagent widgets and `/subagents-status` rendering with foreground subagent result styling for parallel, chain, and grouped chain runs, including inline live detail when tool output expansion is enabled, while keeping multi-job async widgets compact.
+- Render async subagent widgets through an adaptive component so active parallel agent rows fit without Pi's fixed string-widget truncation marker.
+- Tell parent agents that async runs are detached and they should end the turn instead of running sleep/poll loops when no independent work remains.
+
 ## [0.22.0] - 2026-05-02
 
 ### Added

package/README.md

@@ -211,7 +211,7 @@ The package includes reusable prompt templates for common workflows. You do not
 pi install npm:pi-intercom
 ```
 
-Most users do not call `intercom` directly. After `pi-intercom` is installed, `pi-subagents` can automatically give child agents a private coordination channel back to the parent session.
+Most users do not call `intercom` directly. After `pi-intercom` is installed, `pi-subagents` can automatically give child agents a private coordination channel back to the parent session. The bridge recognizes the normal `pi install npm:pi-intercom` package install as well as legacy local extension checkouts.
 
 Use it for work where the child might need a decision instead of guessing:
 
@@ -332,6 +332,8 @@ You can combine them in either order:
 /run reviewer "review this diff" --bg --fork
 ```
 
+Background runs are detached. If the parent agent has other independent work, it should keep working. If it has nothing useful to do until the background result arrives, it should end the turn instead of running sleep or status-polling loops. Pi will deliver the completion when the run finishes.
+
 The `oracle` and `worker` builtins are designed for an explicit decision loop. A typical pattern is to ask `oracle` for diagnosis and a recommended execution prompt, then only run `worker` after the main agent approves that direction.
 
 ## Clarify and launch UI
@@ -401,7 +403,7 @@ Agent locations, lowest to highest priority:
 | User | `~/.pi/agent/agents/**/*.md` |
 | Project | `.pi/agents/**/*.md` |
 
-Project discovery also reads legacy `.agents/**/*.md` files. Nested subdirectories are discovered recursively. `.chain.md` files are treated as chains, not agents. If both `.agents/` and `.pi/agents/` define the same parsed runtime agent name, `.pi/agents/` wins. Use `agentScope: "user" | "project" | "both"` to control discovery; `both` is the default and project definitions win runtime-name collisions.
+Project discovery also reads legacy `.agents/**/*.md` files. Nested subdirectories are discovered recursively. `.chain.md` files do not define agents. If both `.agents/` and `.pi/agents/` define the same parsed runtime agent name, `.pi/agents/` wins. Use `agentScope: "user" | "project" | "both"` to control discovery; `both` is the default and project definitions win runtime-name collisions.
 
 Builtin agents load at the lowest priority, so a user or project agent with the same name overrides them. They do not pin a provider model; they inherit your current Pi default model unless you set `subagents.agentOverrides.<name>.model`. `oracle` is an advisory reviewer that critiques direction and proposes an execution prompt without editing files. `worker` is the implementation agent for normal tasks and approved oracle handoffs.
 
@@ -531,14 +533,14 @@ When `extensions` is present, it takes precedence over extension paths implied b
 
 ## Chain files
 
-Chains are reusable `.chain.md` workflows stored next to agent files.
+Chains are reusable `.chain.md` workflows stored separately from agent files.
 
 | Scope | Path |
 |-------|------|
-| User | `~/.pi/agent/agents/**/*.chain.md` |
-| Project | `.pi/agents/**/*.chain.md` |
+| User | `~/.pi/agent/chains/**/*.chain.md` |
+| Project | `.pi/chains/**/*.chain.md` |
 
-Project discovery also reads legacy `.agents/**/*.chain.md` files. Nested subdirectories are discovered recursively. If both locations define the same parsed runtime chain name, `.pi/agents/` wins. Chains support the same optional `package` frontmatter as agents; `name: review-flow` plus `package: code-analysis` runs as `code-analysis.review-flow`.
+Nested subdirectories are discovered recursively. If user and project scopes define the same parsed runtime chain name, the project chain wins. Chains support the same optional `package` frontmatter as agents; `name: review-flow` plus `package: code-analysis` runs as `code-analysis.review-flow`.
 
 Example:
 
@@ -893,7 +895,7 @@ Fields:
 - `mode`: default `always`; use `fork-only` to inject only for forked runs, or `off` to disable the bridge.
 - `instructionFile`: optional Markdown template replacing the default bridge instructions. `{orchestratorTarget}` is interpolated. Relative paths resolve from `~/.pi/agent/extensions/subagent/`.
 
-Bridge activation also requires `pi-intercom` to be installed and enabled, a targetable current session name or fallback alias, and `pi-intercom` in any explicit agent `extensions` allowlist.
+Bridge activation also requires `pi-intercom` to be installed and enabled through `pi install npm:pi-intercom` or a legacy local extension checkout, a targetable current session name or fallback alias, and `pi-intercom` in any explicit agent `extensions` allowlist.
 
 The default injected guidance tells children to use `contact_supervisor` with `reason: "need_decision"` when blocked or needing a decision, `reason: "progress_update"` only for meaningful blocked/progress updates, generic `intercom` as fallback plumbing, and avoid routine completion handoffs.
 

package/package.json

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

package/skills/pi-subagents/SKILL.md

@@ -183,11 +183,10 @@ Agent files can live in:
 - legacy `.agents/**/*.md` — still read for compatibility, but `.pi/agents/` wins on conflicts
 
 Chains live in:
-- `~/.pi/agent/agents/**/*.chain.md`
-- `.pi/agents/**/*.chain.md`
-- legacy `.agents/**/*.chain.md`
+- `~/.pi/agent/chains/**/*.chain.md` — user scope
+- `.pi/chains/**/*.chain.md` — project scope
 
-Discovery is recursive. `.chain.md` files are chains, not agents. Agents and chains can set optional frontmatter `package: code-analysis`; `name: scout` plus `package: code-analysis` registers as runtime name `code-analysis.scout` while serialization keeps `name` and `package` separate.
+Discovery is recursive. `.chain.md` files do not define agents. Agents and chains can set optional frontmatter `package: code-analysis`; `name: scout` plus `package: code-analysis` registers as runtime name `code-analysis.scout` while serialization keeps `name` and `package` separate.
 
 Precedence is by parsed runtime name:
 1. project scope
@@ -263,7 +262,9 @@ without forcing each step to rediscover everything.
 
 ### Async/background
 
-Use async mode whenever the parent agent should keep working while a child runs. A normal foreground `subagent(...)` call blocks the parent until the child completes; it is appropriate when the next parent step depends on the child result. If you say you will "ask a reviewer while I continue auditing" or otherwise run local work in parallel with a child, launch with `async: true`. Do not end your turn immediately after launching that async child if you promised to keep working; continue the local inspection or other independent work, then check the async run when its result is needed.
+Use async mode whenever the parent agent should keep working while a child runs. A normal foreground `subagent(...)` call blocks the parent until the child completes; it is appropriate when the next parent step depends on the child result. If you say you will "ask a reviewer while I continue auditing" or otherwise run local work in parallel with a child, launch with `async: true`.
+
+Do not end your turn immediately after launching an async child if you promised to keep working. Continue the local inspection or other independent work, then check the async run when its result is needed. If there is no independent work left and you would only be running `sleep` or status polling commands to wait, end your turn instead. Pi will deliver the async completion when it arrives.
 
 ```typescript
 subagent({

package/src/agents/agent-management.ts

@@ -459,7 +459,9 @@ export function handleCreate(params: ManagementParams, ctx: ManagementContext):
 	const scope = scopeRaw as ManagementScope;
 	const isChain = hasKey(cfg, "steps");
 	const d = discoverAgentsAll(ctx.cwd);
-	const targetDir = scope === "user" ? d.userDir : d.projectDir ?? path.join(ctx.cwd, ".pi", "agents");
+	const targetDir = isChain
+		? scope === "user" ? d.userChainDir : d.projectChainDir ?? path.join(ctx.cwd, ".pi", "chains")
+		: scope === "user" ? d.userDir : d.projectDir ?? path.join(ctx.cwd, ".pi", "agents");
 	fs.mkdirSync(targetDir, { recursive: true });
 	if (nameExistsInScope(ctx.cwd, scope, runtimeName)) return result(`Name '${runtimeName}' already exists in ${scope} scope. Use update instead.`, true);
 	const targetPath = path.join(targetDir, isChain ? `${runtimeName}.chain.md` : `${runtimeName}.md`);

package/src/agents/agents.ts

@@ -130,6 +130,10 @@ interface AgentDiscoveryResult {
 	projectAgentsDir: string | null;
 }
 
+export function getUserChainDir(): string {
+	return path.join(os.homedir(), ".pi", "agent", "chains");
+}
+
 function splitToolList(rawTools: string[] | undefined): { tools?: string[]; mcpDirectTools?: string[] } {
 	const mcpDirectTools: string[] = [];
 	const tools: string[] = [];
@@ -705,6 +709,17 @@ function resolveNearestProjectAgentDirs(cwd: string): { readDirs: string[]; pref
 		preferredDir,
 	};
 }
+
+function resolveNearestProjectChainDirs(cwd: string): { readDirs: string[]; preferredDir: string | null } {
+	const projectRoot = findNearestProjectRoot(cwd);
+	if (!projectRoot) return { readDirs: [], preferredDir: null };
+
+	const preferredDir = path.join(projectRoot, ".pi", "chains");
+	return {
+		readDirs: isDirectory(preferredDir) ? [preferredDir] : [],
+		preferredDir,
+	};
+}
 const BUILTIN_AGENTS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
@@ -742,12 +757,16 @@ export function discoverAgentsAll(cwd: string): {
 	chains: ChainConfig[];
 	userDir: string;
 	projectDir: string | null;
+	userChainDir: string;
+	projectChainDir: string | null;
 	userSettingsPath: string;
 	projectSettingsPath: string | null;
 } {
 	const userDirOld = path.join(os.homedir(), ".pi", "agent", "agents");
 	const userDirNew = path.join(os.homedir(), ".agents");
+	const userChainDir = getUserChainDir();
 	const { readDirs: projectDirs, preferredDir: projectDir } = resolveNearestProjectAgentDirs(cwd);
+	const { readDirs: projectChainDirs, preferredDir: projectChainDir } = resolveNearestProjectChainDirs(cwd);
 	const userSettingsPath = getUserAgentSettingsPath();
 	const projectSettingsPath = getProjectAgentSettingsPath(cwd);
 	const userSettings = readSubagentSettings(userSettingsPath);
@@ -773,18 +792,17 @@ export function discoverAgentsAll(cwd: string): {
 	const project = Array.from(projectMap.values());
 
 	const chainMap = new Map<string, ChainConfig>();
-	for (const dir of projectDirs) {
+	for (const dir of projectChainDirs) {
 		for (const chain of loadChainsFromDir(dir, "project")) {
 			chainMap.set(chain.name, chain);
 		}
 	}
 	const chains = [
-		...loadChainsFromDir(userDirOld, "user"),
-		...loadChainsFromDir(userDirNew, "user"),
+		...loadChainsFromDir(userChainDir, "user"),
 		...Array.from(chainMap.values()),
 	];
 
 	const userDir = fs.existsSync(userDirNew) ? userDirNew : userDirOld;
 
-	return { builtin, user, project, chains, userDir, projectDir, userSettingsPath, projectSettingsPath };
+	return { builtin, user, project, chains, userDir, projectDir, userChainDir, projectChainDir, userSettingsPath, projectSettingsPath };
 }

package/src/extension/doctor.ts

@@ -192,6 +192,7 @@ export function buildDoctorReport(input: DoctorReportInput): string {
 			config: input.config.intercomBridge,
 			context: input.context,
 			orchestratorTarget: input.orchestratorTarget,
+			cwd: input.cwd,
 		}), input.context).join("\n")).split("\n"),
 	];
 	return lines.join("\n");

package/src/intercom/intercom-bridge.ts

@@ -1,19 +1,27 @@
+import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.ts";
 
-function defaultIntercomExtensionDir(): string {
-	return path.join(os.homedir(), ".pi", "agent", "extensions", "pi-intercom");
+const PI_INTERCOM_PACKAGE_NAME = "pi-intercom";
+const CONFIG_DIR = ".pi";
+
+function defaultAgentDir(): string {
+	return path.join(os.homedir(), ".pi", "agent");
+}
+
+function defaultIntercomExtensionDir(agentDir = defaultAgentDir()): string {
+	return path.join(agentDir, "extensions", PI_INTERCOM_PACKAGE_NAME);
 }
 
-function defaultIntercomConfigPath(): string {
-	return path.join(os.homedir(), ".pi", "agent", "intercom", "config.json");
+function defaultIntercomConfigPath(agentDir = defaultAgentDir()): string {
+	return path.join(agentDir, "intercom", "config.json");
 }
 
-function defaultSubagentConfigDir(): string {
-	return path.join(os.homedir(), ".pi", "agent", "extensions", "subagent");
+function defaultSubagentConfigDir(agentDir = defaultAgentDir()): string {
+	return path.join(agentDir, "extensions", "subagent");
 }
 
 const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
@@ -56,6 +64,9 @@ interface ResolveIntercomBridgeInput {
 	extensionDir?: string;
 	configPath?: string;
 	settingsDir?: string;
+	cwd?: string;
+	agentDir?: string;
+	globalNpmRoot?: string | null;
 }
 
 export function resolveIntercomSessionTarget(sessionName: string | undefined, sessionId: string): string {
@@ -102,6 +113,119 @@ function intercomConfigStatus(configPath: string): { enabled: boolean; error?: u
 	}
 }
 
+function readJsonBestEffort(filePath: string): unknown {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+
+function packageHasPiExtension(packageRoot: string): boolean {
+	if (!fs.existsSync(packageRoot)) return false;
+	const pkg = readJsonBestEffort(path.join(packageRoot, "package.json"));
+	if (pkg && typeof pkg === "object" && !Array.isArray(pkg)) {
+		const pi = (pkg as { pi?: unknown }).pi;
+		if (pi && typeof pi === "object" && !Array.isArray(pi)) {
+			const extensions = (pi as { extensions?: unknown }).extensions;
+			return Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim() !== "");
+		}
+	}
+	return fs.existsSync(path.join(packageRoot, "extensions"));
+}
+
+function isSafePackagePath(value: string): boolean {
+	return value.length > 0
+		&& !path.isAbsolute(value)
+		&& value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+
+function parseNpmPackageName(source: string): string | undefined {
+	const spec = source.slice(4).trim();
+	if (!spec) return undefined;
+	const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
+	const packageName = match?.[1] ?? spec;
+	return isSafePackagePath(packageName) ? packageName : undefined;
+}
+
+function packageEntrySource(entry: unknown): string | undefined {
+	if (typeof entry === "string") return entry;
+	if (entry && typeof entry === "object" && !Array.isArray(entry) && typeof (entry as { source?: unknown }).source === "string") {
+		return (entry as { source: string }).source;
+	}
+	return undefined;
+}
+
+function packageEntryAllowsExtensions(entry: unknown): boolean {
+	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return true;
+	const extensions = (entry as { extensions?: unknown }).extensions;
+	return !Array.isArray(extensions) || extensions.length > 0;
+}
+
+function findNearestProjectConfigDir(cwd: string): string | undefined {
+	let current = path.resolve(cwd);
+	while (true) {
+		const configDir = path.join(current, CONFIG_DIR);
+		if (fs.existsSync(path.join(configDir, "settings.json"))) return configDir;
+		const parent = path.dirname(current);
+		if (parent === current) return undefined;
+		current = parent;
+	}
+}
+
+let cachedGlobalNpmRoot: string | null | undefined;
+
+function getGlobalNpmRoot(): string | null {
+	if (cachedGlobalNpmRoot !== undefined) return cachedGlobalNpmRoot;
+	try {
+		cachedGlobalNpmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 5000 }).trim();
+		return cachedGlobalNpmRoot;
+	} catch {
+		cachedGlobalNpmRoot = null;
+		return null;
+	}
+}
+
+function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agentDir: string): string | undefined {
+	const cwd = path.resolve(input.cwd ?? process.cwd());
+	const projectConfigDir = findNearestProjectConfigDir(cwd);
+	const settingsFiles = [
+		...(projectConfigDir ? [{ file: path.join(projectConfigDir, "settings.json"), configDir: projectConfigDir, scope: "project" as const }] : []),
+		{ file: path.join(agentDir, "settings.json"), configDir: agentDir, scope: "user" as const },
+	];
+	const globalNpmRoot = input.globalNpmRoot === undefined ? getGlobalNpmRoot() : input.globalNpmRoot;
+
+	for (const { file, configDir, scope } of settingsFiles) {
+		const settings = readJsonBestEffort(file);
+		if (!settings || typeof settings !== "object" || Array.isArray(settings)) continue;
+		const packages = (settings as { packages?: unknown }).packages;
+		if (!Array.isArray(packages)) continue;
+
+		for (const entry of packages) {
+			if (!packageEntryAllowsExtensions(entry)) continue;
+			const source = packageEntrySource(entry)?.trim();
+			if (!source?.startsWith("npm:")) continue;
+			const packageName = parseNpmPackageName(source);
+			if (packageName !== PI_INTERCOM_PACKAGE_NAME) continue;
+			const candidates = scope === "project"
+				? [path.join(configDir, "npm", "node_modules", packageName)]
+				: [
+					...(globalNpmRoot ? [path.join(globalNpmRoot, packageName)] : []),
+					path.join(agentDir, "npm", "node_modules", packageName),
+				];
+			const packageRoot = candidates.find(packageHasPiExtension);
+			if (packageRoot) return path.resolve(packageRoot);
+		}
+	}
+	return undefined;
+}
+
+function resolveIntercomExtensionDir(input: ResolveIntercomBridgeInput, agentDir: string): string {
+	const legacyDir = path.resolve(input.extensionDir ?? defaultIntercomExtensionDir(agentDir));
+	if (fs.existsSync(legacyDir)) return legacyDir;
+	return configuredPiIntercomPackageDir(input, agentDir) ?? legacyDir;
+}
+
 function extensionSandboxAllowsIntercom(extensions: string[] | undefined, extensionDir: string): boolean {
 	if (extensions === undefined) return true;
 
@@ -145,9 +269,10 @@ ${instruction}`;
 export function diagnoseIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeDiagnostic {
 	const config = resolveIntercomBridgeConfig(input.config);
 	const mode = config.mode;
-	const extensionDir = path.resolve(input.extensionDir ?? defaultIntercomExtensionDir());
+	const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
+	const extensionDir = resolveIntercomExtensionDir(input, agentDir);
 	const orchestratorTarget = input.orchestratorTarget?.trim();
-	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath());
+	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath(agentDir));
 	const wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork");
 	const piIntercomAvailable = fs.existsSync(extensionDir);
 	let configStatus: ReturnType<typeof intercomConfigStatus> | undefined;
@@ -183,9 +308,10 @@ export function diagnoseIntercomBridge(input: ResolveIntercomBridgeInput): Inter
 export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeState {
 	const config = resolveIntercomBridgeConfig(input.config);
 	const mode = config.mode;
-	const extensionDir = path.resolve(input.extensionDir ?? defaultIntercomExtensionDir());
+	const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
+	const extensionDir = resolveIntercomExtensionDir(input, agentDir);
 	const orchestratorTarget = input.orchestratorTarget?.trim();
-	const settingsDir = path.resolve(input.settingsDir ?? defaultSubagentConfigDir());
+	const settingsDir = path.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir));
 	const defaultInstruction = buildIntercomBridgeInstruction(
 		orchestratorTarget || "{orchestratorTarget}",
 		DEFAULT_INTERCOM_BRIDGE_TEMPLATE,
@@ -204,7 +330,7 @@ export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): Interc
 		return { active: false, mode, extensionDir, instruction: defaultInstruction };
 	}
 
-	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath());
+	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath(agentDir));
 	const intercomStatus = intercomConfigStatus(configPath);
 	if (intercomStatus.error) console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, intercomStatus.error);
 	if (!intercomStatus.enabled) {

package/src/manager-ui/agent-manager.ts

@@ -38,7 +38,7 @@ export type ManagerResult =
 	| { action: "launch-chain"; chain: ChainConfig; task: string; skipClarify?: boolean; fork?: boolean; background?: boolean; worktree?: boolean }
 	| undefined;
 
-export interface AgentData { builtin: AgentConfig[]; user: AgentConfig[]; project: AgentConfig[]; chains: ChainConfig[]; userDir: string; projectDir: string | null; userSettingsPath: string; projectSettingsPath: string | null; cwd: string; }
+export interface AgentData { builtin: AgentConfig[]; user: AgentConfig[]; project: AgentConfig[]; chains: ChainConfig[]; userDir: string; projectDir: string | null; userChainDir: string; projectChainDir: string | null; userSettingsPath: string; projectSettingsPath: string | null; cwd: string; }
 type ManagerScreen = "list" | "detail" | "chain-detail" | "edit" | "edit-field" | "edit-prompt" | "task-input" | "confirm-delete" | "name-input" | "chain-edit" | "template-select" | "parallel-builder" | "override-scope";
 interface AgentEntry { id: string; kind: "agent"; config: AgentConfig; isNew: boolean; }
 interface ChainEntry { id: string; kind: "chain"; config: ChainConfig; }
@@ -253,7 +253,8 @@ export class AgentManagerComponent implements Component {
 	}
 
 	private enterNameInput(mode: NameInputState["mode"], sourceId?: string, template?: AgentTemplate): void {
-		const allowProject = Boolean(this.agentData.projectDir); let initial = ""; let scope: "user" | "project" = "user";
+		const isChain = mode === "new-chain" || mode === "clone-chain";
+		const allowProject = Boolean(isChain ? this.agentData.projectChainDir : this.agentData.projectDir); let initial = ""; let scope: "user" | "project" = "user";
 		if (mode === "clone-agent" && sourceId) { const entry = this.getAgentEntry(sourceId); if (entry) { initial = `${frontmatterNameForConfig(entry.config)}-copy`; scope = entry.config.source === "project" ? "project" : "user"; } }
 		if (mode === "clone-chain" && sourceId) { const entry = this.getChainEntry(sourceId); if (entry) { initial = `${frontmatterNameForConfig(entry.config)}-copy`; scope = entry.config.source === "project" ? "project" : "user"; } }
 		if (mode === "new-agent" && template && template.name !== "Blank") initial = slugTemplateName(template.name);
@@ -425,14 +426,14 @@ export class AgentManagerComponent implements Component {
 
 		if (state.mode === "clone-chain" && state.sourceId) {
 			const sourceEntry = this.getChainEntry(state.sourceId); if (!sourceEntry) { this.screen = "list"; this.tui.requestRender(); return; }
-			const dir = state.scope === "project" ? this.agentData.projectDir : this.agentData.userDir;
-			if (!dir) { state.error = "Project agents directory not found."; this.tui.requestRender(); return; }
+			const dir = state.scope === "project" ? this.agentData.projectChainDir : this.agentData.userChainDir;
+			if (!dir) { state.error = "Project chains directory not found."; this.tui.requestRender(); return; }
 			const filePath = path.join(dir, `${name}.chain.md`); if (fs.existsSync(filePath) || this.runtimeNameExistsInScope("chain", state.scope, name)) { state.error = "A chain with that name already exists."; this.tui.requestRender(); return; }
 			try { const cloned = cloneChainConfig({ ...sourceEntry.config, name, localName: name, packageName: undefined, source: state.scope, filePath }); fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(filePath, serializeChain(cloned), "utf-8"); const added: ChainEntry = { id: `c${this.nextId++}`, kind: "chain", config: cloned }; this.chains.push(added); this.nameInputState = null; this.enterChainDetail(added); this.tui.requestRender(); return; }
 			catch (err) { state.error = err instanceof Error ? err.message : "Failed to clone chain."; this.tui.requestRender(); return; }
 		}
 		if (state.mode === "new-chain") {
-			const dir = state.scope === "project" ? this.agentData.projectDir : this.agentData.userDir;
+			const dir = state.scope === "project" ? this.agentData.projectChainDir : this.agentData.userChainDir;
 			if (!dir) { state.error = "Directory not found."; this.tui.requestRender(); return; }
 			const filePath = path.join(dir, `${name}.chain.md`); if (fs.existsSync(filePath) || this.runtimeNameExistsInScope("chain", state.scope, name)) { state.error = "A chain with that name already exists."; this.tui.requestRender(); return; }
 			const config: ChainConfig = { name, localName: name, description: "Describe this chain", source: state.scope, filePath, steps: [{ agent: "agent-name", task: "{task}" }] };

package/src/runs/background/async-execution.ts

@@ -116,6 +116,16 @@ interface AsyncExecutionResult {
 	isError?: boolean;
 }
 
+export function formatAsyncStartedMessage(headline: string): string {
+	return [
+		headline,
+		"",
+		"The async run is detached. Do not run sleep timers or polling loops just to wait for it.",
+		"If you have independent work, continue that work. If you have nothing else to do until the async result arrives, end your turn now; Pi will deliver the completion when the run finishes.",
+		"Use subagent({ action: \"status\", id: \"...\" }) when you need the current status/result, or to inspect a blocked/stale run. Do not poll just to wait.",
+	].join("\n");
+}
+
 /**
  * Check if jiti is available for async execution
  */
@@ -425,7 +435,7 @@ export function executeAsyncChain(
 		.join(" -> ");
 
 	return {
-		content: [{ type: "text", text: `Async ${resultMode}: ${chainDesc} [${id}]` }],
+		content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`) }],
 		details: { mode: resultMode, results: [], asyncId: id, asyncDir },
 	};
 }
@@ -557,7 +567,7 @@ export function executeAsyncSingle(
 	}
 
 	return {
-		content: [{ type: "text", text: `Async: ${agent} [${id}]` }],
+		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
 		details: { mode: "single", results: [], asyncId: id, asyncDir },
 	};
 }

package/src/runs/background/async-job-tracker.ts

@@ -162,8 +162,8 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 								? groups.find((group) => status.currentStep! >= group.start && status.currentStep! < group.start + group.count)
 								: undefined;
 							const visibleSteps = activeGroup
-								? status.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count)
-								: status.steps;
+								? status.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count).map((step, index) => ({ ...step, index: activeGroup.start + index }))
+								: status.steps.map((step, index) => ({ ...step, index }));
 							job.activeParallelGroup = Boolean(activeGroup);
 							job.agents = visibleSteps.map((step) => step.agent);
 							job.steps = visibleSteps;

package/src/runs/background/async-status.ts

@@ -13,8 +13,11 @@ interface AsyncRunStepSummary {
 	activityState?: ActivityState;
 	lastActivityAt?: number;
 	currentTool?: string;
+	currentToolArgs?: string;
 	currentToolStartedAt?: number;
 	currentPath?: string;
+	recentTools?: Array<{ tool: string; args: string; endMs: number }>;
+	recentOutput?: string[];
 	turnCount?: number;
 	toolCount?: number;
 	durationMs?: number;
@@ -155,8 +158,11 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 				...(stepActivityState ? { activityState: stepActivityState } : {}),
 				...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
 				...(step.currentTool ? { currentTool: step.currentTool } : {}),
+				...(step.currentToolArgs ? { currentToolArgs: step.currentToolArgs } : {}),
 				...(step.currentToolStartedAt ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
 				...(step.currentPath ? { currentPath: step.currentPath } : {}),
+				...(step.recentTools ? { recentTools: step.recentTools.map((tool) => ({ ...tool })) } : {}),
+				...(step.recentOutput ? { recentOutput: [...step.recentOutput] } : {}),
 				...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
 				...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
 				...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
@@ -270,7 +276,7 @@ function formatParallelProgress(steps: Pick<AsyncRunStepSummary, "status">[], to
 	const failed = steps.filter((step) => step.status === "failed").length;
 	const paused = steps.filter((step) => step.status === "paused").length;
 	const parts = [`${done}/${total} done`];
-	if (showRunning) parts.unshift(running === 1 ? "1 agent running" : `${running} agents running`);
+	if (showRunning && running > 0) parts.unshift(running === 1 ? "1 agent running" : `${running} agents running`);
 	if (failed > 0) parts.push(`${failed} failed`);
 	if (paused > 0) parts.push(`${paused} paused`);
 	return parts.join(" · ");

package/src/runs/background/subagent-runner.ts

@@ -142,6 +142,25 @@ function tokenUsageFromAttempts(attempts: ModelAttempt[] | undefined): TokenUsag
 	return total > 0 ? { input, output, total } : null;
 }
 
+function appendRecentStepOutput(step: RunnerStatusStep, lines: string[]): void {
+	const nonEmpty = lines.filter((line) => line.trim());
+	if (nonEmpty.length === 0) return;
+	step.recentOutput ??= [];
+	step.recentOutput.push(...nonEmpty);
+	if (step.recentOutput.length > 50) {
+		step.recentOutput.splice(0, step.recentOutput.length - 50);
+	}
+}
+
+function resetStepLiveDetail(step: RunnerStatusStep): void {
+	step.currentTool = undefined;
+	step.currentToolArgs = undefined;
+	step.currentToolStartedAt = undefined;
+	step.currentPath = undefined;
+	step.recentTools = [];
+	step.recentOutput = [];
+}
+
 interface ChildEventContext {
 	eventsPath: string;
 	runId: string;
@@ -900,6 +919,8 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			skills: step.skills,
 			model: step.model,
 			attemptedModels: step.modelCandidates && step.modelCandidates.length > 0 ? step.modelCandidates : step.model ? [step.model] : undefined,
+			recentTools: [],
+			recentOutput: [],
 		})),
 		artifactsDir,
 		sessionDir: config.sessionDir,
@@ -1002,13 +1023,19 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			const currentPath = resolveCurrentPath(event.toolName, event.args);
 			step.toolCount = (step.toolCount ?? 0) + 1;
 			step.currentTool = event.toolName;
+			step.currentToolArgs = extractToolArgsPreview(event.args ?? {});
 			step.currentToolStartedAt = now;
 			step.currentPath = currentPath;
 			pendingToolResults[flatIndex] = { tool: event.toolName, path: currentPath, mutates, startedAt: now };
 			statusPayload.toolCount = (statusPayload.toolCount ?? 0) + 1;
 			syncTopLevelCurrentTool();
 		} else if (event.type === "tool_execution_end") {
+			if (step.currentTool) {
+				step.recentTools ??= [];
+				step.recentTools.push({ tool: step.currentTool, args: step.currentToolArgs || "", endMs: now });
+			}
 			step.currentTool = undefined;
+			step.currentToolArgs = undefined;
 			step.currentToolStartedAt = undefined;
 			step.currentPath = undefined;
 			syncTopLevelCurrentTool();
@@ -1016,6 +1043,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			const toolSnapshot = pendingToolResults[flatIndex];
 			pendingToolResults[flatIndex] = undefined;
 			const resultText = extractTextFromContent(event.message.content);
+			appendRecentStepOutput(step, resultText.split("\n").slice(-10));
 			if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
 				const state = mutatingFailureStates[flatIndex]!;
 				recordMutatingFailure(state, {
@@ -1051,6 +1079,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				resetMutatingFailureState(mutatingFailureStates[flatIndex]!);
 			}
 		} else if (event.type === "message_end" && event.message?.role === "assistant") {
+			appendRecentStepOutput(step, extractTextFromContent(event.message.content).split("\n").slice(-10));
 			step.turnCount = (step.turnCount ?? 0) + 1;
 			const usage = event.message.usage;
 			if (usage) {
@@ -1277,6 +1306,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						statusPayload.steps[fi].status = "running";
 						statusPayload.steps[fi].error = undefined;
 						statusPayload.steps[fi].activityState = undefined;
+						resetStepLiveDetail(statusPayload.steps[fi]);
 						statusPayload.steps[fi].startedAt = taskStartTime;
 						statusPayload.steps[fi].endedAt = undefined;
 						statusPayload.steps[fi].durationMs = undefined;
@@ -1420,6 +1450,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			statusPayload.steps[flatIndex].status = "running";
 			statusPayload.steps[flatIndex].activityState = undefined;
 			statusPayload.activityState = undefined;
+			resetStepLiveDetail(statusPayload.steps[flatIndex]);
 			statusPayload.steps[flatIndex].skills = seqStep.skills;
 			statusPayload.steps[flatIndex].startedAt = stepStartTime;
 			statusPayload.steps[flatIndex].lastActivityAt = stepStartTime;

package/src/runs/foreground/chain-clarify.ts

@@ -9,9 +9,8 @@ import type { Theme } from "@mariozechner/pi-coding-agent";
 import type { Component, TUI } from "@mariozechner/pi-tui";
 import { matchesKey, visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import type { AgentConfig, ChainConfig, ChainStepConfig } from "../../agents/agents.ts";
+import { getUserChainDir, type AgentConfig, type ChainConfig, type ChainStepConfig } from "../../agents/agents.ts";
 import type { ResolvedStepBehavior } from "../../shared/settings.ts";
 import type { TextEditorState } from "../../tui/text-editor.ts";
 import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "../../tui/text-editor.ts";
@@ -317,7 +316,7 @@ export class ChainClarifyComponent implements Component {
 				return;
 			}
 			try {
-				const dir = path.join(os.homedir(), ".pi", "agent", "agents");
+				const dir = getUserChainDir();
 				fs.mkdirSync(dir, { recursive: true });
 				const filePath = path.join(dir, `${name}.chain.md`);
 				const config = this.buildChainConfig(name);

package/src/runs/foreground/execution.ts

@@ -811,15 +811,16 @@ export async function runSync(
 		sumUsage(aggregateUsage, result.usage);
 		totalToolCount += result.progressSummary?.toolCount ?? 0;
 		totalDurationMs += result.progressSummary?.durationMs ?? 0;
+		const attemptSucceeded = result.exitCode === 0 && !result.error;
 		const attempt: ModelAttempt = {
 			model: candidate ?? result.model ?? agent.model ?? "default",
-			success: result.exitCode === 0,
+			success: attemptSucceeded,
 			exitCode: result.exitCode,
 			error: result.error,
 			usage: { ...result.usage },
 		};
 		modelAttempts.push(attempt);
-		if (result.exitCode === 0) {
+		if (attemptSucceeded) {
 			break;
 		}
 		if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {

package/src/runs/foreground/subagent-executor.ts

@@ -28,7 +28,7 @@ import {
 	type StepOverrides,
 } from "../../shared/settings.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
-import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "../background/async-execution.ts";
+import { executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable } from "../background/async-execution.ts";
 import { createForkContextResolver } from "../../shared/fork-context.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
@@ -344,6 +344,7 @@ async function resumeAsyncRun(input: {
 		config: input.deps.config.intercomBridge,
 		context: input.params.context,
 		orchestratorTarget: sessionName,
+		cwd: effectiveCwd,
 	});
 	const agents = intercomBridge.active
 		? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))
@@ -396,9 +397,9 @@ async function resumeAsyncRun(input: {
 		`Session: ${target.sessionFile}`,
 		result.details.asyncDir ? `Async dir: ${result.details.asyncDir}` : undefined,
 		revivedTarget ? `Intercom target: ${revivedTarget} (if registered)` : undefined,
-		`Follow: subagent({ action: "status", id: "${revivedId}" })`,
+		`Status if needed: subagent({ action: "status", id: "${revivedId}" })`,
 	].filter((line): line is string => Boolean(line));
-	return { content: [{ type: "text", text: lines.join("\n") }], details: result.details };
+	return { content: [{ type: "text", text: formatAsyncStartedMessage(lines.join("\n")) }], details: result.details };
 }
 
 function resultSummaryForIntercom(result: SingleResult): string {
@@ -1962,6 +1963,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 			config: deps.config.intercomBridge,
 			context: effectiveParams.context,
 			orchestratorTarget: sessionName,
+			cwd: effectiveCwd,
 		});
 		const agents = intercomBridge.active
 			? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))

package/src/shared/types.ts

@@ -299,8 +299,11 @@ export interface AsyncStatus {
 		activityState?: ActivityState;
 		lastActivityAt?: number;
 		currentTool?: string;
+		currentToolArgs?: string;
 		currentToolStartedAt?: number;
 		currentPath?: string;
+		recentTools?: Array<{ tool: string; args: string; endMs: number }>;
+		recentOutput?: string[];
 		turnCount?: number;
 		toolCount?: number;
 		startedAt?: number;
@@ -320,6 +323,10 @@ export interface AsyncStatus {
 	sessionFile?: string;
 }
 
+export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
+	index?: number;
+};
+
 export interface AsyncJobState {
 	asyncId: string;
 	asyncDir: string;
@@ -338,7 +345,7 @@ export interface AsyncJobState {
 	currentStep?: number;
 	chainStepCount?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
-	steps?: AsyncStatus["steps"];
+	steps?: AsyncJobStep[];
 	stepsTotal?: number;
 	runningSteps?: number;
 	completedSteps?: number;

package/src/tui/render.ts

@@ -2,6 +2,7 @@
  * Rendering functions for subagent results
  */
 
+import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { getMarkdownTheme, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { Container, Markdown, Spacer, Text, visibleWidth, type Component } from "@mariozechner/pi-tui";
@@ -14,6 +15,7 @@ import {
 } from "../shared/types.ts";
 import { formatTokens, formatUsage, formatDuration, formatToolCall, shortenPath } from "../shared/formatters.ts";
 import { getDisplayItems, getLastActivity, getSingleResultOutput } from "../shared/utils.ts";
+import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.ts";
 
 type Theme = ExtensionContext["ui"]["theme"];
 
@@ -264,10 +266,10 @@ function formatWidgetAgents(agents: string[]): string {
 }
 
 function widgetJobName(job: AsyncJobState): string {
-	const agents = job.agents?.length ? formatWidgetAgents(job.agents) : undefined;
-	if (job.mode === "parallel") return agents ? `parallel · ${agents}` : "parallel";
-	if (job.activeParallelGroup) return agents ? `parallel group · ${agents}` : "parallel group";
-	if (job.agents?.length) return job.agents.join(" → ");
+	if (job.mode === "parallel") return "parallel";
+	if (job.mode === "chain") return "chain";
+	if (job.mode === "single" && job.agents?.length === 1) return job.agents[0]!;
+	if (job.agents?.length) return formatWidgetAgents(job.agents);
 	return job.mode ?? "subagent";
 }
 
@@ -293,6 +295,7 @@ function widgetActivity(job: AsyncJobState): string {
 	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
 	if (activity) return activity;
 	if (facts.length) return facts.join(" · ");
+	if (job.status === "running") return "thinking…";
 	if (job.status === "queued") return "queued…";
 	if (job.status === "paused") return "Paused";
 	if (job.status === "failed") return "Failed";
@@ -308,7 +311,7 @@ function widgetStatusGlyph(job: AsyncJobState, theme: Theme): string {
 }
 
 function widgetStepGlyph(status: string, theme: Theme): string {
-	if (status === "running") return theme.fg("accent", "▶");
+	if (status === "running") return theme.fg("accent", spinnerFrame());
 	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
 	if (status === "failed") return theme.fg("error", "✗");
 	if (status === "paused") return theme.fg("warning", "■");
@@ -337,14 +340,62 @@ function widgetStepActivity(step: NonNullable<AsyncJobState["steps"]>[number]):
 	return facts.join(" · ");
 }
 
+function widgetAggregateStepStatus(steps: NonNullable<AsyncJobState["steps"]>): string {
+	if (steps.some((step) => step.status === "running")) return "running";
+	if (steps.some((step) => step.status === "failed")) return "failed";
+	if (steps.some((step) => step.status === "paused")) return "paused";
+	if (steps.length > 0 && steps.every((step) => step.status === "complete" || step.status === "completed")) return "complete";
+	return "pending";
+}
+
+function widgetParallelOutcome(steps: NonNullable<AsyncJobState["steps"]>, total: number): string {
+	const running = steps.filter((step) => step.status === "running").length;
+	const done = steps.filter((step) => step.status === "complete" || step.status === "completed").length;
+	const failed = steps.filter((step) => step.status === "failed").length;
+	const paused = steps.filter((step) => step.status === "paused").length;
+	const parts = [`${done}/${total} done`];
+	if (running > 0) parts.unshift(formatAgentRunningLabel(running));
+	if (failed > 0) parts.push(`${failed} failed`);
+	if (paused > 0) parts.push(`${paused} paused`);
+	return parts.join(" · ");
+}
+
+function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth()): string[] {
+	if (!job.steps?.length) return [];
+	const total = job.chainStepCount ?? job.steps.length;
+	const groups = job.parallelGroups ?? [];
+	const lines: string[] = [];
+	let flatIndex = 0;
+	for (let stepIndex = 0; stepIndex < total; stepIndex++) {
+		const group = groups.find((candidate) => candidate.stepIndex === stepIndex);
+		if (group) {
+			const steps = job.steps.slice(group.start, group.start + group.count);
+			const status = widgetAggregateStepStatus(steps);
+			lines.push(`  ${widgetStepGlyph(status, theme)} Step ${stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", widgetParallelOutcome(steps, group.count))}`);
+			flatIndex = Math.max(flatIndex, group.start + group.count);
+			continue;
+		}
+		const step = job.steps[flatIndex];
+		if (!step) {
+			lines.push(`  ${theme.fg("dim", `◦ Step ${stepIndex + 1}/${total}: pending`)}`);
+			continue;
+		}
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", stepIndex + 1, total, expanded, width));
+		flatIndex++;
+	}
+	return lines;
+}
+
 function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme): string[] {
-	if (!job.activeParallelGroup || !job.steps?.length) return [];
+	if (!job.steps?.length) return [];
 	if (job.mode !== "parallel" && job.mode !== "chain") return [];
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme);
 	const total = job.stepsTotal ?? job.steps.length;
 	return job.steps.map((step, index) => {
 		const marker = index === job.steps!.length - 1 ? "└" : "├";
 		const activity = widgetStepActivity(step);
-		return `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme)} Agent ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${activity ? ` · ${activity}` : ""}`)}`;
+		const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+		return `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${activity ? ` · ${activity}` : ""}`)}`;
 	});
 }
 
@@ -513,7 +564,7 @@ function widgetStats(job: AsyncJobState, theme: Theme): string {
 		const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
 		const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
 		if (job.mode === "parallel") {
-			if (job.status === "running") parts.push(formatAgentRunningLabel(running));
+			if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
 			if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
 		} else {
 			const activeGroup = job.currentStep !== undefined
@@ -521,24 +572,157 @@ function widgetStats(job: AsyncJobState, theme: Theme): string {
 				: job.parallelGroups?.find((group) => group.start === 0);
 			const logicalStep = activeGroup?.stepIndex ?? job.currentStep ?? 0;
 			const total = job.chainStepCount ?? stepsTotal;
-			const groupProgress = job.status === "running"
-				? `${formatAgentRunningLabel(running)} · ${done}/${stepsTotal} done`
-				: `${done}/${stepsTotal} done`;
-			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupProgress}`);
+			const groupParts = [`${done}/${stepsTotal} done`];
+			if (job.status === "running" && running > 0) groupParts.unshift(formatAgentRunningLabel(running));
+			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
 		}
 	} else if (job.currentStep !== undefined) {
-		parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
+		if (job.mode === "chain" && job.parallelGroups?.length) {
+			const total = job.chainStepCount ?? stepsTotal;
+			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
+		} else {
+			parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
+		}
 	} else if (stepsTotal > 1) {
 		parts.push(`steps ${stepsTotal}`);
 	}
+	if (job.toolCount !== undefined) parts.push(formatToolUseStat(job.toolCount));
 	if (job.totalTokens?.total) parts.push(formatTokenStat(job.totalTokens.total));
 	const endTime = job.status === "complete" || job.status === "failed" || job.status === "paused" ? (job.updatedAt ?? Date.now()) : Date.now();
 	if (job.startedAt) parts.push(formatDuration(Math.max(0, endTime - job.startedAt)));
 	return statJoin(theme, parts);
 }
 
-export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth()): string[] {
+function widgetStepStats(theme: Theme, step: NonNullable<AsyncJobState["steps"]>[number]): string {
+	return statJoin(theme, [
+		step.turnCount !== undefined ? `${step.turnCount} turns` : "",
+		step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
+		step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
+		step.durationMs !== undefined ? formatDuration(step.durationMs) : "",
+	]);
+}
+
+function widgetStepActivityLine(step: NonNullable<AsyncJobState["steps"]>[number], width: number, expanded: boolean): string {
+	const toolLine = formatCurrentToolLine(step, width, expanded);
+	if (toolLine) return toolLine;
+	const activity = formatActivityLabel(step.lastActivityAt, step.activityState);
+	if (activity) return activity;
+	if (step.status === "running") return "thinking…";
+	return "";
+}
+
+function widgetOutputPath(job: AsyncJobState, step: NonNullable<AsyncJobState["steps"]>[number]): string | undefined {
+	if (typeof step.index !== "number") return undefined;
+	return path.join(job.asyncDir, `output-${step.index}.log`);
+}
+
+function foregroundStyleWidgetStepLines(
+	job: AsyncJobState,
+	theme: Theme,
+	step: NonNullable<AsyncJobState["steps"]>[number],
+	itemTitle: "Agent" | "Step",
+	index: number,
+	total: number,
+	expanded: boolean,
+	width: number,
+): string[] {
+	const stats = widgetStepStats(theme, step);
+	const lines = [`  ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+	const activity = widgetStepActivityLine(step, width, expanded);
+	if (activity) lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
+	if (step.status === "running") {
+		if (!expanded) lines.push(`    ${theme.fg("accent", "Press Ctrl+O for live detail")}`);
+		const output = widgetOutputPath(job, step);
+		if (output) lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+		if (expanded) {
+			const liveStatus = buildLiveStatusLine(step);
+			if (liveStatus && liveStatus !== activity) lines.push(`    ${theme.fg("accent", liveStatus)}`);
+			for (const tool of step.recentTools?.slice(-3) ?? []) {
+				const maxArgsLen = Math.max(40, width - 30);
+				const argsPreview = tool.args.length <= maxArgsLen ? tool.args : `${tool.args.slice(0, maxArgsLen)}...`;
+				lines.push(`      ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
+			}
+			for (const line of step.recentOutput?.slice(-5) ?? []) {
+				lines.push(`      ${theme.fg("dim", line)}`);
+			}
+		}
+	}
+	return lines;
+}
+
+function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded: boolean, width: number): string[] {
+	if (!job.steps?.length) return [`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`];
+	if (job.mode !== "parallel" && job.mode !== "chain") return [`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`];
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width);
+	const total = job.stepsTotal ?? job.steps.length;
+	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+	const lines: string[] = [];
+	for (const [index, step] of job.steps.entries()) {
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width));
+	}
+	return lines;
+}
+
+function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, expanded: boolean): string[] {
+	const stats = widgetStats(job, theme);
+	const count = job.mode === "chain" ? job.chainStepCount : job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
+	const mode = widgetJobName(job);
+	const title = `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
+	return [
+		`${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background · /subagents-status")}`,
+		`${widgetStatusGlyph(job, theme)} ${themeBold(theme, mode)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+		...foregroundStyleWidgetDetails(job, theme, expanded, width),
+	].map((line) => truncLine(line, width));
+}
+
+function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number): string[] {
+	const fullLines = buildSingleWidgetLines(job, theme, width, false);
+	if (fullLines.length <= 10 || !job.steps?.length || (job.mode !== "parallel" && !job.activeParallelGroup)) return fullLines;
+
+	const total = job.stepsTotal ?? job.steps.length;
+	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+	const lines = fullLines.slice(0, 2);
+	for (const [index, step] of job.steps.entries()) {
+		const stepStats = widgetStepStats(theme, step);
+		const activity = widgetStepActivityLine(step, width, false);
+		const activitySuffix = activity ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : "";
+		lines.push(`  ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, step.agent)}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${activitySuffix}`);
+	}
+	if (job.steps.some((step) => step.status === "running")) lines.push(theme.fg("accent", "  Press Ctrl+O for live detail · /subagents-status for output paths"));
+	return lines.map((line) => truncLine(line, width));
+}
+
+function fitWidgetLineBudget(lines: string[], theme: Theme, width: number, expanded: boolean): string[] {
+	const rows = process.stdout.rows || 30;
+	const budget = expanded
+		? Math.max(12, Math.min(24, Math.floor(rows * 0.55)))
+		: Math.max(10, Math.min(14, Math.floor(rows * 0.35)));
+	if (lines.length <= budget) return lines;
+	const visibleLines = Math.max(1, budget - 1);
+	const hiddenCount = lines.length - visibleLines;
+	const hint = expanded
+		? `… ${hiddenCount} live-detail lines hidden · /subagents-status for full detail`
+		: `… ${hiddenCount} lines hidden · Ctrl+O expands · /subagents-status for full detail`;
+	return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
+}
+
+function buildWidgetComponent(jobs: AsyncJobState[], expanded: boolean): (_tui: unknown, theme: Theme) => Component {
+	return (_tui, theme) => {
+		const width = getTermWidth();
+		const lines = expanded
+			? buildWidgetLines(jobs, theme, width, true)
+			: jobs.length === 1
+				? compactSingleWidgetLines(jobs[0]!, theme, width)
+				: buildWidgetLines(jobs, theme, width, false);
+		const container = new Container();
+		for (const line of fitWidgetLineBudget(lines, theme, width, expanded)) container.addChild(new Text(line, 1, 0));
+		return container;
+	};
+}
+
+export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false): string[] {
 	if (jobs.length === 0) return [];
+	if (jobs.length === 1) return buildSingleWidgetLines(jobs[0]!, theme, width, expanded);
 	const running = jobs.filter((job) => job.status === "running");
 	const queued = jobs.filter((job) => job.status === "queued");
 	const finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued");
@@ -608,7 +792,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 function refreshAnimatedWidget(): void {
 	try {
 		if (!latestWidgetCtx?.hasUI || latestWidgetJobs.length === 0) return;
-		latestWidgetCtx.ui.setWidget(WIDGET_KEY, buildWidgetLines(latestWidgetJobs, latestWidgetCtx.ui.theme));
+		latestWidgetCtx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(latestWidgetJobs, latestWidgetCtx.ui.getToolsExpanded?.() ?? false));
 		latestWidgetCtx.ui.requestRender?.();
 	} catch (error) {
 		if (!isStaleExtensionContextError(error)) throw error;
@@ -662,7 +846,7 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 	latestWidgetCtx = ctx;
 	latestWidgetJobs = [...jobs];
 
-	ctx.ui.setWidget(WIDGET_KEY, buildWidgetLines(jobs, ctx.ui.theme));
+	ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? false));
 	if (hasAnimatedWidgetJobs(jobs)) ensureWidgetAnimation();
 	else stopWidgetAnimation();
 }

package/src/tui/subagents-status.ts

@@ -62,11 +62,20 @@ function stepGlyph(theme: Theme, status: string): string {
 	return theme.fg("dim", "◦");
 }
 
+function runGlyph(theme: Theme, status: AsyncRunSummary["state"]): string {
+	if (status === "running") return theme.fg("accent", "▶");
+	if (status === "queued") return theme.fg("dim", "◦");
+	if (status === "complete") return theme.fg("success", "✓");
+	if (status === "paused") return theme.fg("warning", "■");
+	return theme.fg("error", "✗");
+}
+
 function runLabel(theme: Theme, run: AsyncRunSummary, selected: boolean): string {
 	const prefix = selected ? theme.fg("accent", ">") : " ";
 	const stepLabel = formatAsyncRunProgressLabel(run);
 	const cwd = shortenPath(run.cwd ?? run.asyncDir);
-	return `${prefix} ${run.id.slice(0, 8)} ${statusColor(theme, run.state)} | ${run.mode} | ${stepLabel} | ${cwd}`;
+	const mode = ((theme as { bold?: (value: string) => string }).bold?.(run.mode)) ?? run.mode;
+	return `${prefix} ${runGlyph(theme, run.state)} ${mode} · ${stepLabel} · ${run.id.slice(0, 8)} · ${cwd}`;
 }
 
 function selectedIndex(rows: StatusRow[], cursor: number): number {
@@ -332,7 +341,13 @@ export class SubagentsStatusComponent implements Component {
 		if (run.sessionFile) {
 			lines.push(row(`session: ${truncateToWidth(shortenPath(run.sessionFile), innerW - 9)}`, width, this.theme));
 		}
-		lines.push(...this.renderStepRows(run, width, innerW));
+		if (run.mode === "chain" && (run.chainStepCount !== undefined || run.parallelGroups?.length)) {
+			lines.push(...this.renderChainProgressRows(run, width, innerW));
+		} else if (run.mode === "parallel") {
+			lines.push(...this.renderAgentRows(run, width, innerW));
+		} else {
+			lines.push(...this.renderStepRows(run, width, innerW));
+		}
 		return lines;
 	}
 
@@ -438,7 +453,7 @@ export class SubagentsStatusComponent implements Component {
 			: undefined;
 
 		const body: string[] = [];
-		body.push(...detailRows(`${run.id} | ${statusColor(this.theme, run.state)} | ${run.mode} | ${stepLabel} | ${duration}`, width, innerW, this.theme));
+		body.push(...detailRows(`${runGlyph(this.theme, run.state)} ${run.mode} · ${stepLabel} · ${statusColor(this.theme, run.state)} · ${duration}`, width, innerW, this.theme));
 		if (activity) body.push(...detailRows(activity, width, innerW, this.theme));
 		body.push(row("", width, this.theme));
 		if (run.mode === "chain" && (run.chainStepCount !== undefined || run.parallelGroups?.length)) {