@ferris1225/pi-subagents 4.1.9 → 4.1.11

package/src/prompt.ts

@@ -1,7 +1,9 @@
 /**
- * Builds the authoritative delegation directive injected into the parent model's
- * system prompt via `before_agent_start`. Tool metadata stays intentionally
- * minimal so role/process guidance is not paid for twice.
+ * Builds the delegation directive injected into the parent model's
+ * system prompt via `before_agent_start`. It is paid on every turn, so it
+ * stays a lean routing contract — when a child context pays for itself,
+ * how wide to fan out, and how results come back. Tool metadata stays
+ * intentionally minimal so role/process guidance is not paid for twice.
  */
 
 import type { AgentConfig } from "./agents.ts";
@@ -22,13 +24,10 @@ export function buildDelegationDirective(
 	const hasCleaner = agents.some((agent) => agent.name === "cleaner");
 	const hasDocumenter = agents.some((agent) => agent.name === "documenter");
 	const hasReviewer = agents.some((agent) => agent.name === "reviewer");
-	const hasMultiple = agents.length > 1;
-	const autoFixEnabled = hasWorker;
 	const codeWriterNames = [
 		...(hasWorker ? ["worker"] : []),
 		...(hasCleaner ? ["cleaner"] : []),
 	];
-	const reviewedWriterNames = [...codeWriterNames];
 	const namedWorktreeTargets = [
 		...(hasWorker ? ["worker"] : []),
 		...(hasCleaner ? ["cleaner"] : []),
@@ -39,71 +38,54 @@ export function buildDelegationDirective(
 		: namedWorktreeTargets.length === 1
 			? `${namedWorktreeTargets[0]} or another`
 			: `${namedWorktreeTargets.slice(0, -1).join(", ")}, ${namedWorktreeTargets.at(-1)}, or another`;
-	const managedWriterWorkflowRule = reviewedWriterNames.length === 0
-		? undefined
-		: hasReviewer && hasDocumenter
-			? `Successful top-level ${reviewedWriterNames.join("/")} runs continue through the enabled reviewer gate. Only REVIEW_PASS can authorize documenter, which runs for DOCUMENTATION: NEEDED or a missing marker; the workflow delivers once. Never duplicate stages.`
-			: hasReviewer
-				? `Successful top-level ${reviewedWriterNames.join("/")} runs continue through the enabled reviewer gate and then deliver once; never duplicate the gate.`
-				: hasDocumenter
-					? `With reviewer disabled, successful top-level ${reviewedWriterNames.join("/")} runs use documenter as the conservative final fallback and then deliver once; never duplicate the fallback.`
-					: undefined;
 
 	const dispatchRules = [
-		"Keep small, known-target work in the main thread with direct tools: lookups and focused reads/edits do not justify a child context.",
+		"Route substantive work to sub-agents so your context stays lean for orchestration; inline only trivial work — a one-shot lookup, a single focused read/edit, or an answer already in context.",
 		...(hasExplorer
 			? [
-				"Use `explorer` proactively only for broad or cross-file reconnaissance: mapping unfamiliar code, tracing symbols/dependencies, or finding multi-file references. It is a lightweight retrieval index, never an automatic gate. Re-read load-bearing files before edits or high-risk decisions. Use a stronger model/specialist for dynamic, concurrent, migration, or security analysis.",
+				"Use `explorer` for any broad or multi-file search; it is a retrieval index, never a gate — re-read load-bearing files before acting on its findings.",
 			]
 			: []),
 		...(hasWorker
-			? ["Use `worker` for a self-contained implementation, fix, refactor, or test whose separate context pays for itself—not a small known-target edit."]
+			? ["Use `worker` for a self-contained implementation, fix, refactor, or test whose separate context pays for itself."]
 			: []),
 		...(hasCleaner
 			? [
-				`Use \`cleaner\` only for user-authorized cleanup, removal, simplification, or duplicate-code consolidation; it applies every safe proven in-scope cut without item-by-item approval. Read-only audits and code-health reviews go to ${hasReviewer ? "`reviewer`" : "the main context because `reviewer` is disabled"}. Never dispatch cleaner by PR count or as the pre-commit gate.`,
+				`Use \`cleaner\` only for user-authorized cleanup or deduplication; it applies every safe proven cut without item-by-item approval, and never runs as a pre-commit gate or by PR count.`,
 			]
 			: []),
 		...(hasDocumenter
 			? [
-				`Use \`documenter\` directly only for explicit whole-codebase or standalone documentation/comment work; a top-level documenter delivers without an automatic reviewer.${codeWriterNames.length > 0 ? ` ${codeWriterNames.join("/")} must sync existing docs they directly affect; runtime runs documenter only after REVIEW_PASS with DOCUMENTATION: NEEDED or a missing marker, or as the reviewer-disabled fallback—never dispatch a duplicate.` : ""} It never changes runtime behavior, versions, or release state.`,
+				`Use \`documenter\` directly only for explicit standalone documentation work; a top-level documenter delivers without a gate.${codeWriterNames.length > 0 ? ` The runtime runs the final docs sync after REVIEW_PASS with DOCUMENTATION: NEEDED or a missing marker, or as the reviewer-disabled fallback; writers sync docs they directly affect — never dispatch a duplicate.` : ""}`,
 			]
 			: []),
 		...(hasReviewer
 			? [
-				`Use \`reviewer\` for read-only assessments or a gate.${reviewedWriterNames.length > 0 ? ` Successful ${reviewedWriterNames.join("/")} runs already get one fresh read-only reviewer gate, independent of the writer.` : ""} Advisory output has no VERDICT and cannot authorize follow-up edits${hasDocumenter ? "; gates classify docs separately for the enabled documenter." : "."} Re-verifying your own fixes? Dispatch with \`advisory: true\`: the report returns to you and never starts the auto-fix chain.`,
+				`Use \`reviewer\` for read-only assessments or gates.${codeWriterNames.length > 0 ? ` Successful ${codeWriterNames.join("/")} runs already get one fresh gate and then deliver once.` : ""} Advisory output has no VERDICT and cannot authorize edits; dispatch your own re-verification with \`advisory: true\`.`,
 			]
 			: []),
-		"Brief each child with the complete goal, exact paths, constraints, and expected output; it has no conversation memory.",
-		"Children are leaf processes without delegation tools; use `subagent_control resume` on a parked/settled thread to continue its retained context.",
-		...(hasMultiple
-			? [
-				"Dispatch independent work in one `tasks` array and let the resumed main agent start dependent work only after prerequisites finish.",
-			]
-			: []),
-		`Filesystem isolation: single tasks default to shared${hasWorker ? "; parallel worker tasks default to detached Git worktrees" : ""}${hasCleaner ? "; cleaner defaults to shared" : ""}${hasDocumenter ? "; documenter defaults to shared" : ""}. Request \`isolation: "worktree"\` only for ${worktreeTargets} write-capable agent in a Git repository with committed HEAD. Read-only agents reject it, and setup/integration failure never falls back silently to shared.`,
+		"You own the fan-out breadth: every genuinely independent unit goes in one `tasks` array — there is no per-call cap, and extra tasks queue for the next free process slot. One child owns one coherent deliverable and its files; no two children share a file or re-answer the same question; dependent work starts only after its prerequisite delivers.",
+		"Brief each child with the complete goal, exact paths, constraints, and expected output; it has no conversation memory and cannot delegate. Continue a parked/settled thread with `subagent_control resume`.",
+		`Single tasks share the checkout${hasWorker ? "; parallel workers default to detached Git worktrees" : ""}. Request \`isolation: "worktree"\` only for ${worktreeTargets} write-capable agent in a Git repo with committed HEAD; setup failure never silently falls back to shared.`,
 		"A configured child model/provider failure automatically continues the same retained session on the current main model; do not redispatch. Ordinary tool/task failures stay on the selected model.",
-		"Trust but verify: inspect actual changes/results before reporting completion.",
 	];
 
 	const handoffRules = [
-		"Dispatch ends this turn; results resume the main agent, even mid-turn. Never sleep, poll, or call `subagent_wait` to hold the turn.",
-		"Use `subagent_wait` with explicit `timeoutMs` only when the user asks to wait in-turn; its default lookup is non-blocking.",
-		"Results are already shown. Do not restate, paraphrase, or re-summarize them; add only your conclusion or next action.",
-		"A delivered result does not mean siblings are finished. Before declaring the overall task done, use `subagent_status` to confirm that no runs remain active.",
+		"Dispatch ends this turn; each completion resumes the main agent automatically — never sleep, poll, or call `subagent_wait` to hold the turn.",
+		"Results are already shown; add only your conclusion or next action, never a restatement.",
+		"Before declaring the overall task done, use `subagent_status` to confirm that no runs remain active.",
 	];
 
 	const verificationRules = [
-		"Never report an unrun check as passed; identify unavailable checks and pre-existing failures honestly.",
-		...(managedWriterWorkflowRule ? [managedWriterWorkflowRule] : []),
+		"Never report an unrun check as passed; surface unavailable checks and pre-existing failures honestly, and inspect actual changes before reporting completion.",
 		...(hasReviewer
 			? [
 				...(hasDocumenter
 					? [
-						`A direct REVIEW_PASS with DOCUMENTATION: CLEAN delivers immediately; NEEDED or a missing marker runs one documentation sync. A direct REVIEW_FAIL ${autoFixEnabled ? "keeps bounded worker/reviewer auto-fix, with docs considered only after its terminal REVIEW_PASS." : "cannot start fixes while worker is disabled."}`,
+						"A direct REVIEW_PASS with DOCUMENTATION: CLEAN delivers immediately; NEEDED or a missing marker runs one documentation sync.",
 					]
 					: []),
-				"Resolve every gate finding; do not bypass the auto-fix/re-review cap. A reviewer report without a standalone VERDICT is advisory and cannot trigger writes.",
+				"A REVIEW_FAIL — direct or from a managed gate — returns the findings to you: resolve them yourself, inline or via a worker you brief, without waiting for the user; the runtime never auto-fixes. Ask only for genuinely destructive or scope-changing fixes. Advisory reports cannot trigger writes.",
 				"Use multi-model cross-review only when explicitly requested or for genuinely high-risk security, unsafe/FFI, persistence-migration, or concurrency changes.",
 			]
 			: []),
@@ -113,9 +95,9 @@ export function buildDelegationDirective(
 	return `
 ## Sub-agent delegation (pi-subagents)
 
-The \`subagent\` tool starts isolated Pi child processes and context windows. Completions automatically resume the main agent.
+The \`subagent\` tool runs isolated leaf Pi child processes and context windows; each completion automatically resumes the main agent.
 
-Available agents:
+Agents:
 ${catalog}
 
 Dispatch:

package/src/runtime.ts

@@ -50,7 +50,7 @@ export interface SubagentThread {
 	executionCwd: string;
 	thinkingLevel?: ThinkingLevel;
 	isolation: IsolationMode;
-	/** Report-only reviewer dispatch: verdicts never chain into auto-fix. */
+	/** Report-only reviewer dispatch: verdicts never chain into a managed workflow. */
 	advisoryReview: boolean;
 	worktree?: WorktreeIsolation;
 	state: ThreadState;
@@ -137,8 +137,8 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			// Computing this at delivery (emit) time — not when the item was
 			// pushed — reflects the current monitor state, since finishing runs
 			// are removed from the monitor before their completion is pushed.
-			// Managed-workflow parents remain "running" through documenter,
-			// reviewer, and any fix rounds, so they are included without a special case.
+			// Managed-workflow parents remain "running" through reviewer and
+			// documenter stages, so they are included without a special case.
 			const active = monitor
 				.getRuns()
 				.filter((run) => isRunActiveStatus(run.status))

package/src/setup.ts

@@ -1,25 +1,21 @@
 /**
  * Interactive configuration wizard for /subagents-setup.
  *
- * The UI intentionally has no backup pool or global thinking menu. Each agent
- * gets one optional model override; failures hand directly to the current main
- * model. Thinking defaults to Auto and manual choices are limited to levels Pi
- * reports as supported by the selected model.
+ * The wizard stays one level deep and exposes only what most users touch:
+ * which agents run, the model each runs on, and the delegation directive
+ * toggle. Everything else (per-agent thinking, agent scope, idle timeout,
+ * result lines, notifications) is config-file-only; model failures hand
+ * directly to the current main model, and thinking defaults to capability-
+ * aware Auto.
  */
 
 import { stat } from "node:fs/promises";
-import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
-	AGENT_SCOPE_VALUES,
 	BUILTIN_AGENT_NAMES,
 	DEFAULT_CONFIG,
 	DEFAULT_ENABLED_AGENTS,
-	DEFAULT_IDLE_TIMEOUT_SEC,
-	DEFAULT_THINKING_LEVEL,
-	type AgentScope,
 	type SubagentsConfig,
-	type ThinkingLevel,
 	errorMessage,
 	getConfigPath,
 	loadConfig,
@@ -31,28 +27,9 @@ import {
 	availableModelsInScope,
 	buildModelPickerItems,
 	currentModelRef,
-	findModelByRef,
 	modelRef,
-	resolveThinkingLevel,
-	supportedThinkingLevels,
 } from "./models.ts";
 import { promptSelectMany, promptSelectOne } from "./ui.ts";
-import { discoverAgents } from "./agents.ts";
-
-const AUTO_THINKING = "__auto_thinking__";
-
-function actualAgentThinkingDefault(
-	ctx: ExtensionCommandContext,
-	config: SubagentsConfig,
-	agentName: string,
-): ThinkingLevel {
-	const { agents } = discoverAgents(ctx.cwd, {
-		scope: config.agentScope,
-		enabledNames: config.enabledAgents,
-		projectTrusted: ctx.isProjectTrusted(),
-	});
-	return agents.find((agent) => agent.name === agentName)?.thinking ?? DEFAULT_THINKING_LEVEL;
-}
 
 /** Short, selection-friendly descriptions for the built-in agents. */
 const MODULE_HINTS: Record<string, string> = {
@@ -121,61 +98,6 @@ async function pickAgentModel(
 	return pickConfiguredModel(ctx, `Model for "${agentName}"?`, currentRef, escNote);
 }
 
-const THINKING_LEVEL_HINTS: Record<ThinkingLevel, string> = {
-	off: "no reasoning tokens",
-	minimal: "minimal reasoning",
-	low: "light reasoning",
-	medium: "balanced reasoning",
-	high: "deep reasoning",
-	xhigh: "extra-deep reasoning",
-	max: "strongest reasoning",
-};
-
-function effectiveModelForChoice(
-	ctx: ExtensionCommandContext,
-	choice: string,
-): Model<Api> | undefined {
-	if (choice === CURRENT_MAIN_MODEL) return ctx.model;
-	return findModelByRef(availableModelsInScope(ctx), choice);
-}
-
-/** Auto is the default. Manual rows are exactly the levels Pi exposes for the
- * selected model; unsupported xhigh/max entries never appear. */
-async function pickAgentStrength(
-	ctx: ExtensionCommandContext,
-	agentName: string,
-	model: Model<Api> | undefined,
-	current: ThinkingLevel | undefined,
-	agentDefault: ThinkingLevel,
-	escNote = "cancels this setup pass",
-): Promise<ThinkingLevel | typeof AUTO_THINKING | undefined> {
-	const supported = supportedThinkingLevels(model);
-	const automatic = resolveThinkingLevel(model, agentDefault);
-	// No model metadata, or a non-reasoning model whose only valid value is off:
-	// Auto is already the complete and least surprising choice.
-	if (supported.length <= 1) return AUTO_THINKING;
-
-	const currentEffective = current ? resolveThinkingLevel(model, current) : undefined;
-	const modelName = model ? modelRef(model) : "current main model";
-	const options = [
-		{
-			value: AUTO_THINKING,
-			label: `auto — ${automatic} for ${modelName}${current === undefined ? " (current, recommended)" : " (recommended)"}`,
-		},
-		...supported.map((level) => ({
-			value: level,
-			label: `${level} — ${THINKING_LEVEL_HINTS[level]}${current !== undefined && currentEffective === level ? " (current)" : ""}`,
-		})),
-	];
-	return promptSelectOne(
-		ctx,
-		`Thinking for "${agentName}"?`,
-		`Only levels supported by ${modelName} are shown • Enter selects • Esc ${escNote}`,
-		options,
-		current === undefined ? AUTO_THINKING : currentEffective,
-	) as Promise<ThinkingLevel | typeof AUTO_THINKING | undefined>;
-}
-
 async function pickAgentToConfigure(
 	ctx: ExtensionCommandContext,
 	enabledAgents: readonly string[],
@@ -195,11 +117,10 @@ async function pickAgentToConfigure(
 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. */
+/** Configure agents while preserving the UI back stack: model selection returns
+ * to the agent picker on Esc; agent-picker Esc ends this configuration pass. */
 async function configureOneAgent(
 	ctx: ExtensionCommandContext,
 	config: SubagentsConfig,
@@ -207,27 +128,14 @@ async function configureOneAgent(
 	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 };
-		}
+		const model = await pickAgentModel(
+			ctx,
+			name,
+			config.agentModels[name],
+			"returns to agent selection",
+		);
+		if (model === undefined) continue;
+		return { name, model };
 	}
 }
 
@@ -239,40 +147,6 @@ async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Pr
 	return choice.startsWith("On");
 }
 
-const IDLE_TIMEOUT_STEPS = [0, 30, 60, 90, 120, 180, 300, 600];
-
-async function pickCount(
-	ctx: ExtensionCommandContext,
-	title: string,
-	steps: readonly number[],
-	current: number,
-	defaultValue: number,
-): Promise<number | undefined> {
-	const values = [...new Set([...steps, current])].sort((a, b) => a - b);
-	const options = values.map((value) => {
-		const tags = [value === current ? "current" : "", value === defaultValue ? "default" : ""]
-			.filter(Boolean)
-			.join(", ");
-		return tags ? `${value} (${tags})` : String(value);
-	});
-	const choice = await ctx.ui.select(title, options);
-	return choice === undefined ? undefined : Number.parseInt(choice, 10);
-}
-
-async function pickScope(ctx: ExtensionCommandContext, current: AgentScope): Promise<AgentScope | undefined> {
-	const labels: Record<AgentScope, string> = {
-		user: "user — built-in + ~/.pi/agent/agents (default)",
-		project: "project — built-in + nearest .pi/agents only",
-		both: "both — user agents, overridden by project agents",
-	};
-	const options = AGENT_SCOPE_VALUES.map((scope) =>
-		scope === current ? `${labels[scope]} (current)` : labels[scope],
-	);
-	const choice = await ctx.ui.select("Which agent directories to discover from?", options);
-	if (choice === undefined) return undefined;
-	return AGENT_SCOPE_VALUES.find((scope) => choice.startsWith(scope));
-}
-
 function keepAgentEntries<T>(record: Record<string, T>, enabled: readonly string[]): Record<string, T> {
 	const keep = new Set(enabled);
 	return Object.fromEntries(Object.entries(record).filter(([name]) => keep.has(name)));
@@ -291,16 +165,6 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 
 	const injection = await pickInjection(ctx, base.proactiveInjection);
 	if (injection === undefined) return false;
-	const scope = await pickScope(ctx, base.agentScope);
-	if (scope === undefined) return false;
-	const idleTimeoutSec = await pickCount(
-		ctx,
-		"Idle timeout in seconds? (0 = disabled)",
-		IDLE_TIMEOUT_STEPS,
-		base.idleTimeoutSec,
-		DEFAULT_IDLE_TIMEOUT_SEC,
-	);
-	if (idleTimeoutSec === undefined) return false;
 
 	const next: SubagentsConfig = {
 		enabledAgents: enabled,
@@ -310,49 +174,20 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		notifyOnReviewPass: base.notifyOnReviewPass,
 		maxResultLines: base.maxResultLines,
 		proactiveInjection: injection,
-		agentScope: scope,
-		idleTimeoutSec,
+		agentScope: base.agentScope,
+		idleTimeoutSec: base.idleTimeoutSec,
 	};
 	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> {
-	while (true) {
-		const choice = await ctx.ui.select("Runtime setting", [
-			"Proactive injection",
-			"Agent scope",
-			"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 {
-			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;
-	}
-}
-
 async function runMenu(ctx: ExtensionCommandContext, configPath: string, config: SubagentsConfig): Promise<void> {
 	while (true) {
 		const choice = await ctx.ui.select("pi-subagents settings", [
 			"Enable/disable agents",
-			"Configure an agent (model + thinking)",
-			"Runtime settings",
+			"Configure agent models",
+			"Proactive injection",
 			"Full re-setup",
 		]);
 		if (choice === undefined) return;
@@ -395,17 +230,14 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 			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.
+			// Per-agent loop: 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);
@@ -413,9 +245,9 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 			config = next;
 			continue;
 		} else {
-			const updated = await updateRuntimeSetting(ctx, next);
-			if (updated === undefined) continue;
-			next = updated;
+			const injection = await pickInjection(ctx, next.proactiveInjection);
+			if (injection === undefined) continue;
+			next.proactiveInjection = injection;
 		}
 
 		await saveConfig(next, configPath);

package/src/thread-lifecycle.ts

@@ -46,13 +46,12 @@ import {
 } from "./format.ts";
 import {
 	canStartManagedWorkflow,
-	formatChainSummary,
 	formatManagedWorkflowSummary,
 	getManagedWorkflowPlan,
 	workflowAgentAvailability,
 	type ManagedWorkflowOutcome,
 	type ManagedWorkflowPlan,
-} from "./fixloop.ts";
+} from "./workflow.ts";
 import {
 	availableModelsInScope,
 	currentModelRef,
@@ -289,18 +288,23 @@ export interface ResumeReservation {
 }
 
 /** The dispatcher's full internal entry point; the public tool surface only
- * uses the first five parameters. */
+ * uses the first four parameters. */
+export interface StartBackgroundOptions {
+	/** Resume path only: the thread whose retained context continues. */
+	existingThread?: SubagentThread;
+	appendedObjectiveOnResume?: boolean;
+	environment?: DispatchEnvironment;
+	seed?: SessionSeed;
+	resumeReservation?: ResumeReservation;
+	advisoryReview?: boolean;
+}
+
 export type StartBackgroundInternal = (
 	agentName: string,
 	task: string,
 	cwd: string | undefined,
 	isolation?: IsolationMode,
-	existingThread?: SubagentThread,
-	appendedObjectiveOnResume?: boolean,
-	environment?: DispatchEnvironment,
-	seed?: SessionSeed,
-	resumeReservation?: ResumeReservation,
-	options?: { advisoryReview?: boolean },
+	options?: StartBackgroundOptions,
 ) => Promise<SingleResult>;
 
 export interface ThreadLifecycleDeps {
@@ -398,13 +402,15 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		task: string,
 		cwd: string | undefined,
 		isolation: IsolationMode = "shared",
-		existingThread?: SubagentThread,
-		appendedObjectiveOnResume = false,
-		environment?: DispatchEnvironment,
-		seed?: SessionSeed,
-		resumeReservation?: ResumeReservation,
-		options?: { advisoryReview?: boolean },
+		startOptions: StartBackgroundOptions = {},
 	): Promise<SingleResult> => {
+		const {
+			existingThread,
+			appendedObjectiveOnResume = false,
+			environment,
+			seed,
+			resumeReservation,
+		} = startOptions;
 		if (!runtime.sessionActive) {
 			return failedStartResult(agentName, task, "Parent session shut down before this subagent generation could start.");
 		}
@@ -421,7 +427,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		const resolveLiveAgentTools = (candidate: AgentConfig): AgentConfig =>
 			resolveAgentTools({ ...candidate, tools: discoveredAgent.tools }, runtime.getActiveTools());
 		const resolvedAgent = resolveLiveAgentTools(discoveredAgent);
-		const advisoryReview = options?.advisoryReview ?? existingThread?.advisoryReview ?? false;
+		const advisoryReview = startOptions.advisoryReview ?? existingThread?.advisoryReview ?? false;
 		const agent = agentName === "reviewer"
 			? advisoryReview
 				? withAdvisoryReviewContract(resolvedAgent)
@@ -471,9 +477,6 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 		const priorTask = existingThread?.task;
 		const priorSessionId = seed?.sessionId ?? existingThread?.sessionId;
 		const priorSessionDir = seed?.sessionDir ?? existingThread?.sessionDir;
-		if (existingThread && resumeReservation && !ownsResumeReservation(runtime, existingThread, resumeReservation)) {
-			return failedStartResult(agentName, task, `Run #${existingThread.id} changed while resume was preparing; no new generation was started.`);
-		}
 		const runId = existingThread?.id ?? monitor.addRun(agent.name, task, route.agent.model, thinkingLevel, {
 			isolation,
 			...(worktreeGroup ? { worktreeId: worktreeGroup } : {}),
@@ -532,13 +535,13 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 			// A newly admitted generation owns no output yet. Keeping the prior
 			// generation here would make a queued stop publish stale task,
 			// session metadata as this generation's partial.
-				thread.lastResult = undefined;
-				if (seed?.sessionId && seed.sessionDir) {
-					thread.sessionId = seed.sessionId;
-					thread.sessionDir = seed.sessionDir;
-				}
-				thread.retireOnSettle = false;
-				thread.isolationFailureNotified = false;
+			thread.lastResult = undefined;
+			if (seed?.sessionId && seed.sessionDir) {
+				thread.sessionId = seed.sessionId;
+				thread.sessionDir = seed.sessionDir;
+			}
+			thread.retireOnSettle = false;
+			thread.isolationFailureNotified = false;
 		} else {
 			thread = {
 				id: runId,
@@ -674,23 +677,20 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 				if (thread.retireOnSettle) runtime.retireThreadSession(thread);
 				let workflowOutcome: ManagedWorkflowOutcome | undefined;
 				const workflowPlan = getManagedWorkflowPlan(result, workflowAvailability, thread.advisoryReview);
-				if (workflowPlan && runtime.sessionActive) {
-					// The continuation is runtime-initiated (gate review, auto-fix
-					// rounds, documentation sync): release this generation's
-					// concurrency slot so managed chains never starve manual
-					// dispatches. Cancellation and quiescence guarantees are
-					// unchanged — the task stays abortable and awaited.
-					runtime.backgroundQueue.suspend(generationController);
-					thread.state = "running";
-					// 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,
-						workflowPlan.kind === "auto-fix" ? "auto-fix chain running" : "managed workflow running",
-					);
+					if (workflowPlan && runtime.sessionActive) {
+						// The continuation is runtime-initiated (gate review,
+						// documentation sync): release this generation's
+						// concurrency slot so managed chains never starve manual
+						// dispatches. Cancellation and quiescence guarantees are
+						// unchanged — the task stays abortable and awaited.
+						runtime.backgroundQueue.suspend(generationController);
+						thread.state = "running";
+						// 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, "managed workflow running");
 					workflowOutcome = await runManagedWorkflow({
 						plan: workflowPlan,
 						initialResult: result,
@@ -793,9 +793,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 
 					if (workflowOutcome) {
 						const lastStep = workflowOutcome.steps[workflowOutcome.steps.length - 1]!;
-						let block = workflowOutcome.kind === "auto-fix"
-							? formatChainSummary(workflowOutcome.steps, result)
-							: formatManagedWorkflowSummary(workflowOutcome.steps, result);
+						let block = formatManagedWorkflowSummary(workflowOutcome.steps, result);
 						const finalVerdict = lastStep.result.agent === "reviewer"
 							? reviewVerdict(getResultOutput(lastStep.result))
 							: undefined;
@@ -805,7 +803,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 						}
 						if (modelLevel) block += `\n\n${modelLevelTakeoverNote(result, { runId })}`;
 						runtime.sendCompletionGroup([{
-							agent: `${workflowOutcome.kind === "auto-fix" ? "auto-fix chain" : "managed workflow"} (${result.agent})`,
+							agent: `managed workflow (${result.agent})`,
 							block,
 							triggerTurn: true,
 							usage: sumUsage(workflowOutcome.steps.map((step) => step.result.usage)),
@@ -1197,15 +1195,17 @@ export function installThreadLifecycle(thread: SubagentThread, deps: ThreadLifec
 				nextTask,
 				thread.cwd,
 				thread.isolation,
-				thread,
-				objective !== undefined,
 				{
-					ctx: currentCtx,
-					config: currentConfig,
-					agents: currentAgents,
+					existingThread: thread,
+					appendedObjectiveOnResume: objective !== undefined,
+					environment: {
+						ctx: currentCtx,
+						config: currentConfig,
+						agents: currentAgents,
+					},
+					seed,
+					resumeReservation: reservation,
 				},
-				seed,
-				reservation,
 			);
 			if (pending.exitCode !== -1) {
 				if (clonedSession) {