@ferris1225/pi-subagents 4.1.2 → 4.1.3

package/src/thread-lifecycle.ts

@@ -11,7 +11,12 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { existsSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { resolve } from "node:path";
-import { discoverAgents, isWriteCapableAgent, type AgentConfig } from "./agents.ts";
+import {
+	discoverAgents,
+	isWriteCapableAgent,
+	resolveAgentTools,
+	type AgentConfig,
+} from "./agents.ts";
 import { completionTriggersTurn, type CompletionMessageItem } from "./completion.ts";
 import {
 	DEFAULT_THINKING_LEVEL,
@@ -43,7 +48,7 @@ import {
 	resolveAgentModelRoute,
 	resolveThinkingLevel,
 } from "./models.ts";
-import { monitor, sumUsage } from "./monitor.ts";
+import { monitor, sumUsage, type ContinuationKind } from "./monitor.ts";
 import { persistRecoveryRecords, recoveryRecordFromFinalization } from "./recovery.ts";
 import type { SubagentRuntime, SubagentThread, ThreadState } from "./runtime.ts";
 import { forkRetainedSession } from "./session-fork.ts";
@@ -185,6 +190,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		prompt?: string;
 		worktree?: WorktreeIsolation;
 		forkedFromRunId?: number;
+		continuationKind?: ContinuationKind;
 	}
 
 	interface ResumeReservation {
@@ -225,7 +231,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		cwd: string | undefined,
 		isolation: IsolationMode = "shared",
 		existingThread?: SubagentThread,
-		newObjectiveOnResume = false,
+		appendedObjectiveOnResume = false,
 		environment?: DispatchEnvironment,
 		seed?: SessionSeed,
 		resumeReservation?: ResumeReservation,
@@ -239,8 +245,11 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		const runCtx = environment?.ctx ?? ctx;
 		const runConfig = environment?.config ?? config;
 		const runAgents = environment?.agents ?? agents;
-		const agent = runAgents.find((candidate) => candidate.name === agentName);
-		if (!agent) return failedStartResult(agentName, task, `Unknown agent: "${agentName}".`);
+		const discoveredAgent = runAgents.find((candidate) => candidate.name === agentName);
+		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);
 		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.`),
@@ -288,6 +297,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		const runId = existingThread?.id ?? monitor.addRun(agent.name, task, route.agent.model, thinkingLevel, {
 			isolation,
 			...(seed?.forkedFromRunId !== undefined ? { forkedFromRunId: seed.forkedFromRunId } : {}),
+			...(seed?.continuationKind ? { continuationKind: seed.continuationKind } : {}),
 		});
 		const generation = (existingThread?.generation ?? 0) + 1;
 		const pending: SingleResult = {
@@ -302,7 +312,10 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 			...(seed?.forkedFromRunId !== undefined ? { forkedFromRunId: seed.forkedFromRunId } : {}),
 		};
 		if (existingThread) {
-			monitor.restartRun(runId, agent.name, task, route.agent.model, thinkingLevel, isolation);
+			monitor.restartRun(runId, agent.name, task, route.agent.model, thinkingLevel, isolation, {
+				elapsedMs: existingThread.elapsedMs,
+				continuationKind: appendedObjectiveOnResume ? "resume-appended" : "resume-retained",
+			});
 			runtime.settledRuns.delete(runId);
 		}
 
@@ -367,6 +380,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 				control,
 				generationCompletion: Promise.resolve(),
 				lifecycleVersion: 0,
+				elapsedMs: 0,
 				sessionId: seed?.sessionId,
 				sessionDir: seed?.sessionDir,
 				forkedFromRunId: seed?.forkedFromRunId,
@@ -504,6 +518,10 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 			});
 		};
 
+		const persistElapsedTime = (): void => {
+			thread.elapsedMs = monitor.getElapsedMs(runId) ?? thread.elapsedMs;
+		};
+
 		thread.park = async (): Promise<"queued" | "active"> => {
 			if (thread.retired) throw new Error(`Run #${runId} was retired by subagent_stop.`);
 			if (thread.lifecycleOperation) throw new Error(`Run #${runId} is already handling ${thread.lifecycleOperation}.`);
@@ -544,7 +562,14 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 				thread.state = "parked";
 				thread.queueController = undefined;
 				runtime.runControllers.delete(runId);
+				const parkedRun = monitor.findRun(runId);
+				if (parkedRun?.managedWorkflow && parkedRun.task !== thread.task) {
+					// The active child row previously showed this stage objective. Once it
+					// disappears, keep the parked parent aligned with what resume retains.
+					monitor.setTask(runId, thread.task);
+				}
 				monitor.setStatus(runId, "parked");
+				persistElapsedTime();
 				return queued ? "queued" : "active";
 			} finally {
 				if (thread.lifecycleVersion === version && thread.lifecycleOperation === "park") {
@@ -822,6 +847,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 						prompt: forkObjective ?? FORK_CONTINUATION_PROMPT,
 						worktree: childWorktree,
 						forkedFromRunId: runId,
+						continuationKind: forkObjective ? "fork-appended" : "fork-retained",
 					},
 				);
 				if (child.exitCode !== -1 || child.runId === undefined) {
@@ -877,6 +903,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 						{
 							defaultCwd: executionCwd,
 							agent: route.agent,
+							resolveAgentForAttempt: resolveLiveAgentTools,
 							agentName,
 							task,
 							cwd: executionCwd,
@@ -891,7 +918,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 								? {
 									sessionId: priorSessionId,
 									sessionDir: priorSessionDir,
-									stdinText: seed?.prompt ?? (newObjectiveOnResume
+									stdinText: seed?.prompt ?? (appendedObjectiveOnResume
 										? task
 										: buildResumePrompt(priorTask ?? task, "the retained thread was resumed")),
 								}
@@ -955,9 +982,10 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 				const workflowPlan = getManagedWorkflowPlan(result, runConfig, workflowAvailability);
 				if (workflowPlan && runtime.sessionActive) {
 					thread.state = "running";
-					// The stable parent row remains active until every internal writer and
-					// reviewer settles. Internal rows are independently queryable but never
-					// enter this top-level lifecycle or publish completions.
+					// The stable parent row now represents workflow ownership, not whichever
+					// model stage ran most recently. Internal rows own their exact role/model/
+					// thinking/timing telemetry and remain independently queryable.
+					monitor.setManagedWorkflow(runId, true);
 					monitor.setStatus(runId, "running");
 					monitor.setActivity(
 						runId,
@@ -978,8 +1006,10 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 						rememberLatest: (latest) => {
 							if (runtime.threads.get(runId) !== thread || thread.generation !== generation) return;
 							thread.lastResult = latest;
+							// Retained control follows the newest child session, but the live parent
+							// row keeps the original top-level role/model/usage. The active internal
+							// row already owns the current stage's role and telemetry.
 							thread.agentName = latest.agent;
-							monitor.setAgent(runId, latest.agent);
 							thread.task = latest.task;
 							thread.sessionId = latest.sessionId;
 							thread.sessionDir = latest.sessionDir;
@@ -1041,6 +1071,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 					// Stamp the terminal monitor state before projecting it. This gives every
 					// path a fixed endedAt even when the row is removed immediately.
 					monitor.setStatus(runId, failed ? "failed" : "done");
+					persistElapsedTime();
 					if (!runtime.sessionActive || !ownsSettlement()) return;
 
 					const modelLevel = failed && isModelLevelFailure(result);
@@ -1175,6 +1206,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 					if (!ownsSettlement()) return;
 					thread.state = "failed";
 					monitor.setStatus(runId, "failed");
+					persistElapsedTime();
 					finishRun(runId, "failed", { silent: true });
 					runtime.registerRunResult(runId, crashed);
 					runtime.runControllers.delete(runId);

package/src/tools.ts

@@ -1,7 +1,7 @@
 /**
  * Thread controls and lookup tools around the subagent runtime:
- * subagent_control (steer/retarget/park/resume), subagent_wait (in-turn result
- * lookup), subagent_status, and destructive subagent_stop.
+ * subagent_control (steer/retarget/park/resume/fork), subagent_wait (in-turn
+ * result lookup), subagent_status, and destructive subagent_stop.
  */
 
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -12,8 +12,7 @@ import { DEFAULT_MAX_RESULT_LINES, loadConfig } from "./config.ts";
 import { formatCompletionBlock, formatUsage, matchRunIds } from "./format.ts";
 import { emptyUsage } from "./rpc-run.ts";
 import {
-	formatElapsed,
-	formatUsageCompact,
+	formatTaskSummary,
 	isRunActiveStatus,
 	monitor,
 	runLabel,
@@ -51,7 +50,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 			Type.String({ description: "Instruction queued by steer after the current child tool batch." }),
 		),
 		objective: Type.Optional(
-			Type.String({ description: "Replacement objective for retarget, or optional objective for resume/fork." }),
+			Type.String({ description: "Replacement objective for retarget; optional appended objective for resume/fork. Omit on resume/fork to continue the current retained objective." }),
 		),
 	});
 
@@ -64,14 +63,14 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 			"retarget replaces the objective in that same active top-level child.",
 			"Managed downstream documenter/reviewer/fix stages are controlled by the parent queue rather than its settled RPC control: use park or stop there, then resume with an objective to redirect retained context.",
 			"park aborts to a stable checkpoint, terminates the child, preserves context, and releases its concurrency slot.",
-			"resume restarts a parked, completed, or failed retained thread with the same run id; objective is optional.",
-			"fork copies a parked/completed/failed retained session branch into a new logical thread and run id; an isolated checkpoint must be settled and integrated first; objective is optional.",
+			"resume restarts a parked, completed, or failed retained thread with the same run id and cumulative active time; omit objective to continue the current goal, or provide one to append it to retained context and make it the displayed current goal.",
+			"fork copies a parked/completed/failed retained session branch into a new logical thread and run id; an isolated checkpoint must be settled and integrated first; omit objective to continue the current goal, or provide one to append a new branch goal.",
 		].join(" "),
 		promptSnippet: "Control a subagent thread: steer/retarget an active top-level child; park/stop a managed downstream stage; resume or fork retained context.",
 		promptGuidelines: [
 			"Use subagent_control steer to refine an active top-level RPC child without restarting it; the instruction is delivered after its current tool batch.",
 			"Use subagent_control retarget only while that top-level child is active. During a managed downstream stage, park it and resume with a replacement objective instead.",
-			"Use subagent_control park to checkpoint useful context while releasing the process/concurrency slot, and resume to continue the same run id later.",
+			"Use subagent_control park to checkpoint useful context while releasing the process/concurrency slot, and resume to continue the same run id later. Resume without objective keeps the current goal; resume with objective appends that goal to retained context.",
 			"Use subagent_control fork only on a parked or settled retained thread; isolated work must settle and integrate before it can fork. Fork creates a new run id while leaving the source untouched.",
 			"Use subagent_stop only for destructive cancellation; it retires that thread's retained session without retiring independent forks.",
 		],
@@ -110,13 +109,15 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 							thread.task = objective;
 							thread.control.retargetPending(objective);
 							monitor.setTask(thread.id, objective);
-							return { content: [{ type: "text", text: `Updated queued run #${thread.id} to the new objective; no child was spawned by this control action.` }], details: {} };
+							monitor.setContinuationKind(thread.id, "retarget");
+							return { content: [{ type: "text", text: `Updated queued run #${thread.id} to the replacement objective; no child was spawned by this control action.` }], details: {} };
 						}
 						if (!(["starting", "running", "steering", "interrupting", "retrying"] as const).includes(phase as any)) {
 							return { content: [{ type: "text", text: `Run #${thread.id} is ${thread.state}; use resume with objective to restart retained context.` }], details: {} };
 						}
 						thread.task = objective;
 						monitor.setTask(thread.id, objective);
+						monitor.setContinuationKind(thread.id, "retarget");
 						await thread.control.retarget(objective);
 						return { content: [{ type: "text", text: `Retargeted run #${thread.id} in the same session; the aborted objective will not be delivered as a completion.` }], details: {} };
 					}
@@ -146,11 +147,19 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 						if (params.objective !== undefined && !objective) {
 							return { content: [{ type: "text", text: "resume objective must be non-blank when provided." }], details: {} };
 						}
+						const hadRetainedSession = Boolean(thread.sessionId && thread.sessionDir);
 						const pending = await thread.resume(objective, ctx);
 						if (pending.exitCode !== -1) {
 							return { content: [{ type: "text", text: getResultOutput(pending) }], details: {} };
 						}
-						return { content: [{ type: "text", text: `Resumed run #${thread.id}${objective ? " with a new objective" : " from retained context"}; completion will arrive automatically.` }], details: {}, terminate: true };
+						const currentObjective = formatTaskSummary(objective ?? thread.task, 80, false);
+						const mode = objective
+							? `appended objective: ${currentObjective}`
+							: `continuing current objective: ${currentObjective}`;
+						const context = hadRetainedSession
+							? "the same retained session and prior context are preserved"
+							: "no prior child session existed, so only the logical run and objective are continued";
+						return { content: [{ type: "text", text: `Resumed run #${thread.id}, ${mode}; ${context}, and cumulative active time is preserved. Completion will arrive automatically.` }], details: {}, terminate: true };
 					}
 					case "fork": {
 						const objective = params.objective === undefined ? undefined : nonBlank(params.objective);
@@ -164,7 +173,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 						return {
 							content: [{
 								type: "text",
-								text: `Forked run #${thread.id} into new run #${pending.runId}${objective ? " with a new objective" : " from retained context"}; the source is unchanged and child completion will arrive automatically.`,
+								text: `Forked run #${thread.id} into new run #${pending.runId}; ${objective ? `appended branch objective: ${formatTaskSummary(objective, 80, false)}` : `continuing current objective: ${formatTaskSummary(thread.task, 80, false)}`}. Retained context is copied, the source is unchanged, and child completion will arrive automatically.`,
 							}],
 							details: { sourceRunId: thread.id, childRunId: pending.runId, result: pending },
 							terminate: true,
@@ -352,10 +361,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 	});
 
 	// Status overview: what is running right now and what finished this session,
