@ferris1225/pi-subagents 4.1.3 → 4.1.5

package/src/recovery.ts

@@ -1,145 +1,145 @@
-/** Durable handoff for worktree integration/cleanup failures across sessions. */
-
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { stripVTControlCharacters } from "node:util";
-import type { WorktreeFinalization } from "./worktree.ts";
-
-export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
-const RECOVERY_MANIFEST_VERSION = 1;
-
-export interface RecoveryRecord {
-	runId: number;
-	createdAt: number;
-	integrated: boolean;
-	worktreePath?: string;
-	patchPath?: string;
-	error?: string;
-}
-
-interface RecoveryManifest {
-	version: number;
-	records: RecoveryRecord[];
-}
-
-export function getRecoveryManifestPath(configPath: string): string {
-	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
-}
-
-function normalizeRecord(value: unknown): RecoveryRecord | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	if (typeof raw.runId !== "number" || !Number.isInteger(raw.runId) || raw.runId < 1) return undefined;
-	if (typeof raw.createdAt !== "number" || !Number.isFinite(raw.createdAt)) return undefined;
-	return {
-		runId: raw.runId,
-		createdAt: raw.createdAt,
-		integrated: raw.integrated === true,
-		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
-		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
-		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
-	};
-}
-
-export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
-	try {
-		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(configPath), "utf8")) as {
-			records?: unknown;
-		};
-		if (!Array.isArray(parsed.records)) return [];
-		return parsed.records.flatMap((record) => {
-			const normalized = normalizeRecord(record);
-			return normalized ? [normalized] : [];
-		});
-	} catch {
-		return [];
-	}
-}
-
-function recoveryKey(record: RecoveryRecord): string {
-	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
-}
-
-async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
-	if (records.length === 0) {
-		await rm(path, { force: true });
-		return;
-	}
-	await mkdir(dirname(path), { recursive: true });
-	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-	try {
-		const manifest: RecoveryManifest = {
-			version: RECOVERY_MANIFEST_VERSION,
-			records: [...records],
-		};
-		await writeFile(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-		await rename(temporaryPath, path);
-	} finally {
-		await rm(temporaryPath, { force: true }).catch(() => undefined);
-	}
-}
-
-/** Merge retained artifacts into the durable manifest. */
-export async function persistRecoveryRecords(
-	configPath: string,
-	records: readonly RecoveryRecord[],
-): Promise<void> {
-	if (records.length === 0) return;
-	const path = getRecoveryManifestPath(configPath);
-	await withFileMutationQueue(path, async () => {
-		const merged = new Map<string, RecoveryRecord>();
-		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
-		for (const record of records) merged.set(recoveryKey(record), record);
-		await writeManifest(path, [...merged.values()]);
-	});
-}
-
-export function recoveryRecordFromFinalization(
-	runId: number,
-	finalization: WorktreeFinalization,
-	now = Date.now(),
-): RecoveryRecord {
-	return {
-		runId,
-		createdAt: now,
-		integrated: finalization.integrated,
-		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
-		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
-		...(finalization.error ? { error: finalization.error } : {}),
-	};
-}
-
-/** Show retained recovery paths on every later session start until the user
- * removes the artifacts. Stale records are pruned automatically. */
-export async function announceRecoveryRecords(
-	configPath: string,
-	ctx: {
-		hasUI?: boolean;
-		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
-	},
-): Promise<void> {
-	if (ctx.hasUI === false) return;
-	const records = await readRecoveryRecords(configPath);
-	if (records.length === 0) return;
-	const live = records.filter((record) =>
-		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
-		(record.patchPath ? existsSync(record.patchPath) : false),
-	);
-	if (live.length !== records.length) {
-		const path = getRecoveryManifestPath(configPath);
-		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
-	}
-	for (const record of live) {
-		const paths = [
-			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
-			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
-		].filter(Boolean).join(" · ");
-		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
-		ctx.ui.notify(
-			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
-			"error",
-		);
-	}
-}
+/** Durable handoff for worktree integration/cleanup failures across sessions. */
+
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import type { WorktreeFinalization } from "./worktree.ts";
+
+export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
+const RECOVERY_MANIFEST_VERSION = 1;
+
+export interface RecoveryRecord {
+	runId: number;
+	createdAt: number;
+	integrated: boolean;
+	worktreePath?: string;
+	patchPath?: string;
+	error?: string;
+}
+
+interface RecoveryManifest {
+	version: number;
+	records: RecoveryRecord[];
+}
+
+export function getRecoveryManifestPath(configPath: string): string {
+	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
+}
+
+function normalizeRecord(value: unknown): RecoveryRecord | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.runId !== "number" || !Number.isInteger(raw.runId) || raw.runId < 1) return undefined;
+	if (typeof raw.createdAt !== "number" || !Number.isFinite(raw.createdAt)) return undefined;
+	return {
+		runId: raw.runId,
+		createdAt: raw.createdAt,
+		integrated: raw.integrated === true,
+		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
+		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
+		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
+	};
+}
+
+export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
+	try {
+		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(configPath), "utf8")) as {
+			records?: unknown;
+		};
+		if (!Array.isArray(parsed.records)) return [];
+		return parsed.records.flatMap((record) => {
+			const normalized = normalizeRecord(record);
+			return normalized ? [normalized] : [];
+		});
+	} catch {
+		return [];
+	}
+}
+
+function recoveryKey(record: RecoveryRecord): string {
+	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
+}
+
+async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
+	if (records.length === 0) {
+		await rm(path, { force: true });
+		return;
+	}
+	await mkdir(dirname(path), { recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		const manifest: RecoveryManifest = {
+			version: RECOVERY_MANIFEST_VERSION,
+			records: [...records],
+		};
+		await writeFile(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+		await rename(temporaryPath, path);
+	} finally {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+	}
+}
+
+/** Merge retained artifacts into the durable manifest. */
+export async function persistRecoveryRecords(
+	configPath: string,
+	records: readonly RecoveryRecord[],
+): Promise<void> {
+	if (records.length === 0) return;
+	const path = getRecoveryManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const merged = new Map<string, RecoveryRecord>();
+		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
+		for (const record of records) merged.set(recoveryKey(record), record);
+		await writeManifest(path, [...merged.values()]);
+	});
+}
+
+export function recoveryRecordFromFinalization(
+	runId: number,
+	finalization: WorktreeFinalization,
+	now = Date.now(),
+): RecoveryRecord {
+	return {
+		runId,
+		createdAt: now,
+		integrated: finalization.integrated,
+		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
+		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
+		...(finalization.error ? { error: finalization.error } : {}),
+	};
+}
+
+/** Show retained recovery paths on every later session start until the user
+ * removes the artifacts. Stale records are pruned automatically. */
+export async function announceRecoveryRecords(
+	configPath: string,
+	ctx: {
+		hasUI?: boolean;
+		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
+	},
+): Promise<void> {
+	if (ctx.hasUI === false) return;
+	const records = await readRecoveryRecords(configPath);
+	if (records.length === 0) return;
+	const live = records.filter((record) =>
+		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
+		(record.patchPath ? existsSync(record.patchPath) : false),
+	);
+	if (live.length !== records.length) {
+		const path = getRecoveryManifestPath(configPath);
+		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
+	}
+	for (const record of live) {
+		const paths = [
+			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
+			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
+		].filter(Boolean).join(" · ");
+		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
+		ctx.ui.notify(
+			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
+			"error",
+		);
+	}
+}

