@ferris1225/pi-subagents 4.1.4 → 4.1.6

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";
@@ -38,6 +39,26 @@ function formatContinuationTask(label: string, task: string, width: number): str
 	return summary ? `${label}${separator}${summary}` : label;
 }
 
+/** Worktree-group badge shown on the row that owns the isolated worktree: the
+ * short group identity plus its integration state, so a workflow visibly moves
+ * through applying → applied (or retained) and a continuation worktree (new
+ * identity) is distinguishable from the original one. */
+function worktreeBadge(run: RunView): string {
+	const id = run.worktreeId ?? "?";
+	switch (run.integrationStatus) {
+		case "finalizing":
+			return `wt:${id} applying`;
+		case "integrated":
+			return `wt:${id} applied`;
+		case "no_changes":
+			return `wt:${id} clean`;
+		case "retained":
+			return `wt:${id} retained`;
+		default:
+			return `wt:${id}`;
+	}
+}
+
 /** One compact primary line per genuinely active run, plus an optional indented
  * activity line. The primary line reserves stage model/thinking when present and
  * elapsed width before truncating the task. Settled and parked threads never
@@ -48,23 +69,32 @@ function runPrimaryLine(
 	width: number,
 	now: number,
 	prefix: string,
+	isGroupOwner: boolean,
 ): 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}`;
+	// The stable run id is the handle for subagent_control/subagent_status; a
+	// queued run has not started, which must be visible at a glance. Its model
+	// is omitted too: the route is re-resolved when the run actually starts.
+	const queued = run.status === "queued";
+	const queuedTag = queued ? ` ${dim("· queued")}` : "";
+	const identity = `${prefix}${icon} #${run.id} ${name}${queuedTag}`;
 	const elapsed = formatElapsed(run, now);
 	// Render only the resolved model id plus thinking level. Provider auth and
 	// other configuration never enter monitor state or this line.
 	const modelId = run.model?.split("/").at(-1);
-	const modelSource = run.managedWorkflow
+	const modelSource = run.managedWorkflow || queued
 		? ""
 		: formatTaskSummary(
 			modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
 			64,
 			false,
 		);
+	const badge = isGroupOwner && run.isolation === "worktree" ? worktreeBadge(run) : "";
 	// A chain child shows its role in the chain plus a task-derived label; the
 	// templated fix brief itself would only repeat the parent review's content.
 	const continuation = run.parentRunId === undefined
@@ -72,11 +102,13 @@ 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(" · ");
-	const primaryPartCount = 2 + (modelSource ? 1 : 0) + (elapsed ? 1 : 0);
+	const primaryPartCount = 2 + (modelSource ? 1 : 0) + (badge ? 1 : 0) + (elapsed ? 1 : 0);
 	const contentWidth = Math.max(
 		0,
 		width -
@@ -125,10 +157,51 @@ function runPrimaryLine(
 		identity,
 		task ? dim(task) : undefined,
 		modelThinking ? dim(modelThinking) : undefined,
+		badge ? dim(badge) : undefined,
 	].filter((part): part is string => Boolean(part)).join(" · ");
 	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 +213,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,
@@ -165,13 +239,20 @@ export function formatActiveRunLines(
 	const lines: string[] = [];
 	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, "  "));
+		// Roots (including orphaned chain children whose parent row is gone) own
+		// their worktree group; nested children inherit the group via the tree.
+		lines.push(runPrimaryLine(root, theme, width, now, "", true));
+		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}`)));
+			lines.push(runPrimaryLine(child, theme, width, now, theme.fg("dim", `  ${connector}`), false));
 			lines.push(...runActivityLine(child, theme, width, "      "));
 		});
 	}

package/src/worktree.ts

@@ -16,6 +16,18 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 
 export type IsolationMode = "shared" | "worktree";
 
+const WORKTREE_TEMP_DIR_PREFIX = "pi-subagent-worktree-";
+
+/** Short stable identity of one isolated worktree group (the mkdtemp suffix).
+ * Continuation/fork generations create a fresh worktree, so the identity
+ * visibly changes when the group's filesystem boundary changes. */
+export function worktreeGroupId(worktree: Pick<WorktreeIsolation, "tempDir">): string {
+	const base = worktree.tempDir.split(/[\\/]/).filter(Boolean).pop() ?? worktree.tempDir;
+	return base.startsWith(WORKTREE_TEMP_DIR_PREFIX)
+		? base.slice(WORKTREE_TEMP_DIR_PREFIX.length)
+		: base;
+}
+
 export interface CommandRunOptions {
 	cwd: string;
 	input?: Buffer;