@ferris1225/pi-subagents 4.1.2 → 4.1.4

package/src/setup.ts

@@ -63,7 +63,7 @@ const MODULE_HINTS: Record<string, string> = {
 	explorer: "read-only codebase recon (fast model)",
 	worker: "implement / fix / refactor / test (full tools)",
 	cleaner: "apply proven cleanup and deduplicate code (full tools)",
-	documenter: "sync diff or whole-codebase comments/docs (full tools)",
+	documenter: "sync diff or whole-codebase comments/docs (docs write)",
 	reviewer: "read-only audits and pre-commit gates",
 };
 
@@ -89,7 +89,7 @@ async function pickEnabledAgents(
 	return promptSelectMany(
 		ctx,
 		"Enable which sub-agents?",
-		"Space toggles • Enter confirms • Esc cancels",
+		"Space toggles • Enter confirms • Esc returns to settings",
 		items,
 		current,
 	);
@@ -120,7 +120,7 @@ async function pickAgentModel(
 	ctx: ExtensionCommandContext,
 	agentName: string,
 	currentRef: string | undefined,
-	escNote = "cancels setup",
+	escNote = "cancels this setup pass",
 ): Promise<string | undefined> {
 	return pickConfiguredModel(ctx, `Model for "${agentName}"?`, currentRef, escNote);
 }
@@ -151,7 +151,7 @@ async function pickAgentStrength(
 	model: Model<Api> | undefined,
 	current: ThinkingLevel | undefined,
 	agentDefault: ThinkingLevel,
-	escNote = "cancels setup",
+	escNote = "cancels this setup pass",
 ): Promise<ThinkingLevel | typeof AUTO_THINKING | undefined> {
 	const supported = supportedThinkingLevels(model);
 	const automatic = resolveThinkingLevel(model, agentDefault);
@@ -191,44 +191,48 @@ async function pickAgentToConfigure(
 	return promptSelectOne(
 		ctx,
 		"Configure which agent?",
-		"Type to filter • ↑/↓ • Enter selects • Esc ends this pass",
+		"Type to filter • ↑/↓ • Enter selects • Esc returns to settings",
 		enabledAgents.map((name) => ({ value: name, label: moduleLabel(name) })),
 	);
 }
 
-/** One agent: model, then thinking if the model exposes a choice. Esc at any
- * step ends the caller's pass; earlier agents in that pass stay applied. */
+interface ConfiguredAgentChoice {
+	name: string;
+	model: string;
+	strength: ThinkingLevel | typeof AUTO_THINKING;
+}
+
+/** Configure one agent while preserving the UI back stack: thinking → model →
+ * agent selection. Esc from agent selection ends this configuration pass. */
 async function configureOneAgent(
 	ctx: ExtensionCommandContext,
 	config: SubagentsConfig,
-): Promise<
-	| {
-			name: string;
-			model: string;
-			strength: ThinkingLevel | typeof AUTO_THINKING;
-	  }
-	| undefined
-> {
-	const name = await pickAgentToConfigure(ctx, config.enabledAgents);
-	if (name === undefined) return undefined;
-	const modelChoice = await pickAgentModel(
-		ctx,
-		name,
-		config.agentModels[name],
-		"stops — earlier agent changes are kept",
-	);
-	if (modelChoice === undefined) return undefined;
-	const model = effectiveModelForChoice(ctx, modelChoice);
-	const strength = await pickAgentStrength(
-		ctx,
-		name,
-		model,
-		config.agentThinkingLevels[name],
-		actualAgentThinkingDefault(ctx, config, name),
-		"stops — earlier agent changes are kept",
-	);
-	if (strength === undefined) return undefined;
-	return { name, model: modelChoice, strength };
+): Promise<ConfiguredAgentChoice | undefined> {
+	while (true) {
+		const name = await pickAgentToConfigure(ctx, config.enabledAgents);
+		if (name === undefined) return undefined;
+
+		while (true) {
+			const modelChoice = await pickAgentModel(
+				ctx,
+				name,
+				config.agentModels[name],
+				"returns to agent selection",
+			);
+			if (modelChoice === undefined) break;
+			const model = effectiveModelForChoice(ctx, modelChoice);
+			const strength = await pickAgentStrength(
+				ctx,
+				name,
+				model,
+				config.agentThinkingLevels[name],
+				actualAgentThinkingDefault(ctx, config, name),
+				"returns to model selection",
+			);
+			if (strength === undefined) continue;
+			return { name, model: modelChoice, strength };
+		}
+	}
 }
 
 async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Promise<boolean | undefined> {
@@ -280,21 +284,21 @@ function keepAgentEntries<T>(record: Record<string, T>, enabled: readonly string
 	return Object.fromEntries(Object.entries(record).filter(([name]) => keep.has(name)));
 }
 
-async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, base: SubagentsConfig): Promise<void> {
+async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, base: SubagentsConfig): Promise<boolean> {
 	const enabled = await pickEnabledAgents(ctx, base.enabledAgents);
-	if (enabled === undefined) return notifyCancelled(ctx);
+	if (enabled === undefined) return false;
 
 	let agentModels = keepAgentEntries(base.agentModels, enabled);
 	for (const agentName of enabled) {
 		const choice = await pickAgentModel(ctx, agentName, agentModels[agentName]);
-		if (choice === undefined) return notifyCancelled(ctx);
+		if (choice === undefined) return false;
 		agentModels = applyAgentModelChoice(agentModels, agentName, choice);
 	}
 
 	const injection = await pickInjection(ctx, base.proactiveInjection);
-	if (injection === undefined) return notifyCancelled(ctx);
+	if (injection === undefined) return false;
 	const scope = await pickScope(ctx, base.agentScope);
-	if (scope === undefined) return notifyCancelled(ctx);
+	if (scope === undefined) return false;
 	const maxConcurrency = await pickCount(
 		ctx,
 		"Max sub-agents running at once?",
@@ -302,7 +306,7 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		base.maxConcurrency,
 		DEFAULT_MAX_CONCURRENCY,
 	);
-	if (maxConcurrency === undefined) return notifyCancelled(ctx);
+	if (maxConcurrency === undefined) return false;
 	const maxFixRounds = await pickCount(
 		ctx,
 		"Reviewer worker-fix rounds? (0 = no automatic fixes)",
@@ -310,7 +314,7 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		base.maxFixRounds,
 		DEFAULT_MAX_FIX_ROUNDS,
 	);
-	if (maxFixRounds === undefined) return notifyCancelled(ctx);
+	if (maxFixRounds === undefined) return false;
 	const idleTimeoutSec = await pickCount(
 		ctx,
 		"Idle timeout in seconds? (0 = disabled)",
@@ -318,7 +322,7 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		base.idleTimeoutSec,
 		DEFAULT_IDLE_TIMEOUT_SEC,
 	);
-	if (idleTimeoutSec === undefined) return notifyCancelled(ctx);
+	if (idleTimeoutSec === undefined) return false;
 
 	const next: SubagentsConfig = {
 		enabledAgents: enabled,
@@ -342,114 +346,123 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 	};
 	await saveConfig(next, configPath);
 	ctx.ui.notify(`pi-subagents configured with Auto thinking. Saved to ${configPath}`, "info");
+	return true;
 }
 
 async function updateRuntimeSetting(
 	ctx: ExtensionCommandContext,
 	config: SubagentsConfig,
 ): Promise<SubagentsConfig | undefined> {
-	const choice = await ctx.ui.select("Runtime setting", [
-		"Proactive injection",
-		"Agent scope",
-		"Max concurrency",
-		"Reviewer worker-fix rounds",
-		"Idle timeout",
-	]);
-	if (choice === undefined) return undefined;
-	const next = { ...config };
-	if (choice.startsWith("Proactive")) {
-		const value = await pickInjection(ctx, config.proactiveInjection);
-		if (value === undefined) return undefined;
-		next.proactiveInjection = value;
-	} else if (choice.startsWith("Agent scope")) {
-		const value = await pickScope(ctx, config.agentScope);
-		if (value === undefined) return undefined;
-		next.agentScope = value;
-	} else if (choice.startsWith("Max concurrency")) {
-		const value = await pickCount(ctx, "Max sub-agents running at once?", CONCURRENCY_STEPS, config.maxConcurrency, DEFAULT_MAX_CONCURRENCY);
-		if (value === undefined) return undefined;
-		next.maxConcurrency = value;
-	} else if (choice.startsWith("Reviewer")) {
-		const value = await pickCount(ctx, "Reviewer worker-fix rounds?", FIX_ROUNDS_STEPS, config.maxFixRounds, DEFAULT_MAX_FIX_ROUNDS);
-		if (value === undefined) return undefined;
-		next.maxFixRounds = value;
-	} else {
-		const value = await pickCount(ctx, "Idle timeout in seconds?", IDLE_TIMEOUT_STEPS, config.idleTimeoutSec, DEFAULT_IDLE_TIMEOUT_SEC);
-		if (value === undefined) return undefined;
-		next.idleTimeoutSec = value;
+	while (true) {
+		const choice = await ctx.ui.select("Runtime setting", [
+			"Proactive injection",
+			"Agent scope",
+			"Max concurrency",
+			"Reviewer worker-fix rounds",
+			"Idle timeout",
+		]);
+		if (choice === undefined) return undefined;
+		const next = { ...config };
+		if (choice.startsWith("Proactive")) {
+			const value = await pickInjection(ctx, config.proactiveInjection);
+			if (value === undefined) continue;
+			next.proactiveInjection = value;
+		} else if (choice.startsWith("Agent scope")) {
+			const value = await pickScope(ctx, config.agentScope);
+			if (value === undefined) continue;
+			next.agentScope = value;
+		} else if (choice.startsWith("Max concurrency")) {
+			const value = await pickCount(ctx, "Max sub-agents running at once?", CONCURRENCY_STEPS, config.maxConcurrency, DEFAULT_MAX_CONCURRENCY);
+			if (value === undefined) continue;
+			next.maxConcurrency = value;
+		} else if (choice.startsWith("Reviewer")) {
+			const value = await pickCount(ctx, "Reviewer worker-fix rounds?", FIX_ROUNDS_STEPS, config.maxFixRounds, DEFAULT_MAX_FIX_ROUNDS);
+			if (value === undefined) continue;
+			next.maxFixRounds = value;
+		} else {
+			const value = await pickCount(ctx, "Idle timeout in seconds?", IDLE_TIMEOUT_STEPS, config.idleTimeoutSec, DEFAULT_IDLE_TIMEOUT_SEC);
+			if (value === undefined) continue;
+			next.idleTimeoutSec = value;
+		}
+		return next;
 	}
-	return next;
 }
 
 async function runMenu(ctx: ExtensionCommandContext, configPath: string, config: SubagentsConfig): Promise<void> {
-	const choice = await ctx.ui.select("pi-subagents settings", [
-		"Enable/disable agents",
-		"Configure an agent (model + thinking)",
-		"Runtime settings",
-		"Full re-setup",
-	]);
-	if (choice === undefined) return notifyCancelled(ctx);
-	if (choice.startsWith("Full")) return runFullSetup(ctx, configPath, config);
+	while (true) {
+		const choice = await ctx.ui.select("pi-subagents settings", [
+			"Enable/disable agents",
+			"Configure an agent (model + thinking)",
+			"Runtime settings",
+			"Full re-setup",
+		]);
+		if (choice === undefined) return;
+		if (choice.startsWith("Full")) {
+			if (await runFullSetup(ctx, configPath, config)) return;
+			continue;
+		}
 
-	let next: SubagentsConfig = {
-		...config,
-		agentModels: { ...config.agentModels },
-		agentThinkingLevels: { ...config.agentThinkingLevels },
-	};
-	if (choice.startsWith("Enable")) {
-		const enabled = await pickEnabledAgents(ctx, config.enabledAgents);
-		if (enabled === undefined) return notifyCancelled(ctx);
-		next.enabledAgents = enabled;
-		// Newly enabling cleaner inherits the reviewer's configured model and
-		// thinking level, so the file reflects what cleaner will actually run
-		// instead of silently falling back to the current main model.
-		if (!config.enabledAgents.includes("cleaner") && enabled.includes("cleaner")) {
-			if (!next.agentModels.cleaner && config.agentModels.reviewer) {
-				next.agentModels.cleaner = config.agentModels.reviewer;
-			}
-			if (!next.agentThinkingLevels.cleaner && config.agentThinkingLevels.reviewer) {
-				next.agentThinkingLevels.cleaner = config.agentThinkingLevels.reviewer;
+		let next: SubagentsConfig = {
+			...config,
+			agentModels: { ...config.agentModels },
+			agentThinkingLevels: { ...config.agentThinkingLevels },
+		};
+		if (choice.startsWith("Enable")) {
+			const enabled = await pickEnabledAgents(ctx, config.enabledAgents);
+			if (enabled === undefined) continue;
+			next.enabledAgents = enabled;
+			// Newly enabling cleaner inherits the reviewer's configured model and
+			// thinking level, so the file reflects what cleaner will actually run
+			// instead of silently falling back to the current main model.
+			if (!config.enabledAgents.includes("cleaner") && enabled.includes("cleaner")) {
+				if (!next.agentModels.cleaner && config.agentModels.reviewer) {
+					next.agentModels.cleaner = config.agentModels.reviewer;
+				}
+				if (!next.agentThinkingLevels.cleaner && config.agentThinkingLevels.reviewer) {
+					next.agentThinkingLevels.cleaner = config.agentThinkingLevels.reviewer;
+				}
 			}
-		}
-		// Documenter intentionally follows the faster explorer route. Fresh
-		// installs leave it unselected; enabling it later inherits any explorer
-		// overrides instead of silently choosing a stronger model.
-		if (!config.enabledAgents.includes("documenter") && enabled.includes("documenter")) {
-			if (!next.agentModels.documenter && config.agentModels.explorer) {
-				next.agentModels.documenter = config.agentModels.explorer;
+			// Documenter intentionally follows the faster explorer route. Fresh
+			// installs leave it unselected; enabling it later inherits any explorer
+			// overrides instead of silently choosing a stronger model.
+			if (!config.enabledAgents.includes("documenter") && enabled.includes("documenter")) {
+				if (!next.agentModels.documenter && config.agentModels.explorer) {
+					next.agentModels.documenter = config.agentModels.explorer;
+				}
+				if (!next.agentThinkingLevels.documenter && config.agentThinkingLevels.explorer) {
+					next.agentThinkingLevels.documenter = config.agentThinkingLevels.explorer;
+				}
 			}
-			if (!next.agentThinkingLevels.documenter && config.agentThinkingLevels.explorer) {
-				next.agentThinkingLevels.documenter = config.agentThinkingLevels.explorer;
+			next.agentModels = keepAgentEntries(next.agentModels, enabled);
+			next.agentThinkingLevels = keepAgentEntries(next.agentThinkingLevels, enabled);
+		} else if (choice.startsWith("Configure")) {
+			// Per-agent loop: thinking Esc returns to that agent's model picker;
+			// model Esc returns to the agent picker; agent-picker Esc saves completed
+			// choices and returns to this settings menu.
+			let configuredAny = false;
+			while (true) {
+				const picked = await configureOneAgent(ctx, next);
+				if (!picked) break;
+				configuredAny = true;
+				next.agentModels = applyAgentModelChoice(next.agentModels, picked.name, picked.model);
+				if (picked.strength === AUTO_THINKING) delete next.agentThinkingLevels[picked.name];
+				else next.agentThinkingLevels[picked.name] = picked.strength;
 			}
+			if (!configuredAny) continue;
+			await saveConfig(next, configPath);
+			ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
+			config = next;
+			continue;
+		} else {
+			const updated = await updateRuntimeSetting(ctx, next);
+			if (updated === undefined) continue;
+			next = updated;
 		}
-		next.agentModels = keepAgentEntries(next.agentModels, enabled);
-		next.agentThinkingLevels = keepAgentEntries(next.agentThinkingLevels, enabled);
-	} else if (choice.startsWith("Configure")) {
-		// Per-agent loop: model (+ thinking when the model exposes a choice), then
-		// back to the agent picker so several agents can be set in one pass. Esc
-		// at any step ends the loop; agents already configured in this pass are kept.
-		let configuredAny = false;
-		while (true) {
-			const picked = await configureOneAgent(ctx, next);
-			if (picked === undefined) break;
-			configuredAny = true;
-			next.agentModels = applyAgentModelChoice(next.agentModels, picked.name, picked.model);
-			if (picked.strength === AUTO_THINKING) delete next.agentThinkingLevels[picked.name];
-			else next.agentThinkingLevels[picked.name] = picked.strength;
-		}
-		if (!configuredAny) return notifyCancelled(ctx);
-	} else {
-		const updated = await updateRuntimeSetting(ctx, next);
-		if (updated === undefined) return notifyCancelled(ctx);
-		next = updated;
-	}
 
-	await saveConfig(next, configPath);
-	ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
-}
-
-function notifyCancelled(ctx: ExtensionCommandContext): void {
-	ctx.ui.notify("pi-subagents setup cancelled.", "info");
+		await saveConfig(next, configPath);
+		ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
+		return;
+	}
 }
 
 /** Entry point for the /subagents-setup command. */
@@ -462,7 +475,9 @@ export async function runSetup(ctx: ExtensionCommandContext, configPath: string
 		const exists = await configExists(configPath);
 		const config = await loadConfig(configPath);
 		if (exists) await runMenu(ctx, configPath, config);
-		else await runFullSetup(ctx, configPath, { ...DEFAULT_CONFIG, enabledAgents: [...DEFAULT_ENABLED_AGENTS] });
+		else if (!(await runFullSetup(ctx, configPath, { ...DEFAULT_CONFIG, enabledAgents: [...DEFAULT_ENABLED_AGENTS] }))) {
+			ctx.ui.notify("pi-subagents setup cancelled.", "info");
+		}
 	} catch (error) {
 		ctx.ui.notify(`pi-subagents setup failed: ${errorMessage(error)}`, "error");
 	}

package/src/spawn.ts

@@ -327,7 +327,7 @@ export function getResultOutput(result: SingleResult): string {
 }
 
 export function buildResumePrompt(task: string, reason: string): string {
-	return `You are resuming an earlier sub-agent session after ${reason}. Your earlier work — searches, reads, edits, and reasoning — is preserved in this session's history above; review it before acting. Original task: ${task}. Pick up exactly where you left off and finish it. Do NOT redo searches, reads, or edits you already completed unless a step clearly failed. Continue now.`;
+	return `You are resuming an earlier sub-agent session after ${reason}. Your earlier work — searches, reads, edits, and reasoning — is preserved in this session's history above; review it before acting. Current objective: ${task}. Pick up exactly where you left off and finish it. Do NOT redo searches, reads, or edits you already completed unless a step clearly failed. Continue now.`;
 }
 
 export function buildFallbackResumeReason(fromModel?: string): string {
@@ -351,6 +351,9 @@ export interface RunSingleOptions {
 	sessionId?: string;
 	/** Initial RPC prompt. Kept under the old name to limit caller churn. */
 	stdinText?: string;
+	/** Refresh parent-derived tools immediately before every startup retry and
+	 * selected-to-main fallback process is spawned. */
+	resolveAgentForAttempt?: (agent: AgentConfig) => AgentConfig;
 	signal?: AbortSignal;
 	onLive?: (event: SubagentLiveEvent) => void;
 	makeDetails: (results: SingleResult[]) => SubagentDetails;
@@ -496,7 +499,10 @@ export async function runSingleAgentWithMainFallback(
 			}
 			const start = Date.now();
 			try {
-				lastResult = await runSingleAgent(opts);
+				const attemptOptions = opts.resolveAgentForAttempt
+					? { ...opts, agent: opts.resolveAgentForAttempt(opts.agent) }
+					: opts;
+				lastResult = await runSingleAgent(attemptOptions);
 			} catch (error) {
 				const failed = await dispatchFailure(error);
 				return controlledDisposition(opts, failed) ?? failed;

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;
@@ -1021,9 +1051,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 documentation stages: every child sees the same worktree, then one
+					// lifecycle owner integrates the complete writer+fixes+docs state exactly once.
 					await thread.finalizeIsolation(generation, result);
 					if (!ownsSettlement()) return;
 					if (workflowOutcome && isolation === "worktree") {
@@ -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);