pi-subagents 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [0.17.1] - 2026-04-20
+
+### Added
+- Foreground subagent runs now make deeper live detail easier to discover. Running cards show an explicit `Ctrl+O` hint, lightweight live-state signals like recent activity, current-tool durations, and artifact output paths when available. Common array-heavy tool previews such as `web_search.queries` and `fetch_content.urls` are now summarized more clearly instead of collapsing into opaque fallback text.
+
+### Changed
+- Forked delegated runs now use stronger prompt-side guidance for `pi-intercom` coordination instead of runtime policing. The default fork preamble and intercom bridge instructions now explicitly treat inherited fork history as reference-only context, tell children not to continue the parent conversation in normal assistant text, and steer upstream questions or handoffs through `intercom` when needed.
+- Documented an opt-in custom agent pattern for forked chat-back workflows so users can make that coordination contract explicit without changing builtin agents.
+- Slash-run status text and `/subagents-status` summary output now use the same more explicit observability language, including clearer live-detail hints and surfaced output/session paths in the async status overlay.
+- Builtin agent defaults now prefer `openai-codex` models for `planner`, `scout`, `researcher`, `context-builder`, and `worker`.
+
+### Fixed
+- Removed the short-lived foreground intercom enforcement/retry layer from delegated fork runs. Coordination behavior is now shaped by prompt and agent design only, avoiding hidden retries, heuristic output inspection, and failure paths based on guessed intent.
+
 ## [0.17.0] - 2026-04-16
 
 ### Added

package/README.md

@@ -925,12 +925,14 @@ Example `instructionFile`:
 ```md
 Intercom orchestration channel:
 
+The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the orchestrator in normal assistant text.
+
 Use `intercom` only to coordinate with the orchestrator session `{orchestratorTarget}`.
 
 - Need a decision or you're blocked: `intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })`
-- Need to report progress or completion: `intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })`
+- Need to report progress or a completion handoff: `intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })`
 
-If intercom is unavailable in this run, continue the task normally.
+If no upstream coordination is needed, continue the task normally and return a focused task result.
 ```
 
 Bridge activation also requires all of the following:
@@ -941,6 +943,33 @@ Bridge activation also requires all of the following:
 
 When an unnamed session falls back to `subagent-chat-<id>`, that alias is used only for the live intercom broker. It is not persisted as the Pi session title, so `pi --resume` can still show the transcript snippet.
 
+If you want a stronger prompt contract for forked chat-back runs without changing builtins, define a custom agent for it. Keeping that as an opt-in agent works better than teaching every delegated run to behave this way.
+
+Example agent:
+
+```md
+---
+name: fork-chatback
+description: Forked worker that asks the orchestrator questions through intercom when needed
+tools: read, bash, edit, write, intercom
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+You are a delegated worker running from a fork of the orchestrator session.
+
+Treat the inherited conversation as reference-only context. Do not continue that conversation in normal assistant text.
+
+Your job is to do the task. If you need a decision, clarification, or unblock from the orchestrator, use `intercom` to ask the orchestrator session named in the runtime bridge instructions.
+
+If you need to send a progress update or completion handoff upstream, use `intercom` to send it to that same orchestrator session.
+
+If no upstream coordination is needed, just complete the work and return a focused task result.
+```
+
+Pair that with task wording that makes the contract explicit, like "Work from the forked context below. If you need anything from me, ask through `intercom`. Otherwise complete the task and return the result."
+
 ### `worktreeSetupHook`
 
 `worktreeSetupHook` configures an optional setup hook for worktree-isolated parallel runs. The hook runs once per created worktree, after `git worktree add` succeeds and before the agent starts.
@@ -1005,7 +1034,7 @@ When fallback is used, metadata records both the ordered `attemptedModels` list
 
 Session files (JSONL) are stored under a per-run session directory. Directory selection follows the same precedence as session root resolution: explicit `sessionDir` > `config.defaultSessionDir` > parent-session-derived path. The session file path is shown in output.
 
-When `context: "fork"` is used, each child run starts with `--session <branched-session-file>` produced from the parent's current leaf. This is a real session fork, not injected summary text.
+When `context: "fork"` is used, each child run starts with `--session <branched-session-file>` produced from the parent's current leaf. This is a real session fork, not injected summary text. The fork preamble explicitly tells the child to treat the inherited conversation as reference-only context rather than a live thread to continue.
 
 ## Session Sharing
 