package/src/session-fork.ts

@@ -1,80 +1,80 @@
-/** Pi SessionManager-backed cloning of a retained sub-agent session branch. */
-
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export interface ForkedSession {
-	sessionDir: string;
-	sessionId: string;
-	sessionFile: string;
-}
-
-/** Locate one retained session by its authoritative header id. */
-export async function findRetainedSessionFile(
-	sessionDir: string,
-	sessionId: string,
-): Promise<string> {
-	// The retained header may point at a worktree that has since been removed.
-	// The session id is authoritative inside this explicit private directory;
-	// listing the directory directly avoids a stale-cwd filter rejecting it.
-	const sessions = await SessionManager.listAll(sessionDir);
-	const matches = sessions.filter((session) => session.id === sessionId);
-	if (matches.length === 0) {
-		throw new Error(`Retained session ${sessionId} was not found in ${sessionDir}.`);
-	}
-	if (matches.length > 1) {
-		throw new Error(`Retained session id ${sessionId} is ambiguous in ${sessionDir}.`);
-	}
-	return matches[0].path;
-}
-
-/**
- * Copy only the source file's active branch into a new isolated temp session
- * directory. SessionManager performs all JSONL/tree handling; source state is
- * never mutated.
- */
-export async function forkRetainedSession(options: {
-	/** Cwd stored in the source session header (used for exact lookup). */
-	cwd: string;
-	/** Optional cwd for the cloned session header and future child tools. */
-	targetCwd?: string;
-	sessionDir: string;
-	sessionId: string;
-}): Promise<ForkedSession> {
-	const sourceSessionFile = await findRetainedSessionFile(
-		options.sessionDir,
-		options.sessionId,
-	);
-	const sessionDir = await mkdtemp(join(tmpdir(), "pi-subagent-session-fork-"));
-	try {
-		// Supplying the new directory makes createBranchedSession write there.
-		// cwdOverride rewrites the cloned header so a settled isolated session can
-		// safely continue in its fresh worktree instead of a removed old path.
-		const manager = SessionManager.open(
-			sourceSessionFile,
-			sessionDir,
-			options.targetCwd ?? options.cwd,
-		);
-		const leafId = manager.getLeafId();
-		if (!leafId) throw new Error(`Retained session ${options.sessionId} has no active branch to fork.`);
-		const sessionFile = manager.createBranchedSession(leafId);
-		if (!sessionFile) throw new Error("Pi SessionManager did not create a persistent fork.");
-		// Pi defers branch files that contain no assistant response. Such a file
-		// cannot be resumed by RPC without creating a blank session, so reject
-		// rather than pretending context was preserved.
-		if (!existsSync(sessionFile)) {
-			throw new Error(`Forked session branch has no persisted assistant checkpoint at ${sessionFile}.`);
-		}
-		return {
-			sessionDir,
-			sessionId: manager.getSessionId(),
-			sessionFile,
-		};
-	} catch (error) {
-		await rm(sessionDir, { recursive: true, force: true }).catch(() => undefined);
-		throw error;
-	}
-}
+/** Pi SessionManager-backed cloning of a retained sub-agent session branch. */
+
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface ForkedSession {
+	sessionDir: string;
+	sessionId: string;
+	sessionFile: string;
+}
+
+/** Locate one retained session by its authoritative header id. */
+export async function findRetainedSessionFile(
+	sessionDir: string,
+	sessionId: string,
+): Promise<string> {
+	// The retained header may point at a worktree that has since been removed.
+	// The session id is authoritative inside this explicit private directory;
+	// listing the directory directly avoids a stale-cwd filter rejecting it.
+	const sessions = await SessionManager.listAll(sessionDir);
+	const matches = sessions.filter((session) => session.id === sessionId);
+	if (matches.length === 0) {
+		throw new Error(`Retained session ${sessionId} was not found in ${sessionDir}.`);
+	}
+	if (matches.length > 1) {
+		throw new Error(`Retained session id ${sessionId} is ambiguous in ${sessionDir}.`);
+	}
+	return matches[0].path;
+}
+
+/**
+ * Copy only the source file's active branch into a new isolated temp session
+ * directory. SessionManager performs all JSONL/tree handling; source state is
+ * never mutated.
+ */
+export async function forkRetainedSession(options: {
+	/** Cwd stored in the source session header (used for exact lookup). */
+	cwd: string;
+	/** Optional cwd for the cloned session header and future child tools. */
+	targetCwd?: string;
+	sessionDir: string;
+	sessionId: string;
+}): Promise<ForkedSession> {
+	const sourceSessionFile = await findRetainedSessionFile(
+		options.sessionDir,
+		options.sessionId,
+	);
+	const sessionDir = await mkdtemp(join(tmpdir(), "pi-subagent-session-fork-"));
+	try {
+		// Supplying the new directory makes createBranchedSession write there.
+		// cwdOverride rewrites the cloned header so a settled isolated session can
+		// safely continue in its fresh worktree instead of a removed old path.
+		const manager = SessionManager.open(
+			sourceSessionFile,
+			sessionDir,
+			options.targetCwd ?? options.cwd,
+		);
+		const leafId = manager.getLeafId();
+		if (!leafId) throw new Error(`Retained session ${options.sessionId} has no active branch to fork.`);
+		const sessionFile = manager.createBranchedSession(leafId);
+		if (!sessionFile) throw new Error("Pi SessionManager did not create a persistent fork.");
+		// Pi defers branch files that contain no assistant response. Such a file
+		// cannot be resumed by RPC without creating a blank session, so reject
+		// rather than pretending context was preserved.
+		if (!existsSync(sessionFile)) {
+			throw new Error(`Forked session branch has no persisted assistant checkpoint at ${sessionFile}.`);
+		}
+		return {
+			sessionDir,
+			sessionId: manager.getSessionId(),
+			sessionFile,
+		};
+	} catch (error) {
+		await rm(sessionDir, { recursive: true, force: true }).catch(() => undefined);
+		throw error;
+	}
+}

