@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/subagent-tool/process.ts

@@ -14,13 +14,23 @@ import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import type { Message } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { extractPreview, isInlineResultsEnabled } from "../_shared/inline-preview.js";
+import {
+	emitWorktreeLifecycleEvent,
+	type WorktreeLifecycleScope,
+} from "../_shared/interop-events.js";
 import { expandFileReferences } from "../file-reference/index.js";
+import { createWorktree, removeWorktree, validateGitRepo } from "../worktree/lifecycle.js";
 import type { AgentConfig, AgentDefaults } from "./agents.js";
-import { computeEffectiveTools, resolveAgentForExecution } from "./agents.js";
+import {
+	computeEffectiveTools,
+	resolveAgentForExecution,
+	resolveEffectiveIsolation,
+} from "./agents.js";
 import { getFinalOutput, type SingleResult, type SubagentDetails } from "./formatting.js";
 import type { RoutingHints } from "./model-router.js";
 import { routeModel } from "./model-router.js";
 import type {
+	IsolationMode,
 	SubagentCompleteDetails,
 	SubagentStartEvent,
 	SubagentStopEvent,
@@ -266,6 +276,100 @@ export function applyBackgroundResultRetention(
 	subagent.historyRetainedMessageCount = compacted.retainedMessageCount;
 }
 
+/** Managed isolation metadata for one subagent invocation. */
+interface SubagentIsolationContext {
+	readonly mode: IsolationMode;
+	readonly repoRoot: string;
+	readonly worktreePath: string;
+}
+
+/**
+ * Provision execution isolation for one subagent invocation.
+ *
+ * @param baseCwd - Base working directory before isolation
+ * @param requestedIsolation - Explicit per-call isolation, if any
+ * @param agent - Resolved agent config
+ * @param defaults - Defaults from _defaults.md
+ * @param lifecycleScope - Lifecycle scope for emitted events
+ * @param lifecycleId - Subagent/task identifier for lifecycle payloads
+ * @param events - Optional event bus for lifecycle hooks
+ * @returns Effective cwd and optional isolation context
+ */
+function provisionIsolation(
+	baseCwd: string,
+	requestedIsolation: IsolationMode | undefined,
+	agent: AgentConfig,
+	defaults: AgentDefaults | undefined,
+	lifecycleScope: WorktreeLifecycleScope,
+	lifecycleId: string,
+	events?: ExtensionAPI["events"]
+): {
+	readonly isolation: SubagentIsolationContext | undefined;
+	readonly workingDirectory: string;
+} {
+	const isolationMode = resolveEffectiveIsolation(
+		requestedIsolation,
+		agent.isolation,
+		defaults?.isolation
+	);
+	if (isolationMode !== "worktree") {
+		return { isolation: undefined, workingDirectory: baseCwd };
+	}
+
+	const repoRoot = validateGitRepo(baseCwd).repoRoot;
+	const created = createWorktree(repoRoot, {
+		agentId: lifecycleScope === "subagent" ? lifecycleId : undefined,
+		id: lifecycleId,
+		scope: "subagent",
+	});
+	const isolation: SubagentIsolationContext = {
+		mode: "worktree",
+		repoRoot,
+		worktreePath: created.worktreePath,
+	};
+
+	if (events) {
+		emitWorktreeLifecycleEvent(events, "worktree_create", {
+			agentId: lifecycleScope === "subagent" ? lifecycleId : undefined,
+			repoRoot,
+			scope: lifecycleScope,
+			timestamp: Date.now(),
+			worktreePath: created.worktreePath,
+		});
+	}
+
+	return {
+		isolation,
+		workingDirectory: created.worktreePath,
+	};
+}
+
+/**
+ * Cleanup worktree isolation for one subagent invocation.
+ *
+ * @param lifecycleScope - Lifecycle scope for emitted events
+ * @param lifecycleId - Subagent/task identifier
+ * @param isolation - Isolation context to cleanup
+ * @param events - Optional event bus for lifecycle hooks
+ */
+function cleanupIsolation(
+	lifecycleScope: WorktreeLifecycleScope,
+	lifecycleId: string,
+	isolation: SubagentIsolationContext | undefined,
+	events?: ExtensionAPI["events"]
+): void {
+	if (!isolation) return;
+	removeWorktree(isolation.worktreePath);
+	if (!events) return;
+	emitWorktreeLifecycleEvent(events, "worktree_remove", {
+		agentId: lifecycleScope === "subagent" ? lifecycleId : undefined,
+		repoRoot: isolation.repoRoot,
+		scope: lifecycleScope,
+		timestamp: Date.now(),
+		worktreePath: isolation.worktreePath,
+	});
+}
+
 /**
  * Write a subagent prompt to a temporary file for the pi subprocess.
  * @param agentName - Agent name (sanitized for filename)
@@ -513,6 +617,7 @@ export type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => vo
  * @param parentModelId - Parent model ID for inheritance
  * @param defaults - Optional agent defaults
  * @param hints - Optional routing hints
+ * @param isolationOverride - Optional per-call isolation override
  * @returns Background subagent ID, error string if model unresolvable, or null if agent not found
  */
 export async function spawnBackgroundSubagent(
@@ -526,11 +631,14 @@ export async function spawnBackgroundSubagent(
 	modelOverride?: string,
 	parentModelId?: string,
 	defaults?: AgentDefaults,
-	hints?: RoutingHints
+	hints?: RoutingHints,
+	isolationOverride?: IsolationMode
 ): Promise<string | null> {
 	const resolved = resolveAgentForExecution(agentName, agents, defaults);
-	const effectiveCwd = cwd ?? defaultCwd;
-	// Route model via fuzzy resolution + auto-routing
+	const id = `bg_${generateId()}`;
+	const requestedCwd = cwd ?? defaultCwd;
+
+	// Route model via fuzzy resolution + auto-routing.
 	const routing = await routeModel(
 		task,
 		modelOverride,
@@ -538,9 +646,29 @@ export async function spawnBackgroundSubagent(
 		parentModelId,
 		resolved.agent.description,
 		hints,
-		effectiveCwd
+		requestedCwd
 	);
 	if (!routing.ok) return routing.error;
+
+	let isolationContext: SubagentIsolationContext | undefined;
+	let effectiveCwd = requestedCwd;
+	try {
+		const provisioned = provisionIsolation(
+			requestedCwd,
+			isolationOverride,
+			resolved.agent,
+			defaults,
+			"subagent",
+			id,
+			piEvents
+		);
+		isolationContext = provisioned.isolation;
+		effectiveCwd = provisioned.workingDirectory;
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return `Failed to create worktree isolation for ${agentName}: ${reason}`;
+	}
+
 	const agent = { ...resolved.agent, model: routing.model.id };
 	const agentSource = resolved.resolution === "ephemeral" ? ("ephemeral" as const) : agent.source;
 
@@ -573,7 +701,14 @@ export async function spawnBackgroundSubagent(
 		args.push("--append-system-prompt", tmpPromptPath);
 	}
 
-	const expandedTask = await expandFileReferences(task, effectiveCwd);
+	let expandedTask: string;
+	try {
+		expandedTask = await expandFileReferences(task, effectiveCwd);
+	} catch (error) {
+		cleanupIsolation("subagent", id, isolationContext, piEvents);
+		const reason = error instanceof Error ? error.message : String(error);
+		return `Failed to expand task references for ${agentName}: ${reason}`;
+	}
 	args.push(`Task: ${expandedTask}`);
 
 	const childEnv: Record<string, string> = { ...process.env, PI_IS_SUBAGENT: "1" } as Record<
@@ -587,14 +722,19 @@ export async function spawnBackgroundSubagent(
 		childEnv.PI_MCP_SERVERS = agent.mcpServers.join(",");
 	}
 
-	const proc = spawn("pi", args, {
-		cwd: effectiveCwd,
-		shell: false,
-		stdio: ["ignore", "pipe", "pipe"],
-		env: childEnv,
-	});
-
-	const id = `bg_${generateId()}`;
+	let proc: ReturnType<typeof spawn>;
+	try {
+		proc = spawn("pi", args, {
+			cwd: effectiveCwd,
+			shell: false,
+			stdio: ["ignore", "pipe", "pipe"],
+			env: childEnv,
+		});
+	} catch (error) {
+		cleanupIsolation("subagent", id, isolationContext, piEvents);
+		const reason = error instanceof Error ? error.message : String(error);
+		return `Failed to spawn background subagent ${agentName}: ${reason}`;
+	}
 
 	// Emit subagent_start event
 	piEvents?.emit("subagent_start", {
@@ -627,6 +767,7 @@ export async function spawnBackgroundSubagent(
 	const bgSubagent: BackgroundSubagent = {
 		id,
 		agent: agentName,
+		isolationMode: isolationContext?.mode,
 		model: agent.model,
 		task,
 		startTime: Date.now(),
@@ -635,12 +776,25 @@ export async function spawnBackgroundSubagent(
 		status: "running",
 		tmpPromptDir,
 		tmpPromptPath,
+		worktreePath: isolationContext?.worktreePath,
 	};
 
 	backgroundSubagents.set(id, bgSubagent);
 	publishSubagentSnapshot(piEvents);
 	startBackgroundSubagentCleanupLoop(piEvents);
 
+	let isolationCleaned = false;
+	const cleanupBackgroundIsolation = () => {
+		if (isolationCleaned) return;
+		isolationCleaned = true;
+		cleanupIsolation("subagent", id, isolationContext, piEvents);
+	};
+
+	if (!proc.stdout || !proc.stderr) {
+		cleanupBackgroundIsolation();
+		return `Failed to spawn background subagent ${agentName}: missing stdio pipes`;
+	}
+
 	// Collect output
 	let buffer = "";
 	let bgTurnCount = 0;
@@ -714,6 +868,11 @@ export async function spawnBackgroundSubagent(
 		result.stderr += data.toString();
 	});
 
+	proc.on("error", (error) => {
+		result.stderr += error.message;
+		cleanupBackgroundIsolation();
+	});
+
 	proc.on("close", (code) => {
 		if (buffer.trim()) {
 			try {
@@ -757,6 +916,7 @@ export async function spawnBackgroundSubagent(
 				/* ignore */
 			}
 
+		cleanupBackgroundIsolation();
 		updateWidget();
 
 		// Post inline result for background subagent completion
@@ -812,6 +972,7 @@ export async function spawnBackgroundSubagent(
  * @param parentModelId - Parent model ID for inheritance
  * @param defaults - Optional agent defaults
  * @param hints - Optional routing hints
+ * @param isolationOverride - Optional per-call isolation override
  * @returns Result from the subagent execution
  */
 export async function runSingleAgent(
@@ -829,10 +990,11 @@ export async function runSingleAgent(
 	modelOverride?: string,
 	parentModelId?: string,
 	defaults?: AgentDefaults,
-	hints?: RoutingHints
+	hints?: RoutingHints,
+	isolationOverride?: IsolationMode
 ): Promise<SingleResult> {
 	const resolved = resolveAgentForExecution(agentName, agents, defaults);
-	const effectiveCwd = cwd ?? defaultCwd;
+	const requestedCwd = cwd ?? defaultCwd;
 	// Route model via fuzzy resolution + auto-routing
 	const routing = await routeModel(
 		task,
@@ -841,7 +1003,7 @@ export async function runSingleAgent(
 		parentModelId,
 		resolved.agent.description,
 		hints,
-		effectiveCwd
+		requestedCwd
 	);
 	if (!routing.ok) {
 		// Return a failed SingleResult so the caller can surface the error
@@ -870,7 +1032,53 @@ export async function runSingleAgent(
 	const agentSource = resolved.resolution === "ephemeral" ? ("ephemeral" as const) : agent.source;
 	const taskId = `fg_${generateId()}`;
 
-	registerForegroundSubagent(taskId, agentName, task, Date.now(), piEvents, agent.model);
+	let isolationContext: SubagentIsolationContext | undefined;
+	let effectiveCwd = requestedCwd;
+	try {
+		const provisioned = provisionIsolation(
+			requestedCwd,
+			isolationOverride,
+			agent,
+			defaults,
+			"subagent",
+			taskId,
+			piEvents
+		);
+		isolationContext = provisioned.isolation;
+		effectiveCwd = provisioned.workingDirectory;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			agent: agentName,
+			agentSource,
+			task,
+			exitCode: 1,
+			messages: [],
+			stderr: message,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+				contextTokens: 0,
+				turns: 0,
+				denials: 0,
+			},
+			errorMessage: message,
+			step,
+		};
+	}
+
+	registerForegroundSubagent(
+		taskId,
+		agentName,
+		task,
+		Date.now(),
+		piEvents,
+		agent.model,
+		isolationContext?.mode
+	);
 
 	// Emit subagent_start event
 	piEvents?.emit("subagent_start", {
@@ -993,7 +1201,7 @@ export async function runSingleAgent(
 		let fgTurnCount = 0;
 		const exitCode = await new Promise<number>((resolve) => {
 			const proc = spawn("pi", args, {
-				cwd: cwd ?? defaultCwd,
+				cwd: effectiveCwd,
 				shell: false,
 				stdio: ["ignore", "pipe", "pipe"],
 				env: fgChildEnv,
@@ -1210,7 +1418,7 @@ export async function runSingleAgent(
 				agents,
 				agentName,
 				task,
-				cwd,
+				effectiveCwd,
 				step,
 				signal,
 				onUpdate,
@@ -1219,8 +1427,10 @@ export async function runSingleAgent(
 				session,
 				nextModel.id,
 				parentModelId,
-				defaults
-				// Clear hints — the explicit model override will be used
+				defaults,
+				undefined,
+				undefined
+				// Clear hints and isolation override — explicit model + existing cwd are used
 			);
 		}
 
@@ -1228,5 +1438,6 @@ export async function runSingleAgent(
 	} finally {
 		completeForegroundSubagent(taskId, piEvents);
 		cleanupTempFiles();
+		cleanupIsolation("subagent", taskId, isolationContext, piEvents);
 	}
 }

package/extensions/subagent-tool/schema.ts

@@ -7,6 +7,14 @@ import { Type } from "@sinclair/typebox";
 
 // ── Parameter Schemas ────────────────────────────────────────────────────────
 
+export const IsolationModeSchema = StringEnum(["worktree"] as const, {
+	description:
+		'Isolation strategy for subagent execution. "worktree" runs the subagent in a temporary detached git worktree.',
+});
+
+/** Isolation mode supported by the subagent tool. */
+export type IsolationMode = "worktree";
+
 export const TaskItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task to delegate to the agent" }),
@@ -14,6 +22,7 @@ export const TaskItem = Type.Object({
 	model: Type.Optional(
 		Type.String({ description: "Model ID to use for this agent (overrides agent default)" })
 	),
+	isolation: Type.Optional(IsolationModeSchema),
 });
 
 export const CentipedeItem = Type.Object({
@@ -25,6 +34,7 @@ export const CentipedeItem = Type.Object({
 	model: Type.Optional(
 		Type.String({ description: "Model ID to use for this step (overrides agent default)" })
 	),
+	isolation: Type.Optional(IsolationModeSchema),
 });
 
 export const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
@@ -58,6 +68,7 @@ export const SubagentParams = Type.Object({
 	cwd: Type.Optional(
 		Type.String({ description: "Working directory for the agent process (single mode)" })
 	),
+	isolation: Type.Optional(IsolationModeSchema),
 	background: Type.Optional(
 		Type.Boolean({
 			description: "Run in background, return immediately. Use subagent_status to check.",

package/extensions/subagent-tool/widget.ts

@@ -16,6 +16,7 @@ import {
 	type InteropSubagentView,
 } from "../_shared/interop-events.js";
 import { getFinalOutput, type SingleResult } from "./formatting.js";
+import type { IsolationMode } from "./schema.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -23,6 +24,7 @@ import { getFinalOutput, type SingleResult } from "./formatting.js";
 export interface RunningSubagent {
 	id: string;
 	agent: string;
+	isolationMode?: IsolationMode;
 	model?: string;
 	task: string;
 	startTime: number;
@@ -37,6 +39,7 @@ export interface BackgroundSubagent {
 	historyOriginalMessageCount?: number;
 	historyRetainedMessageCount?: number;
 	id: string;
+	isolationMode?: IsolationMode;
 	model?: string;
 	process: ReturnType<typeof spawn>;
 	result: SingleResult;
@@ -46,6 +49,7 @@ export interface BackgroundSubagent {
 	task: string;
 	tmpPromptDir?: string;
 	tmpPromptPath?: string;
+	worktreePath?: string;
 }
 
 // ── State ────────────────────────────────────────────────────────────────────
@@ -324,9 +328,18 @@ export function registerForegroundSubagent(
 	task: string,
 	startTime: number,
 	piEvents?: ExtensionAPI["events"],
-	model?: string
+	model?: string,
+	isolationMode?: IsolationMode
 ): void {
-	runningSubagents.set(id, { id, agent, model, task, startTime, status: "running" });
+	runningSubagents.set(id, {
+		id,
+		agent,
+		isolationMode,
+		model,
+		task,
+		startTime,
+		status: "running",
+	});
 	publishSubagentSnapshot(piEvents);
 	startWidgetUpdates();
 }

package/extensions/tasks/__tests__/widget-subagents.test.ts

@@ -273,8 +273,8 @@ afterEach(() => {
 });
 
 describe("tasks widget subagent sections", () => {
-	it("labels a foreground-only snapshot as blocking foreground subagents", async () => {
-		const fixture = await createFixture();
+	it("omits subagent sections for foreground-only snapshots", async () => {
+		const fixture = await createFixture("Keep task list visible");
 		try {
 			emitSubagentsSnapshot(fixture.harness, {
 				foreground: [
@@ -289,7 +289,8 @@ describe("tasks widget subagent sections", () => {
 
 			const lines = renderWidget(fixture.captured, 90);
 			const text = stripAnsi(lines.join("\n"));
-			expect(text).toContain("Foreground Subagents (blocking · 1 running)");
+			expect(text).toContain("Tasks (0/1)");
+			expect(text).not.toContain("Foreground Subagents (blocking");
 			expect(text).not.toContain("Background Subagents (non-blocking");
 			expectLinesWithinWidth(lines, 90);
 		} finally {
@@ -297,6 +298,26 @@ describe("tasks widget subagent sections", () => {
 		}
 	});
 
+	it("does not mount the widget when foreground subagents are the only activity", async () => {
+		const fixture = await createFixture();
+		try {
+			emitSubagentsSnapshot(fixture.harness, {
+				foreground: [
+					createSubagent({
+						agent: "reviewer",
+						id: "fg_only",
+						status: "running",
+						task: "Review changed files",
+					}),
+				],
+			});
+
+			expect(fixture.captured.render).toBeNull();
+		} finally {
+			await shutdownFixture(fixture);
+		}
+	});
+
 	it("labels a background-only snapshot as non-blocking background subagents", async () => {
 		const fixture = await createFixture();
 		try {
@@ -321,7 +342,7 @@ describe("tasks widget subagent sections", () => {
 		}
 	});
 
-	it("renders separate foreground/background sections with distinct per-section counts", async () => {
+	it("renders only the background heading for mixed foreground/background snapshots", async () => {
 		const fixture = await createFixture();
 		try {
 			emitSubagentsSnapshot(fixture.harness, {
@@ -345,8 +366,8 @@ describe("tasks widget subagent sections", () => {
 
 			const lines = renderWidget(fixture.captured, 95);
 			const text = stripAnsi(lines.join("\n"));
-			expect(text).toContain("Foreground Subagents (blocking · 1 running)");
 			expect(text).toContain("Background Subagents (non-blocking · 1 stalled)");
+			expect(text).not.toContain("Foreground Subagents (blocking");
 			expect(text).not.toContain("Subagents (1 running · 1 stalled)");
 			expectLinesWithinWidth(lines, 95);
 		} finally {
@@ -363,10 +384,10 @@ describe("tasks widget subagent sections", () => {
 
 		try {
 			emitSubagentsSnapshot(fixture.harness, {
-				foreground: [
+				background: [
 					createSubagent({
 						agent: "widthprobe",
-						id: "width_fg",
+						id: "width_bg",
 						status: "running",
 						task: longTask,
 					}),

package/extensions/tasks/commands/register-tasks-extension.ts

@@ -233,22 +233,19 @@ export function registerTasksExtension(
 	}
 
 	/**
-	 * Render subagent lines (right column in side-by-side mode, or below tasks in stacked mode).
+	 * Render background subagent lines (right column in side-by-side mode, or below tasks in
+	 * stacked mode).
 	 */
 	function renderSubagentLines(
 		ctx: ExtensionContext,
 		spinner: string,
-		foreground: SubagentView[],
 		background: SubagentView[],
 		maxLineWidth: number
 	): string[] {
-		const activeForeground = foreground.filter(
-			(subagent) => subagent.status === "running" || subagent.status === "stalled"
-		);
 		const activeBackground = background.filter(
 			(subagent) => subagent.status === "running" || subagent.status === "stalled"
 		);
-		if (activeForeground.length === 0 && activeBackground.length === 0) return [];
+		if (activeBackground.length === 0) return [];
 
 		const safeLineWidth = Math.max(1, maxLineWidth);
 
@@ -355,21 +352,14 @@ export function registerTasksExtension(
 		}
 
 		/**
-		 * Append one subagent section (foreground/background) to the output.
+		 * Append the background-subagent section to the output.
 		 * @param lines - Mutable output line sink
-		 * @param sectionTitle - Section title label
-		 * @param modeLabel - Blocking mode label
 		 * @param subagents - Section subagents
 		 */
-		function appendSection(
-			lines: string[],
-			sectionTitle: string,
-			modeLabel: string,
-			subagents: SubagentView[]
-		): void {
+		function appendSection(lines: string[], subagents: SubagentView[]): void {
 			if (subagents.length === 0) return;
 
-			const sectionSummary = `${sectionTitle} (${modeLabel} · ${getStatusSummary(subagents)})`;
+			const sectionSummary = `Background Subagents (non-blocking · ${getStatusSummary(subagents)})`;
 			lines.push(
 				clampLine(`${formatWidgetRole(ctx, "title", sectionSummary)}${getModelSummary(subagents)}`)
 			);
@@ -413,9 +403,7 @@ export function registerTasksExtension(
 		}
 
 		const lines: string[] = [];
-		appendSection(lines, "Foreground Subagents", "blocking", activeForeground);
-		if (activeForeground.length > 0 && activeBackground.length > 0) lines.push("");
-		appendSection(lines, "Background Subagents", "non-blocking", activeBackground);
+		appendSection(lines, activeBackground);
 		return lines;
 	}
 
@@ -608,18 +596,15 @@ export function registerTasksExtension(
 			return;
 		}
 
-		const fgSubagents = foregroundSubagents.filter(
-			(subagent) => subagent.status === "running" || subagent.status === "stalled"
-		);
 		const bgSubagents = backgroundSubagents.filter(
 			(subagent) => subagent.status === "running" || subagent.status === "stalled"
 		);
 		const runningBgTasks = backgroundTasks.filter((task) => task.status === "running");
 
-		const hasSubagents = fgSubagents.length > 0 || bgSubagents.length > 0;
+		const hasBackgroundSubagents = bgSubagents.length > 0;
 		const hasBgTasks = runningBgTasks.length > 0;
 		const hasTeams = activeTeams.length > 0;
-		const hasRightColumn = hasSubagents || hasBgTasks || hasTeams;
+		const hasRightColumn = hasBackgroundSubagents || hasBgTasks || hasTeams;
 		const hasTasks = state.tasks.length > 0;
 
 		if (!(state.visible && (hasTasks || hasRightColumn))) {
@@ -634,7 +619,6 @@ export function registerTasksExtension(
 
 		// Build stable key for structure changes
 		const taskStates = state.tasks.map((t) => `${t.id}:${t.status}`).join(",");
-		const fgIds = fgSubagents.map((s) => `${s.id}:${s.status}`).join(",");
 		const bgIds = bgSubagents.map((s) => `${s.id}:${s.status}`).join(",");
 		const bgTaskIds = runningBgTasks.map((t) => t.id).join(",");
 		const teamKey = activeTeams
@@ -643,7 +627,7 @@ export function registerTasksExtension(
 					`${t.name}:${t.tasks.map((tk) => tk.status).join("")}:${t.teammates.map((m) => m.status).join("")}`
 			)
 			.join("|");
-		const stableKey = `${taskStates}|${fgIds}|${bgIds}|${bgTaskIds}|${teamKey}`;
+		const stableKey = `${taskStates}|${bgIds}|${bgTaskIds}|${teamKey}`;
 
 		// Re-render when structure changes, background items running (for animation),
 		// or in_progress tasks exist (spinner needs to animate every frame).
@@ -678,16 +662,14 @@ export function registerTasksExtension(
 
 					const taskLines = renderTaskLines(ctx, maxTitleLen);
 
-					// Build right column: teams, then subagents, then bg tasks
+					// Build right column: teams, background subagents, then bg tasks
 					const rightLines: string[] = [];
 					if (hasTeams) {
 						rightLines.push(...renderTeamLines(ctx, spinner, activeTeams, maxTeamLen));
 					}
-					if (hasSubagents) {
+					if (hasBackgroundSubagents) {
 						if (rightLines.length > 0) rightLines.push(""); // Spacer
-						rightLines.push(
-							...renderSubagentLines(ctx, spinner, fgSubagents, bgSubagents, rightColumnWidth)
-						);
+						rightLines.push(...renderSubagentLines(ctx, spinner, bgSubagents, rightColumnWidth));
 					}
 					if (hasBgTasks) {
 						if (rightLines.length > 0) rightLines.push(""); // Spacer
@@ -713,9 +695,9 @@ export function registerTasksExtension(
 					lines.push(...renderTeamLines(ctx, spinner, activeTeams, maxTeamLen));
 				}
 
-				if (hasSubagents) {
+				if (hasBackgroundSubagents) {
 					if (lines.length > 0) lines.push(""); // Spacer
-					lines.push(...renderSubagentLines(ctx, spinner, fgSubagents, bgSubagents, width));
+					lines.push(...renderSubagentLines(ctx, spinner, bgSubagents, width));
 				}
 
 				if (hasBgTasks) {