@@ -1041,6 +1070,8 @@ During sync execution, the collapsed view shows real-time progress for single, c
 - Per-task step cards showing status icon, agent name, model, tool count, and duration
 - Current tool and recent output for each running task
 
+While a foreground run is active, the compact view also hints when richer detail is available and shows lightweight live-state signals like activity freshness and current-tool duration.
+
 Press **Ctrl+O** to expand the full streaming view with complete output per step.
 
 > **Note:** Chain visualization (the `done scout → running planner` line) is only shown for sequential chains. Chains with parallel steps show per-step cards instead.
@@ -1095,7 +1126,7 @@ subagent_status({ id: "<id>" })
 subagent_status({ dir: "<tmpdir>/pi-subagents-<scope>/async-subagent-runs/<id>" })
 ```
 
-For an interactive overview, run the `/subagents-status` slash command to open the overlay listing active runs and recent completed/failed runs. The overlay auto-refreshes every 2 seconds while it is open.
+For an interactive overview, run the `/subagents-status` slash command to open the overlay listing active runs and recent completed/failed runs. The overlay auto-refreshes every 2 seconds while it is open and focuses on summary/status information, including the current output/session paths when available.
 
 ## Events
 

package/agents/context-builder.md

@@ -2,7 +2,7 @@
 name: context-builder
 description: Analyzes requirements and codebase, generates context and meta-prompt
 tools: read, grep, find, ls, bash, write, web_search
-model: claude-sonnet-4-6
+model: openai-codex/gpt-5.4
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/agents/planner.md

@@ -2,7 +2,7 @@
 name: planner
 description: Creates implementation plans from context and requirements
 tools: read, grep, find, ls, write
-model: claude-opus-4-6
+model: openai-codex/gpt-5.4
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/researcher.md

@@ -2,7 +2,7 @@
 name: researcher
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
 tools: read, write, web_search, fetch_content, get_search_content
-model: anthropic/claude-sonnet-4-6
+model: openai-codex/gpt-5.4
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/agents/scout.md

@@ -2,7 +2,7 @@
 name: scout
 description: Fast codebase recon that returns compressed context for handoff
 tools: read, grep, find, ls, bash, write
-model: anthropic/claude-haiku-4-5
+model: openai-codex/gpt-5.4-mini
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/agents/worker.md

@@ -1,7 +1,7 @@
 ---
 name: worker
 description: General-purpose subagent with full capabilities
-model: claude-sonnet-4-6
+model: openai-codex/gpt-5.4
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/execution.ts

@@ -63,6 +63,35 @@ function appendRecentOutput(progress: AgentProgress, lines: string[]): void {
 	}
 }
 
+function snapshotProgress(progress: AgentProgress): AgentProgress {
+	return {
+		...progress,
+		skills: progress.skills ? [...progress.skills] : undefined,
+		recentTools: progress.recentTools.map((tool) => ({ ...tool })),
+		recentOutput: [...progress.recentOutput],
+	};
+}
+
+function snapshotResult(result: SingleResult, progress: AgentProgress): SingleResult {
+	return {
+		...result,
+		messages: result.messages ? [...result.messages] : undefined,
+		usage: { ...result.usage },
+		skills: result.skills ? [...result.skills] : undefined,
+		attemptedModels: result.attemptedModels ? [...result.attemptedModels] : undefined,
+		modelAttempts: result.modelAttempts
+			? result.modelAttempts.map((attempt) => ({
+				...attempt,
+				usage: attempt.usage ? { ...attempt.usage } : undefined,
+			}))
+			: undefined,
+		progress,
+		progressSummary: result.progressSummary ? { ...result.progressSummary } : undefined,
+		artifactPaths: result.artifactPaths ? { ...result.artifactPaths } : undefined,
+		truncation: result.truncation ? { ...result.truncation } : undefined,
+	};
+}
+
 async function runSingleAttempt(
 	runtimeCwd: string,
 	agent: AgentConfig,
@@ -75,6 +104,7 @@ async function runSingleAttempt(
 		resolvedSkillNames?: string[];
 		skillsWarning?: string;
 		jsonlPath?: string;
+		artifactPaths?: ArtifactPaths;
 		attemptNotes: string[];
 		outputSnapshot?: SingleOutputSnapshot;
 	},
@@ -105,6 +135,7 @@ async function runSingleAttempt(
 		messages: [],
 		usage: emptyUsage(),
 		model: modelArg,
+		artifactPaths: shared.artifactPaths,
 		skills: shared.resolvedSkillNames,
 		skillsWarning: shared.skillsWarning,
 	};
@@ -120,6 +151,7 @@ async function runSingleAttempt(
 		toolCount: 0,
 		tokens: 0,
 		durationMs: 0,
+		lastActivityAt: Date.now(),
 	};
 	result.progress = progress;
 
@@ -175,15 +207,22 @@ async function runSingleAttempt(
 			resolve(code);
 		};
 
-		const fireUpdate = () => {
+		const emitUpdateSnapshot = (text: string) => {
 			if (!options.onUpdate || processClosed) return;
-			progress.durationMs = Date.now() - startTime;
+			const progressSnapshot = snapshotProgress(progress);
+			const resultSnapshot = snapshotResult(result, progressSnapshot);
 			options.onUpdate({
-				content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-				details: { mode: "single", results: [result], progress: [progress] },
+				content: [{ type: "text", text }],
+				details: { mode: "single", results: [resultSnapshot], progress: [progressSnapshot] },
 			});
 		};
 
+		const fireUpdate = () => {
+			if (!options.onUpdate || processClosed) return;
+			progress.durationMs = Date.now() - startTime;
+			emitUpdateSnapshot(getFinalOutput(result.messages) || "(running...)");
+		};
+
 		const processLine = (line: string) => {
 			if (!line.trim()) return;
 			jsonlWriter.writeLine(line);
@@ -197,6 +236,7 @@ async function runSingleAttempt(
 
 			const now = Date.now();
 			progress.durationMs = now - startTime;
+			progress.lastActivityAt = now;
 
 			if (evt.type === "tool_execution_start") {
 				if (options.allowIntercomDetach && evt.toolName === "intercom") {
@@ -205,6 +245,7 @@ async function runSingleAttempt(
 				progress.toolCount++;
 				progress.currentTool = evt.toolName;
 				progress.currentToolArgs = extractToolArgsPreview((evt.args || {}) as Record<string, unknown>);
+				progress.currentToolStartedAt = now;
 				fireUpdate();
 			}
 
@@ -218,6 +259,7 @@ async function runSingleAttempt(
 				}
 				progress.currentTool = undefined;
 				progress.currentToolArgs = undefined;
+				progress.currentToolStartedAt = undefined;
 				fireUpdate();
 			}
 
@@ -343,6 +385,15 @@ async function runSingleAttempt(
 		result.outputSaveError = resolvedOutput.saveError;
 	}
 	result.finalOutput = fullOutput;
+	if (options.onUpdate) {
+		const finalText = result.finalOutput || result.error || "(no output)";
+		const progressSnapshot = snapshotProgress(progress);
+		const resultSnapshot = snapshotResult(result, progressSnapshot);
+		options.onUpdate({
+			content: [{ type: "text", text: finalText }],
+			details: { mode: "single", results: [resultSnapshot], progress: [progressSnapshot] },
+		});
+	}
 	return result;
 }
 
@@ -417,6 +468,7 @@ export async function runSync(
 			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
 			skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
 			jsonlPath,
+			artifactPaths: artifactPathsResult,
 			attemptNotes,
 			outputSnapshot,
 		});

package/intercom-bridge.ts

@@ -9,10 +9,13 @@ const DEFAULT_INTERCOM_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "in
 const DEFAULT_SUBAGENT_CONFIG_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "subagent");
 const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
 const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
-const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `Use intercom only for coordination with the orchestrator session:
+const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the orchestrator in normal assistant text.
+
+Use intercom only for coordination with the orchestrator session "{orchestratorTarget}".
 - Need a decision or blocked: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