package/src/thread-lifecycle.ts

@@ -1,7 +1,8 @@
 /**
  * Stable logical-thread generation lifecycle for background sub-agents.
  *
- * Dispatch owns workflow policy and internal role briefs; this module owns one
+ * Dispatch owns workflow policy, the live stage projection, and internal role
+ * briefs; this module owns one
  * stable parent generation end to end: managed-repository lane use,
  * worktree setup/finalization after downstream review, queue/process ownership,
  * retained-session resume/fork, and guarded one-time terminal publication.
@@ -88,6 +89,16 @@ export function isWorktreeCapableAgent(agent: AgentConfig): boolean {
 	return isWriteCapableAgent(agent);
 }
 
+/** A direct reviewer otherwise cannot infer enabled-role availability from its
+ * isolated task. Managed internal gates receive the same contract in their
+ * generated briefs. Advisory reviews still emit neither machine marker. */
+function withEnabledDocumenterReviewContract(agent: AgentConfig): AgentConfig {
+	return {
+		...agent,
+		systemPrompt: `${agent.systemPrompt.trimEnd()}\n\nRuntime workflow context: documenter is enabled. In gate reviews, documentation drift is non-gating: emit DOCUMENTATION: NEEDED with ## Documentation notes, or DOCUMENTATION: CLEAN when no sync is needed. Advisory reviews still emit neither VERDICT nor DOCUMENTATION markers.`.trim(),
+	};
+}
+
 interface DispatchEnvironment {
 	ctx: ExtensionContext;
 	config: SubagentsConfig;
@@ -249,7 +260,10 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		if (!discoveredAgent) return failedStartResult(agentName, task, `Unknown agent: "${agentName}".`);
 		const resolveLiveAgentTools = (candidate: AgentConfig): AgentConfig =>
 			resolveAgentTools({ ...candidate, tools: discoveredAgent.tools }, runtime.getActiveTools());
-		const agent = resolveLiveAgentTools(discoveredAgent);
+		const resolvedAgent = resolveLiveAgentTools(discoveredAgent);
+		const agent = agentName === "reviewer" && runAgents.some((candidate) => candidate.name === "documenter")
+			? withEnabledDocumenterReviewContract(resolvedAgent)
+			: resolvedAgent;
 		if (isolation === "worktree" && !isWorktreeCapableAgent(agent)) {
 			return {
 				...failedStartResult(agentName, task, `Agent "${agentName}" is read-only; worktree isolation is available only to write-capable agents such as worker, cleaner, or documenter.`),
@@ -1051,9 +1065,9 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 					thread.lifecycleOperation === "settle" &&
 					!thread.retired;
 				try {
-					// For isolated writers this is deliberately after the managed documenter
-					// and reviewer stages: every child sees the same worktree, then one
-					// lifecycle owner integrates the complete writer+docs state exactly once.
+					// For isolated writers this is deliberately after the managed reviewer
+					// and any needed documentation stage: every child sees the same worktree,
+					// then one lifecycle owner integrates the complete settled state exactly once.
 					await thread.finalizeIsolation(generation, result);
 					if (!ownsSettlement()) return;
 					if (workflowOutcome && isolation === "worktree") {

package/src/widget.ts

@@ -10,6 +10,7 @@ import {
 	monitor,
 	statusIcon,
 	type RunView,
+	type WorkflowStage,
 } from "./monitor.ts";
 
 export const SUBAGENTS_WIDGET_ID = "pi-subagents";
@@ -50,7 +51,9 @@ function runPrimaryLine(
 	prefix: string,
 ): string {
 	const dim = (text: string): string => theme.fg("dim", text);
-	const icon = statusIcon(run.status, theme);
+	const icon = run.managedWorkflow && run.status === "running"
+		? theme.fg("accent", theme.bold("◆"))
+		: statusIcon(run.status, theme);
 	const displayName = run.managedWorkflow ? `${run.agent} workflow` : run.agent;
 	const name = theme.fg("accent", theme.bold(displayName));
 	const identity = `${prefix}${icon} ${name}`;
@@ -72,7 +75,9 @@ function runPrimaryLine(
 		: undefined;
 	const taskSource = run.parentRunId !== undefined
 		? [run.relationLabel, run.label].filter((part): part is string => Boolean(part)).join(" · ")
-		: formatTaskSummary(run.task, 64);
+		: run.managedWorkflow
+			? run.label ?? formatTaskSummary(run.task, 64)
+			: formatTaskSummary(run.task, 64);
 	const taskDesiredSource = [continuation, taskSource]
 		.filter((part): part is string => Boolean(part))
 		.join(" · ");
@@ -129,6 +134,46 @@ function runPrimaryLine(
 	return compactLine(primaryLeft, elapsed ? dim(`· ${elapsed}`) : "", width);
 }
 
+function workflowStageToken(stage: WorkflowStage, theme: Theme): string {
+	const content = (icon: string): string => `${icon} ${stage.relation}`;
+	switch (stage.status) {
+		case "done":
+			return theme.fg("success", content("✓"));
+		case "active":
+			return theme.fg("accent", theme.bold(content("●")));
+		case "changes":
+			return theme.fg("warning", content("!"));
+		case "failed":
+			return theme.fg("error", content("✗"));
+		default:
+			return theme.fg("dim", content("○"));
+	}
+}
+
+/** Render the real/currently planned stage sequence. On narrow terminals the
+ * active (or next actionable) stage becomes the left edge so it survives before
+ * older history; the workflow-wide elapsed tail is independently preserved on
+ * the primary line. */
+function workflowTimelineLine(run: RunView, theme: Theme, width: number): string | undefined {
+	const stages = run.workflowStages;
+	const indent = "  ";
+	if (!stages || stages.length === 0 || width <= visibleWidth(indent)) return undefined;
+	const separator = theme.fg("dim", " ─ ");
+	const render = (items: readonly WorkflowStage[]): string =>
+		items.map((stage) => workflowStageToken(stage, theme)).join(separator);
+	const full = `${indent}${render(stages)}`;
+	if (visibleWidth(full) <= width) return full;
+
+	let focusIndex = stages.findIndex((stage) => stage.status === "active");
+	if (focusIndex === -1) {
+		focusIndex = stages.findLastIndex((stage) => stage.status === "changes" || stage.status === "failed");
+	}
+	if (focusIndex === -1) focusIndex = stages.findIndex((stage) => stage.status === "pending");
+	if (focusIndex === -1) focusIndex = stages.length - 1;
+	const omittedPrefix = focusIndex > 0 ? theme.fg("dim", "… ─ ") : "";
+	return truncateToWidth(`${indent}${omittedPrefix}${render(stages.slice(focusIndex))}`, width, "…");
+}
+
 function runActivityLine(run: RunView, theme: Theme, width: number, indent: string): string[] {
 	const dim = (text: string): string => theme.fg("dim", text);
 	const activity = run.activity?.trim();
@@ -140,9 +185,10 @@ function runActivityLine(run: RunView, theme: Theme, width: number, indent: stri
 	return [truncateToWidth(`${indent}${dim(activitySummary)}`, width, "")];
 }
 
-/** Render active runs as a tree: main-agent dispatches are roots and managed
- * documenter/reviewer/fix steps nest under the stable parent row. Fork labels
- * include their source id; other control ids remain available through status. */
+/** Render active runs as compact workflow-aware trees. Stable managed parents
+ * retain their stage timeline while the current internal child supplies exact
+ * model/thinking/activity telemetry. Fork labels include their source id; other
+ * control ids remain available through status. */
 export function formatActiveRunLines(
 	runs: readonly RunView[],
 	theme: Theme,
@@ -166,9 +212,14 @@ export function formatActiveRunLines(
 	for (const root of roots) {
 		const children = childrenOf.get(root.id) ?? [];
 		lines.push(runPrimaryLine(root, theme, width, now, ""));
-		// The parent's managed-workflow placeholder is redundant while a child
-		// row shows live progress; keep it only between stages.
-		if (children.length === 0) lines.push(...runActivityLine(root, theme, width, "  "));
+		const hasTimeline = Boolean(root.managedWorkflow && root.workflowStages?.length);
+		const timeline = hasTimeline ? workflowTimelineLine(root, theme, width) : undefined;
+		if (timeline) lines.push(timeline);
+		// A parent placeholder ("managed workflow running") would duplicate the
+		// timeline. Standalone roots keep their useful activity line as before.
+		if (children.length === 0 && !hasTimeline) {
+			lines.push(...runActivityLine(root, theme, width, "  "));
+		}
 		children.forEach((child, index) => {
 			const connector = index === children.length - 1 ? "└ " : "├ ";
 			lines.push(runPrimaryLine(child, theme, width, now, theme.fg("dim", `  ${connector}`)));