-	// with per-run details (id, agent, model, usage, elapsed, activity) so the
-	// main agent can decide whether to wait, stop, or re-dispatch. Learned from
-	// nicobailon/pi-subagents ({action:"status"} + status files): inspect before
-	// you act, and report run ids when handing off.
+	// with per-run details (id, role, model, usage, elapsed, activity).
 	const SubagentStatusParams = Type.Object({
 		id: Type.Optional(
 			Type.String({
@@ -368,7 +374,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 		name: "subagent_status",
 		label: "Subagent Status",
 		description: [
-			"List active background sub-agent runs (id, agent, model, usage, elapsed, current activity) and recently finished results.",
+			"List active background sub-agent runs (id, role, model, thinking, usage, elapsed, current activity) and recently finished results.",
 			"Pass id to read the full result of a finished run; pass no id for the overview.",
 			"Use it to decide whether to subagent_wait, subagent_stop, or re-dispatch — never to poll: results arrive by themselves.",
 		].join(" "),
@@ -412,20 +418,30 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 					const activeThread = runtime.threads.get(active.id);
 					const managedDownstream =
 						activeThread?.state === "running" && activeThread.control.getPhase() === "settled";
+					const activeChild = runs.find((run) =>
+						run.parentRunId === active.id && isRunActiveStatus(run.status)
+					);
+					const owner = active.managedWorkflow ? `${active.agent} workflow` : active.agent;
+					const retainedStage = active.managedWorkflow && activeThread?.agentName !== active.agent
+						? activeThread?.agentName
+						: undefined;
 					const metadata = [
 						activeThread?.isolation === "worktree" ? `worktree ${active.integrationStatus ?? activeThread.worktree?.state ?? "active"}` : undefined,
 						activeThread?.forkedFromRunId !== undefined ? `forked from #${activeThread.forkedFromRunId}` : undefined,
 						(activeThread?.forkChildRunIds.length ?? 0) > 0 ? `forks ${activeThread!.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
 					].filter(Boolean).join(" · ");
+					const stageStatus = activeChild
+						? monitor.summarize(activeChild)
+						: active.activity ?? statusLabel(active.status);
 					return {
 						content: [
 							{
 								type: "text",
 								text: parked
-									? `Run #${active.id} ${active.agent} is parked with retained context${metadata ? ` (${metadata})` : ""}. Use subagent_control resume to restart it, or subagent_stop to retire it.`
+									? `Run #${active.id} ${owner} is parked with retained${retainedStage ? ` ${retainedStage} stage` : ""} context${metadata ? ` (${metadata})` : ""}. Use subagent_control resume to restart it, or subagent_stop to retire it.`
 									: managedDownstream
-										? `Run #${active.id} ${active.agent} is in a managed downstream stage (${active.activity ?? statusLabel(active.status)}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait for its result, subagent_control park to checkpoint it, or subagent_stop to cancel it. Steer/retarget are unavailable until you park and resume the retained stage.`
-										: `Run #${active.id} ${active.agent} is still active (${active.activity ?? statusLabel(active.status)}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait to block for its result, subagent_control to steer/park it, or subagent_stop to cancel it.`,
+										? `Run #${active.id} ${owner} is in a managed downstream stage (${stageStatus}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait for its result, subagent_control park to checkpoint it, or subagent_stop to cancel it. Steer/retarget are unavailable until you park and resume the retained stage.`
+										: `Run #${active.id} ${owner} is still active (${active.activity ?? statusLabel(active.status)}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait to block for its result, subagent_control to steer/park it, or subagent_stop to cancel it.`,
 							},
 						],
 						details: {},
@@ -434,36 +450,34 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 				return { content: [{ type: "text", text: `No subagent run matches "${requested}".` }], details: {} };
 			}
 
-			const now = Date.now();
 			const activeRuns = monitor.getRuns().filter(
 				(run) => isRunActiveStatus(run.status),
 			);
 			const activeLines = activeRuns.map((run) => {
 				const thread = runtime.threads.get(run.id);
-				const model = run.modelFallbackFrom
-					? `${run.model ?? "?"} (main after ${run.modelFallbackFrom} failed)`
-					: (run.model ?? "?");
 				const parts = [
-					`#${run.id} ${run.agent}`,
+					`#${run.id} ${monitor.summarize(run)}`,
 					run.label,
-					model,
-					formatUsageCompact(run.usage),
-					formatElapsed(run, now),
-					thread?.isolation === "worktree" ? `worktree ${run.integrationStatus ?? thread.worktree?.state ?? "active"}` : undefined,
 					thread?.forkedFromRunId !== undefined ? `forked from #${thread.forkedFromRunId}` : undefined,
 					(thread?.forkChildRunIds.length ?? 0) > 0 ? `forks ${thread!.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
+					run.activity ?? statusLabel(run.status),
 				].filter(Boolean);
-				return `- ${parts.join(" · ")} · ${run.activity ?? statusLabel(run.status)}`;
+				return `- ${parts.join(" · ")}`;
 			});
 			const parkedThreads = [...runtime.threads.values()].filter((thread) => thread.state === "parked");
 			const parkedLines = parkedThreads.map((thread) => {
+				const run = monitor.findRun(thread.id);
+				const owner = run?.managedWorkflow ? `${run.agent} workflow` : run?.agent ?? thread.agentName;
+				const retainedStage = run?.managedWorkflow && thread.agentName !== run.agent
+					? ` · retained stage ${thread.agentName}`
+					: "";
 				const relations = [
 					thread.forkedFromRunId !== undefined ? `forked from #${thread.forkedFromRunId}` : undefined,
 					thread.forkChildRunIds.length > 0 ? `forks ${thread.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
 				].filter(Boolean);
 				const relation = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
 				const isolation = thread.isolation === "worktree" ? ` · worktree ${thread.worktree?.state ?? "active"}` : "";
-				return `- #${thread.id} ${thread.agentName} · ${runLabel(thread.task)} · parked${thread.sessionDir ? " · context retained" : " · not started"}${isolation}${relation}`;
+				return `- #${thread.id} ${owner} · ${run?.label ?? runLabel(thread.task)} · parked${thread.sessionDir ? " · context retained" : " · not started"}${retainedStage}${isolation}${relation}`;
 			});
 			const completed = [...runtime.settledRuns.entries()].slice(-5);
 			const completedLines = completed.map(([id, result]) => {

package/src/widget.ts

@@ -3,6 +3,7 @@
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import {
+	continuationLabel,
 	formatElapsed,
 	formatTaskSummary,
 	isRunActiveStatus,
@@ -25,10 +26,22 @@ function compactLine(left: string, right: string, width: number): string {
 	return `${truncateToWidth(left, leftWidth, "…")}${separator}${right}`;
 }
 
+/** Keep continuation semantics intact while independently compacting the task. */
+function formatContinuationTask(label: string, task: string, width: number): string {
+	if (width <= 0) return "";
+	const labelWidth = visibleWidth(label);
+	if (labelWidth >= width) return truncateToWidth(label, width, "");
+	const separator = " · ";
+	const taskWidth = width - labelWidth - visibleWidth(separator);
+	if (taskWidth <= 0) return label;
+	const summary = formatTaskSummary(task, taskWidth);
+	return summary ? `${label}${separator}${summary}` : label;
+}
+
 /** One compact primary line per genuinely active run, plus an optional indented
- * activity line. The primary line reserves effective model/thinking and elapsed
- * width before truncating the task. Settled and parked threads never appear, so
- * elapsed time cannot keep ticking beside a terminal status. */
+ * activity line. The primary line reserves stage model/thinking when present and
+ * elapsed width before truncating the task. Settled and parked threads never
+ * appear, so elapsed time cannot keep ticking beside a terminal status. */
 function runPrimaryLine(
 	run: RunView,
 	theme: Theme,
@@ -38,22 +51,31 @@ function runPrimaryLine(
 ): string {
 	const dim = (text: string): string => theme.fg("dim", text);
 	const icon = statusIcon(run.status, theme);
-	const name = theme.fg("accent", theme.bold(run.agent));
+	const displayName = run.managedWorkflow ? `${run.agent} workflow` : run.agent;
+	const name = theme.fg("accent", theme.bold(displayName));
 	const identity = `${prefix}${icon} ${name}`;
 	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 = formatTaskSummary(
-		modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
-		64,
-		false,
-	);
+	const modelSource = run.managedWorkflow
+		? ""
+		: formatTaskSummary(
+			modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
+			64,
+			false,
+		);
 	// 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
+		? continuationLabel(run.continuationKind, run.forkedFromRunId)
+		: undefined;
 	const taskSource = run.parentRunId !== undefined
 		? [run.relationLabel, run.label].filter((part): part is string => Boolean(part)).join(" · ")
 		: 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 contentWidth = Math.max(
 		0,
@@ -64,15 +86,40 @@ function runPrimaryLine(
 	);
 	const modelDesired = visibleWidth(modelSource);
 	const modelFloor = Math.min(modelDesired, Math.min(12, contentWidth));
-	let modelWidth = modelSource
-		? Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8))
-		: 0;
+	let modelWidth = 0;
+	if (modelSource) {
+		if (continuation) {
+			const continuationWidth = visibleWidth(continuation);
+			// Preserve the full semantic label and the usual eight-column task tail
+			// before giving the remaining space to model/thinking.
+			const taskFloor = Math.min(
+				visibleWidth(taskDesiredSource),
+				continuationWidth +
+					(taskSource ? visibleWidth(" · ") + Math.min(8, visibleWidth(taskSource)) : 0),
+				contentWidth,
+			);
+			const effectiveModelFloor = Math.min(
+				modelFloor,
+				Math.max(0, contentWidth - continuationWidth),
+			);
+			modelWidth = Math.min(
+				modelDesired,
+				Math.max(effectiveModelFloor, contentWidth - taskFloor),
+			);
+		} else {
+			modelWidth = Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8));
+		}
+	}
 	let taskWidth = contentWidth - modelWidth;
-	if (visibleWidth(taskSource) < taskWidth) {
-		modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskSource));
+	if (visibleWidth(taskDesiredSource) < taskWidth) {
+		modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskDesiredSource));
 		taskWidth = contentWidth - modelWidth;
 	}
-	const task = taskWidth > 0 ? formatTaskSummary(taskSource, taskWidth, run.parentRunId === undefined) : "";
+	const task = taskWidth <= 0
+		? ""
+		: continuation
+			? formatContinuationTask(continuation, taskSource, taskWidth)
+			: formatTaskSummary(taskSource, taskWidth, run.parentRunId === undefined);
 	const modelThinking = modelWidth > 0 ? formatTaskSummary(modelSource, modelWidth, false) : "";
 	const primaryLeft = [
 		identity,
@@ -94,9 +141,8 @@ function runActivityLine(run: RunView, theme: Theme, width: number, indent: stri
 }
 
 /** Render active runs as a tree: main-agent dispatches are roots and managed
- * documenter/reviewer/fix steps nest under the stable parent row. No run ids
- * appear here — the tree and the task label say what each row is, and ids stay
- * available through subagent_status when a thread must be controlled. */
+ * documenter/reviewer/fix steps nest under the stable parent row. Fork labels
+ * include their source id; other control ids remain available through status. */
 export function formatActiveRunLines(
 	runs: readonly RunView[],
 	theme: Theme,
@@ -134,7 +180,7 @@ export function formatActiveRunLines(
 
 function hasTickingRun(): boolean {
 	return monitor.getRuns().some(
-		(run) => isRunActiveStatus(run.status) && run.startedAt !== undefined,
+		(run) => isRunActiveStatus(run.status) && run.activeSince !== undefined,
 	);
 }