-- Completion/update: intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })
-If intercom is unavailable in this run, continue the task normally.`;
+- Need to report progress or a completion handoff: intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })
+
+If no upstream coordination is needed, continue the task normally and return a focused task result.`;
 
 export interface IntercomBridgeState {
 	active: boolean;

package/package.json

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

package/render.ts

@@ -6,6 +6,7 @@ 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";
 import {
+	type AgentProgress,
 	type AsyncJobState,
 	type Details,
 	MAX_WIDGET_JOBS,
@@ -113,6 +114,34 @@ function getToolCallLines(
 	return result.toolCalls?.map((toolCall) => expanded ? toolCall.expandedText : toolCall.text) ?? [];
 }
 
+function formatActivityLabel(lastActivityAt: number | undefined, now = Date.now()): string | undefined {
+	if (lastActivityAt === undefined) return undefined;
+	const ago = Math.max(0, now - lastActivityAt);
+	if (ago < 1000) return "active now";
+	if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
+	return `active ${Math.floor(ago / 60000)}m ago`;
+}
+
+function formatCurrentToolLine(progress: Pick<AgentProgress, "currentTool" | "currentToolArgs" | "currentToolStartedAt">, availableWidth: number, expanded: boolean): string | undefined {
+	if (!progress.currentTool) return undefined;
+	const maxToolArgsLen = Math.max(50, availableWidth - 20);
+	const toolArgsPreview = progress.currentToolArgs
+		? (expanded || progress.currentToolArgs.length <= maxToolArgsLen
+			? progress.currentToolArgs
+			: `${progress.currentToolArgs.slice(0, maxToolArgsLen)}...`)
+		: "";
+	const durationSuffix = progress.currentToolStartedAt !== undefined
+		? ` | ${formatDuration(Math.max(0, Date.now() - progress.currentToolStartedAt))}`
+		: "";
+	return toolArgsPreview
+		? `${progress.currentTool}: ${toolArgsPreview}${durationSuffix}`
+		: `${progress.currentTool}${durationSuffix}`;
+}
+
+function buildLiveStatusLine(progress: Pick<AgentProgress, "lastActivityAt">): string | undefined {
+	return formatActivityLabel(progress.lastActivityAt);
+}
+
 /**
  * Render the async jobs widget
  */
@@ -226,18 +255,18 @@ export function renderSubagentResult(
 		c.addChild(new Spacer(1));
 
 		if (isRunning && r.progress) {
-			if (r.progress.currentTool) {
-				const maxToolArgsLen = Math.max(50, w - 20);
-				const toolArgsPreview = 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;
+			const toolLine = formatCurrentToolLine(r.progress, w, expanded);
+			if (toolLine) {
 				c.addChild(new Text(fit(theme.fg("warning", `> ${toolLine}`)), 0, 0));
 			}
+			const liveStatusLine = buildLiveStatusLine(r.progress);
+			if (liveStatusLine) {
+				c.addChild(new Text(fit(theme.fg("accent", liveStatusLine)), 0, 0));
+			}
+			c.addChild(new Text(fit(theme.fg("accent", "Press Ctrl+O for live detail")), 0, 0));
+			if (r.artifactPaths) {
+				c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+			}
 			if (r.progress.recentTools?.length) {
 				for (const t of r.progress.recentTools.slice(-3)) {
 					const maxArgsLen = Math.max(40, w - 24);
@@ -250,7 +279,7 @@ export function renderSubagentResult(
 			for (const line of (r.progress.recentOutput ?? []).slice(-5)) {
 				c.addChild(new Text(fit(theme.fg("dim", `  ${line}`)), 0, 0));
 			}
-			if (r.progress.currentTool || r.progress.recentTools?.length || r.progress.recentOutput?.length) {
+			if (toolLine || liveStatusLine || r.progress.recentTools?.length || r.progress.recentOutput?.length || r.artifactPaths) {
 				c.addChild(new Spacer(1));
 			}
 		}
@@ -278,7 +307,7 @@ export function renderSubagentResult(
 			c.addChild(new Text(fit(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`)), 0, 0));
 		}
 
-		if (r.artifactPaths) {
+		if (!isRunning && r.artifactPaths) {
 			c.addChild(new Spacer(1));
 			c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
 		}
@@ -391,6 +420,7 @@ export function renderSubagentResult(
 			|| d.progress?.find((p) => p.agent === r.agent && p.status === "running");
 		const rProg = r.progress || progressFromArray || r.progressSummary;
 		const rRunning = rProg?.status === "running";
+		const stepNumber = typeof rProg?.index === "number" ? rProg.index + 1 : i + 1;
 
 		const resultOutput = getSingleResultOutput(r);
 		const statusIcon = rRunning
@@ -403,8 +433,8 @@ export function renderSubagentResult(
 		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
 		const modelDisplay = r.model ? theme.fg("dim", ` (${r.model})`) : "";
 		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}`;
+			? `${statusIcon} Step ${stepNumber}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}`
+			: `${statusIcon} Step ${stepNumber}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
 		const toolCallLines = getToolCallLines(r, expanded);
 		c.addChild(new Text(fit(stepHeader), 0, 0));
 
@@ -433,18 +463,18 @@ export function renderSubagentResult(
 			if (rProg.skills?.length) {
 				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
-					? (expanded || rProg.currentToolArgs.length <= maxToolArgsLen
-						? rProg.currentToolArgs
-						: `${rProg.currentToolArgs.slice(0, maxToolArgsLen)}...`)
-					: "";
-				const toolLine = toolArgsPreview
-					? `${rProg.currentTool}: ${toolArgsPreview}`
-					: rProg.currentTool;
+			const toolLine = formatCurrentToolLine(rProg, w, expanded);
+			if (toolLine) {
 				c.addChild(new Text(fit(theme.fg("warning", `    > ${toolLine}`)), 0, 0));
 			}
+			const liveStatusLine = buildLiveStatusLine(rProg);
+			if (liveStatusLine) {
+				c.addChild(new Text(fit(theme.fg("accent", `    ${liveStatusLine}`)), 0, 0));
+			}
+			c.addChild(new Text(fit(theme.fg("accent", "    Press Ctrl+O for live detail")), 0, 0));
+			if (r.artifactPaths) {
+				c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+			}
 			if (rProg.recentTools?.length) {
 				for (const t of rProg.recentTools.slice(-3)) {
 					const maxArgsLen = Math.max(40, w - 30);
@@ -460,6 +490,10 @@ export function renderSubagentResult(
 			}
 		}
 
+		if (!rRunning && r.artifactPaths) {
+			c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+		}
+
 		if (expanded && !rRunning) {
 			for (const line of toolCallLines) {
 				c.addChild(new Text(fit(theme.fg("muted", `      ${line}`)), 0, 0));

package/slash-commands.ts

@@ -145,7 +145,7 @@ async function requestSlashRun(
 			if (!ctx.hasUI) return;
 			const tool = update.currentTool ? ` ${update.currentTool}` : "";
 			const count = update.toolCount ?? 0;
-			ctx.ui.setStatus("subagent-slash", `${count} tools${tool}`);
+			ctx.ui.setStatus("subagent-slash", `${count} tools${tool} | Ctrl+O live detail`);
 		};
 
 		const onTerminalInput = ctx.hasUI

package/subagents-status.ts

@@ -157,6 +157,12 @@ export class SubagentsStatusComponent implements Component {
 		const lines = [
 			row(`cwd: ${truncateToWidth(shortenPath(run.cwd ?? run.asyncDir), innerW - 5)}`, width, this.theme),
 		];
+		if (run.outputFile) {
+			lines.push(row(`output: ${truncateToWidth(shortenPath(run.outputFile), innerW - 8)}`, width, this.theme));
+		}
+		if (run.sessionFile) {
+			lines.push(row(`session: ${truncateToWidth(shortenPath(run.sessionFile), innerW - 9)}`, width, this.theme));
+		}
 		for (const step of run.steps) {
 			const model = step.model ? ` | ${step.model}` : "";
 			const attempts = step.attemptedModels && step.attemptedModels.length > 1
@@ -226,7 +232,7 @@ export class SubagentsStatusComponent implements Component {
 			lines.push(row(this.theme.fg("dim", "No runs selected."), w, this.theme));
 		}
 
-		const footer = `↑↓ select  esc close  ${this.active.length} active / ${this.recent.length} recent`;
+		const footer = `↑↓ select  esc close  summary view  ${this.active.length} active / ${this.recent.length} recent`;
 		lines.push(renderFooter(truncateToWidth(footer, innerW), w, this.theme));
 		return lines;
 	}

package/types.ts

@@ -50,8 +50,10 @@ export interface AgentProgress {
 	status: "pending" | "running" | "completed" | "failed" | "detached";
 	task: string;
 	skills?: string[];
+	lastActivityAt?: number;
 	currentTool?: string;
 	currentToolArgs?: string;
+	currentToolStartedAt?: number;
 	recentTools: Array<{ tool: string; args: string; endMs: number }>;
 	recentOutput: string[];
 	toolCount: number;
@@ -384,9 +386,10 @@ export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
 
 export const DEFAULT_FORK_PREAMBLE =
-	"You are a delegated subagent with access to the parent session's context for reference. " +
-	"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.";
+	"You are a delegated subagent running from a fork of the parent session. " +
+	"Treat the inherited conversation as reference-only context, not a live thread to continue. " +
+	"Do not continue or answer prior messages as if they are waiting for a reply. " +
+	"Your sole job is to execute the task below and return a focused result for that task using your tools.";
 
 function normalizeTopLevelParallelValue(value: unknown): number | undefined {
 	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;

package/utils.ts

@@ -362,25 +362,54 @@ export function detectSubagentError(messages: Message[]): ErrorInfo {
  * Extract a preview of tool arguments for display
  */
 export function extractToolArgsPreview(args: Record<string, unknown>): string {
+	const truncatePreview = (value: string, maxLength: number): string =>
+		value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
+
+	const stringifyPreviewValue = (value: unknown): string | undefined => {
+		if (typeof value === "string" && value.trim().length > 0) return value;
+		if (typeof value === "number" || typeof value === "boolean") return String(value);
+		return undefined;
+	};
+
+	const previewArray = (value: unknown): string | undefined => {
+		if (!Array.isArray(value) || value.length === 0) return undefined;
+		const first = stringifyPreviewValue(value[0]);
+		if (!first) return undefined;
+		const suffix = value.length > 1 ? ` (+${value.length - 1} more)` : "";
+		return `${first}${suffix}`;
+	};
+
 	// Handle MCP tool calls - show server/tool info
 	if (args.tool && typeof args.tool === "string") {
 		const server = args.server && typeof args.server === "string" ? `${args.server}/` : "";
 		const toolArgs = args.args && typeof args.args === "string" ? ` ${args.args.slice(0, 40)}` : "";
 		return `${server}${args.tool}${toolArgs}`;
 	}
+
+	const queriesPreview = previewArray(args.queries);
+	if (queriesPreview) return truncatePreview(queriesPreview, 60);
+	if (typeof args.query === "string" && args.query.trim().length > 0) return truncatePreview(args.query, 60);
+	if (typeof args.workflow === "string" && args.workflow.trim().length > 0) return `workflow=${truncatePreview(args.workflow, 48)}`;
+
+	if (typeof args.url === "string" && args.url.trim().length > 0) return truncatePreview(args.url, 60);
+	const urlsPreview = previewArray(args.urls);
+	if (urlsPreview) return truncatePreview(urlsPreview, 60);
+	if (typeof args.prompt === "string" && args.prompt.trim().length > 0) return truncatePreview(args.prompt, 60);
 	
 	const previewKeys = ["command", "path", "file_path", "pattern", "query", "url", "task", "describe", "search"];
 	for (const key of previewKeys) {
 		if (args[key] && typeof args[key] === "string") {
 			const value = args[key] as string;
-			return value.length > 60 ? `${value.slice(0, 57)}...` : value;
+			return truncatePreview(value, 60);
 		}
 	}
 	
 	// Fallback: show first string value found
 	for (const [key, value] of Object.entries(args)) {
+		const arrayPreview = previewArray(value);
+		if (arrayPreview) return `${key}=${truncatePreview(arrayPreview, 50)}`;
 		if (typeof value === "string" && value.length > 0) {
-			const preview = value.length > 50 ? `${value.slice(0, 47)}...` : value;
+			const preview = truncatePreview(value, 50);
 			return `${key}=${preview}`;
 		}
 	}