@tmustier/pi-agent-teams 0.1.2 → 0.2.0

package/extensions/teams/leader.ts

@@ -1,76 +1,45 @@
-import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import { StringEnum } from "@mariozechner/pi-ai";
-import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { SessionManager } from "@mariozechner/pi-coding-agent";
-import { popUnreadMessages, writeToMailbox } from "./mailbox.js";
-import { cleanupTeamDir } from "./cleanup.js";
-import {
-	addTaskDependency,
-	clearTasks,
-	createTask,
-	formatTaskLine,
-	getTask,
-	isTaskBlocked,
-	listTasks,
-	removeTaskDependency,
-	unassignTasksForAgent,
-	updateTask,
-	type TaskStatus,
-	type TeamTask,
-} from "./task-store.js";
+import { writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { TEAM_MAILBOX_NS } from "./protocol.js";
+import { listTasks, unassignTasksForAgent, type TeamTask } from "./task-store.js";
 import { TeammateRpc } from "./teammate-rpc.js";
-import { ensureTeamConfig, loadTeamConfig, setMemberStatus, upsertMember, type TeamConfig, type TeamMember } from "./team-config.js";
+import { ensureTeamConfig, loadTeamConfig, setMemberStatus, upsertMember, type TeamConfig } from "./team-config.js";
 import { getTeamDir, getTeamsRootDir } from "./paths.js";
 import { ensureWorktreeCwd } from "./worktree.js";
+import { ActivityTracker, TranscriptTracker } from "./activity-tracker.js";
+import { openInteractiveWidget } from "./teams-panel.js";
+import { createTeamsWidget } from "./teams-widget.js";
+import { getTeamsStyleFromEnv, type TeamsStyle, formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+import { pollLeaderInbox as pollLeaderInboxImpl } from "./leader-inbox.js";
+import { handleTeamTaskCommand } from "./leader-task-commands.js";
+import { handleTeamPlanCommand } from "./leader-plan-commands.js";
+import { handleTeamSpawnCommand } from "./leader-spawn-command.js";
+import { registerTeamsTool } from "./leader-teams-tool.js";
+import {
+	handleTeamBroadcastCommand,
+	handleTeamDmCommand,
+	handleTeamSendCommand,
+	handleTeamSteerCommand,
+} from "./leader-messaging-commands.js";
+import { handleTeamEnvCommand, handleTeamIdCommand, handleTeamListCommand } from "./leader-info-commands.js";
+import {
+	handleTeamCleanupCommand,
+	handleTeamDelegateCommand,
+	handleTeamKillCommand,
+	handleTeamShutdownCommand,
+	handleTeamStopCommand,
+	handleTeamStyleCommand,
+} from "./leader-lifecycle-commands.js";
 
-const TEAM_MAILBOX_NS = "team";
 
 type ContextMode = "fresh" | "branch";
 type WorkspaceMode = "shared" | "worktree";
 
-const TeamsActionSchema = StringEnum(["delegate"] as const, {
-	description: "Teams tool action. Currently only 'delegate' is supported.",
-	default: "delegate",
-});
-
-const TeamsContextModeSchema = StringEnum(["fresh", "branch"] as const, {
-	description: "How to initialize teammate session context. 'branch' clones the leader session branch.",
-	default: "fresh",
-});
-
-const TeamsWorkspaceModeSchema = StringEnum(["shared", "worktree"] as const, {
-	description: "Workspace isolation mode. 'shared' matches Claude Teams; 'worktree' creates a git worktree per teammate.",
-	default: "shared",
-});
-
-const TeamsDelegateTaskSchema = Type.Object({
-	text: Type.String({ description: "Task / TODO text." }),
-	assignee: Type.Optional(Type.String({ description: "Optional teammate name. If omitted, assigned round-robin." })),
-});
-
-const TeamsToolParams = Type.Object({
-	action: Type.Optional(TeamsActionSchema),
-	tasks: Type.Optional(Type.Array(TeamsDelegateTaskSchema, { description: "Tasks to delegate (action=delegate)." })),
-	teammates: Type.Optional(
-		Type.Array(Type.String(), { description: "Explicit teammate names to use/spawn. If omitted, uses existing or auto-generates." }),
-	),
-	maxTeammates: Type.Optional(
-		Type.Integer({
-			description: "If teammates is omitted and none exist, spawn up to this many.",
-			default: 4,
-			minimum: 1,
-			maximum: 16,
-		}),
-	),
-	contextMode: Type.Optional(TeamsContextModeSchema),
-	workspaceMode: Type.Optional(TeamsWorkspaceModeSchema),
-});
-
 function getTeamsExtensionEntryPath(): string | null {
 	// In dev, teammates won't automatically have this extension unless it is installed or discoverable.
 	// We try to load the same extension entry explicitly (and disable extension discovery to avoid duplicates).
@@ -86,10 +55,6 @@ function getTeamsExtensionEntryPath(): string | null {
 	}
 }
 
-function sanitizeName(name: string): string {
-	return name.replace(/[^a-zA-Z0-9_-]/g, "-");
-}
-
 function shellQuote(v: string): string {
 	return "'" + v.replace(/'/g, `"'"'"'`) + "'";
 }
@@ -97,7 +62,10 @@ function shellQuote(v: string): string {
 function parseAssigneePrefix(text: string): { assignee?: string; text: string } {
 	const m = text.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
 	if (!m) return { text };
-	return { assignee: m[1], text: m[2] };
+	const assignee = m[1];
+	const rest = m[2];
+	if (!assignee || !rest) return { text };
+	return { assignee, text: rest };
 }
 
 function getTeamSessionsDir(teamDir: string): string {
@@ -153,16 +121,6 @@ async function createSessionForTeammate(
 	}
 }
 
-function countTasks(tasks: TeamTask[]): Record<TaskStatus, number> {
-	return tasks.reduce(
-		(acc, t) => {
-			acc[t.status] = (acc[t.status] ?? 0) + 1;
-			return acc;
-		},
-		{ pending: 0, in_progress: 0, completed: 0 } as Record<TaskStatus, number>,
-	);
-}
-
 function taskAssignmentPayload(task: TeamTask, assignedBy: string) {
 	return {
 		type: "task_assignment",
@@ -174,144 +132,29 @@ function taskAssignmentPayload(task: TeamTask, assignedBy: string) {
 	};
 }
 
-function isIdleNotification(
-	text: string,
-): {
-	from: string;
-	timestamp?: string;
-	completedTaskId?: string;
-	completedStatus?: string;
-	failureReason?: string;
-} | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "idle_notification") return null;
-		return {
-			from: typeof obj.from === "string" ? obj.from : "unknown",
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-			completedTaskId: typeof obj.completedTaskId === "string" ? obj.completedTaskId : undefined,
-			completedStatus: typeof obj.completedStatus === "string" ? obj.completedStatus : undefined,
-			failureReason: typeof obj.failureReason === "string" ? obj.failureReason : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isShutdownApproved(
-	text: string,
-): {
-	from: string;
-	requestId: string;
-	timestamp?: string;
-} | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "shutdown_approved") return null;
-		if (typeof obj.requestId !== "string") return null;
-		return {
-			from: typeof obj.from === "string" ? obj.from : "unknown",
-			requestId: obj.requestId,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isShutdownRejected(
-	text: string,
-): {
-	from: string;
-	requestId: string;
-	reason: string;
-	timestamp?: string;
-} | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "shutdown_rejected") return null;
-		if (typeof obj.requestId !== "string") return null;
-		return {
-			from: typeof obj.from === "string" ? obj.from : "unknown",
-			requestId: obj.requestId,
-			reason: typeof obj.reason === "string" ? obj.reason : "",
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isPlanApprovalRequest(
-	text: string,
-): {
-	requestId: string;
-	from: string;
-	plan: string;
-	taskId?: string;
-	timestamp?: string;
-} | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "plan_approval_request") return null;
-		if (typeof obj.requestId !== "string") return null;
-		if (typeof obj.from !== "string") return null;
-		if (typeof obj.plan !== "string") return null;
-		return {
-			requestId: obj.requestId,
-			from: obj.from,
-			plan: obj.plan,
-			taskId: typeof obj.taskId === "string" ? obj.taskId : undefined,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isPeerDmSent(
-	text: string,
-): {
-	from: string;
-	to: string;
-	summary: string;
-	timestamp?: string;
-} | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "peer_dm_sent") return null;
-		if (typeof obj.from !== "string") return null;
-		if (typeof obj.to !== "string") return null;
-		if (typeof obj.summary !== "string") return null;
-		return {
-			from: obj.from,
-			to: obj.to,
-			summary: obj.summary,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
+// Message parsers are shared with the worker implementation.
 export function runLeader(pi: ExtensionAPI): void {
 	const teammates = new Map<string, TeammateRpc>();
-	let currentCtx: ExtensionCommandContext | null = null;
+	const tracker = new ActivityTracker();
+	const transcriptTracker = new TranscriptTracker();
+	const teammateEventUnsubs = new Map<string, () => void>();
+	let currentCtx: ExtensionContext | null = null;
 	let currentTeamId: string | null = null;
 	let tasks: TeamTask[] = [];
 	let teamConfig: TeamConfig | null = null;
 	const pendingPlanApprovals = new Map<string, { requestId: string; name: string; taskId?: string }>();
-	let taskListId: string | null = process.env.PI_TEAMS_TASK_LIST_ID ?? null;
+	// Task list namespace. By default we keep it aligned with the current session id.
+	// (Do NOT read PI_TEAMS_TASK_LIST_ID for the leader; that env var is intended for workers
+	// and can easily be set globally, which makes the leader "lose" its tasks.)
+	let taskListId: string | null = null;
 
 	let refreshTimer: NodeJS.Timeout | null = null;
 	let inboxTimer: NodeJS.Timeout | null = null;
+	let refreshInFlight = false;
+	let inboxInFlight = false;
 	let isStopping = false;
 	let delegateMode = process.env.PI_TEAMS_DELEGATE_MODE === "1";
+	let style: TeamsStyle = getTeamsStyleFromEnv();
 
 	const stopLoops = () => {
 		if (refreshTimer) clearInterval(refreshTimer);
@@ -320,11 +163,20 @@ export function runLeader(pi: ExtensionAPI): void {
 		inboxTimer = null;
 	};
 
-	const stopAllTeammates = async (ctx: ExtensionCommandContext, reason: string) => {
+	const stopAllTeammates = async (ctx: ExtensionContext, reason: string) => {
 		if (teammates.size === 0) return;
 		isStopping = true;
 		try {
 			for (const [name, t] of teammates.entries()) {
+				try {
+					teammateEventUnsubs.get(name)?.();
+				} catch {
+					// ignore
+				}
+				teammateEventUnsubs.delete(name);
+				tracker.reset(name);
+				transcriptTracker.reset(name);
+
 				await t.stop();
 				// Claude-style: unassign non-completed tasks on exit.
 				const teamId = ctx.sessionManager.getSessionId();
@@ -339,6 +191,15 @@ export function runLeader(pi: ExtensionAPI): void {
 		}
 	};
 
+	const widgetFactory = createTeamsWidget({
+		getTeammates: () => teammates,
+		getTracker: () => tracker,
+		getTasks: () => tasks,
+		getTeamConfig: () => teamConfig,
+		getStyle: () => style,
+		isDelegateMode: () => delegateMode,
+	});
+
 	const refreshTasks = async () => {
 		if (!currentCtx || !currentTeamId) return;
 		const teamDir = getTeamDir(currentTeamId);
@@ -352,71 +213,17 @@ export function runLeader(pi: ExtensionAPI): void {
 				teamId: currentTeamId,
 				taskListId: effectiveTaskListId,
 				leadName: "team-lead",
+				style,
 			}));
+		style = teamConfig.style ?? style;
 	};
 
-	const renderWidget = () => {
-		if (!currentCtx || !currentTeamId) return;
-
-		// Hide the widget entirely when there is no active team state.
-		const hasOnlineMembers = (teamConfig?.members ?? []).some(
-			(m) => m.role === "worker" && m.status === "online",
-		);
-		if (teammates.size === 0 && tasks.length === 0 && !hasOnlineMembers) {
-			currentCtx.ui.setWidget("pi-teams", []);
-			return;
-		}
-
-		const lines: string[] = [];
-		lines.push(delegateMode ? "Teams [delegate]" : "Teams");
+	let widgetSuppressed = false;
 
-		const c = countTasks(tasks);
-		lines.push(`  Tasks: pending ${c.pending} • in_progress ${c.in_progress} • completed ${c.completed}`);
-
-		const cfgWorkers = (teamConfig?.members ?? []).filter((m) => m.role === "worker");
-		const cfgByName = new Map<string, TeamMember>();
-		for (const m of cfgWorkers) cfgByName.set(m.name, m);
-
-		const visibleNames = new Set<string>();
-		for (const name of teammates.keys()) visibleNames.add(name);
-		for (const m of cfgWorkers) {
-			if (m.status === "online") visibleNames.add(m.name);
-		}
-		// Fallback: show active task owners even if they haven't been persisted in config yet.
-		for (const t of tasks) {
-			if (t.owner && t.status === "in_progress") visibleNames.add(t.owner);
-		}
-
-		if (visibleNames.size === 0) {
-			lines.push("  (no teammates)  •  /team spawn <name> [fresh|branch] [shared|worktree]");
-			lines.push("  /team task add <text...>  •  /team task list");
-		} else {
-			for (const name of Array.from(visibleNames).sort()) {
-				const rpc = teammates.get(name);
-				const cfg = cfgByName.get(name);
-
-				const active = tasks.find((x) => x.owner === name && x.status === "in_progress");
-				const taskTag = active ? `task:${active.id}` : "";
-
-				if (rpc) {
-					const status = rpc.status.padEnd(9);
-					const tail = rpc.lastAssistantText.trim().split("\n").slice(-1)[0];
-					lines.push(
-						`  ${name}: ${status} ${taskTag ? "• " + taskTag + " " : ""}${tail ? "• " + tail.slice(0, 60) : ""}`,
-					);
-				} else {
-					const status = (cfg?.status ?? "offline").padEnd(9);
-					const seen = cfg?.lastSeenAt ? `• seen ${cfg.lastSeenAt.slice(11, 19)}` : "";
-					lines.push(`  ${name}: ${status} ${taskTag ? "• " + taskTag : ""} ${seen}`.trimEnd());
-				}
-			}
-
-			lines.push("  /team dm <name> <msg...>  •  /team broadcast <msg...>");
-			if (teammates.size > 0) lines.push("  /team send <name> <msg...>  •  /team kill <name>");
-			lines.push("  /team task add <text...>  •  /team task list");
-		}
-
-		currentCtx.ui.setWidget("pi-teams", lines);
+	const renderWidget = () => {
+		if (!currentCtx || widgetSuppressed) return;
+		// Component widget (more informative + styled). Re-setting it is also our "refresh" trigger.
+		currentCtx.ui.setWidget("pi-teams", widgetFactory);
 	};
 
 	type SpawnTeammateResult =
@@ -440,8 +247,11 @@ export function runLeader(pi: ExtensionAPI): void {
 		let workspaceMode: WorkspaceMode = opts.workspaceMode ?? "shared";
 
 		const name = sanitizeName(opts.name);
-		if (!name) return { ok: false, error: "Missing teammate name" };
-		if (teammates.has(name)) return { ok: false, error: `Teammate already exists: ${name}` };
+		if (!name) return { ok: false, error: "Missing comrade name" };
+		if (teammates.has(name)) {
+			const strings = getTeamsStrings(style);
+			return { ok: false, error: `${formatMemberDisplayName(style, name)} already exists (${strings.teamNoun})` };
+		}
 
 		const teamId = ctx.sessionManager.getSessionId();
 		const teamDir = getTeamDir(teamId);
@@ -452,13 +262,34 @@ export function runLeader(pi: ExtensionAPI): void {
 
 		const t = new TeammateRpc(name, sessionFile);
 		teammates.set(name, t);
+		// Track teammate activity for the widget/panel.
+		const unsub = t.onEvent((ev) => {
+			tracker.handleEvent(name, ev);
+			transcriptTracker.handleEvent(name, ev);
+		});
+		teammateEventUnsubs.set(name, unsub);
 		renderWidget();
 
 		// On crash/close, unassign tasks like Claude.
 		const leaderSessionId = teamId;
 		t.onClose((code) => {
+			try {
+				teammateEventUnsubs.get(name)?.();
+			} catch {
+				// ignore
+			}
+			teammateEventUnsubs.delete(name);
+			tracker.reset(name);
+			transcriptTracker.reset(name);
+
 			if (currentCtx?.sessionManager.getSessionId() !== leaderSessionId) return;
-			void unassignTasksForAgent(teamDir, leaderSessionId, name, `Teammate '${name}' exited`).finally(() => {
+			const effectiveTlId = taskListId ?? leaderSessionId;
+			void unassignTasksForAgent(
+				teamDir,
+				effectiveTlId,
+				name,
+				`${formatMemberDisplayName(style, name)} ${getTeamsStrings(style).leftVerb}`,
+			).finally(() => {
 				void refreshTasks().finally(renderWidget);
 			});
 			void setMemberStatus(teamDir, name, "offline", { meta: { exitCode: code ?? undefined } });
@@ -482,10 +313,11 @@ export function runLeader(pi: ExtensionAPI): void {
 			argsForChild.push("--no-extensions", "-e", teamsEntry);
 		}
 
-		argsForChild.push(
-			"--append-system-prompt",
-			`You are teammate '${name}'. You collaborate with a team lead. Prefer working from the shared task list.\n`,
-		);
+		const systemAppend =
+			style === "soviet"
+				? `You are comrade '${name}'. You collaborate with the chairman. Prefer working from the shared task list.\n`
+				: `You are teammate '${name}'. You collaborate with the team leader. Prefer working from the shared task list.\n`;
+		argsForChild.push("--append-system-prompt", systemAppend);
 
 		const autoClaim = (process.env.PI_TEAMS_DEFAULT_AUTO_CLAIM ?? "1") === "1";
 
@@ -506,6 +338,7 @@ export function runLeader(pi: ExtensionAPI): void {
 					PI_TEAMS_TASK_LIST_ID: taskListId ?? teamId,
 					PI_TEAMS_AGENT_NAME: name,
 					PI_TEAMS_LEAD_NAME: "team-lead",
+					PI_TEAMS_STYLE: style,
 					PI_TEAMS_AUTO_CLAIM: autoClaim ? "1" : "0",
 					...(opts.planRequired ? { PI_TEAMS_PLAN_REQUIRED: "1" } : {}),
 				},
@@ -516,7 +349,8 @@ export function runLeader(pi: ExtensionAPI): void {
 			return { ok: false, error: err instanceof Error ? err.message : String(err) };
 		}
 
-		const sessionName = `pi agent teams - comrade ${name}`;
+		const strings = getTeamsStrings(style);
+		const sessionName = `pi agent teams - ${strings.memberTitle.toLowerCase()} ${name}`;
 
 		// Leader-driven session naming (so teammates are easy to spot in /resume).
 		try {
@@ -537,7 +371,7 @@ export function runLeader(pi: ExtensionAPI): void {
 			// ignore
 		}
 
-		await ensureTeamConfig(teamDir, { teamId, taskListId: taskListId ?? teamId, leadName: "team-lead" });
+		await ensureTeamConfig(teamDir, { teamId, taskListId: taskListId ?? teamId, leadName: "team-lead", style });
 		await upsertMember(teamDir, {
 			name,
 			role: "worker",
@@ -556,165 +390,39 @@ export function runLeader(pi: ExtensionAPI): void {
 	const pollLeaderInbox = async () => {
 		if (!currentCtx || !currentTeamId) return;
 		const teamDir = getTeamDir(currentTeamId);
-		const msgs = await popUnreadMessages(teamDir, TEAM_MAILBOX_NS, "team-lead");
-		if (!msgs.length) return;
-
-		for (const m of msgs) {
-			const approved = isShutdownApproved(m.text);
-			if (approved) {
-				const name = sanitizeName(approved.from);
-				const cfg = await ensureTeamConfig(teamDir, {
-					teamId: currentTeamId,
-					taskListId: taskListId ?? currentTeamId,
-					leadName: "team-lead",
-				});
-				if (!cfg.members.some((mm) => mm.name === name)) {
-					await upsertMember(teamDir, { name, role: "worker", status: "offline" });
-				}
-				await setMemberStatus(teamDir, name, "offline", {
-					lastSeenAt: approved.timestamp,
-					meta: {
-						shutdownApprovedRequestId: approved.requestId,
-						shutdownApprovedAt: approved.timestamp ?? new Date().toISOString(),
-					},
-				});
-				currentCtx.ui.notify(`${name} approved shutdown`, "info");
-				continue;
-			}
-
-			const rejected = isShutdownRejected(m.text);
-			if (rejected) {
-				const name = sanitizeName(rejected.from);
-				await setMemberStatus(teamDir, name, "online", {
-					lastSeenAt: rejected.timestamp,
-					meta: {
-						shutdownRejectedAt: rejected.timestamp ?? new Date().toISOString(),
-						shutdownRejectedReason: rejected.reason,
-					},
-				});
-				currentCtx.ui.notify(`${name} rejected shutdown: ${rejected.reason}`, "warning");
-				continue;
-			}
-
-			const planReq = isPlanApprovalRequest(m.text);
-			if (planReq) {
-				const name = sanitizeName(planReq.from);
-				const preview = planReq.plan.length > 500 ? planReq.plan.slice(0, 500) + "..." : planReq.plan;
-				currentCtx.ui.notify(`${name} requests plan approval:\n${preview}`, "info");
-				pendingPlanApprovals.set(name, {
-					requestId: planReq.requestId,
-					name,
-					taskId: planReq.taskId,
-				});
-				continue;
-			}
-
-			const peerDm = isPeerDmSent(m.text);
-			if (peerDm) {
-				currentCtx.ui.notify(`${peerDm.from} → ${peerDm.to}: ${peerDm.summary}`, "info");
-				continue;
-			}
-
-			const idle = isIdleNotification(m.text);
-			if (idle) {
-				const name = sanitizeName(idle.from);
-				if (idle.failureReason) {
-					const cfg = await ensureTeamConfig(teamDir, {
-						teamId: currentTeamId,
-						taskListId: taskListId ?? currentTeamId,
-						leadName: "team-lead",
-					});
-					if (!cfg.members.some((mm) => mm.name === name)) {
-						await upsertMember(teamDir, { name, role: "worker", status: "offline" });
-					}
-					await setMemberStatus(teamDir, name, "offline", {
-						lastSeenAt: idle.timestamp,
-						meta: { offlineReason: idle.failureReason },
-					});
-					currentCtx.ui.notify(`${name} went offline (${idle.failureReason})`, "warning");
-				} else {
-					const desiredSessionName = `pi agent teams - comrade ${name}`;
-
-					const cfg = await ensureTeamConfig(teamDir, {
-						teamId: currentTeamId,
-						taskListId: taskListId ?? currentTeamId,
-						leadName: "team-lead",
-					});
-
-					const member = cfg.members.find((mm) => mm.name === name);
-					const existingSessionName =
-						member?.meta && typeof (member.meta as any).sessionName === "string"
-							? String((member.meta as any).sessionName)
-							: undefined;
-					const shouldSendName = existingSessionName !== desiredSessionName;
-
-					if (!member) {
-						// Manual tmux worker: learn from idle notifications.
-						await upsertMember(teamDir, {
-							name,
-							role: "worker",
-							status: "online",
-							lastSeenAt: idle.timestamp,
-							meta: { sessionName: desiredSessionName },
-						});
-					} else {
-						await setMemberStatus(teamDir, name, "online", {
-							lastSeenAt: idle.timestamp,
-							meta: { sessionName: desiredSessionName },
-						});
-					}
-
-					if (shouldSendName) {
-						try {
-							const ts = new Date().toISOString();
-							await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-								from: "team-lead",
-								text: JSON.stringify({
-									type: "set_session_name",
-									name: desiredSessionName,
-									from: "team-lead",
-									timestamp: ts,
-								}),
-								timestamp: ts,
-							});
-						} catch {
-							// ignore
-						}
-					}
-
-					if (idle.completedTaskId && idle.completedStatus === "failed") {
-						currentCtx.ui.notify(`${name} aborted task #${idle.completedTaskId}`, "warning");
-					} else if (idle.completedTaskId) {
-						currentCtx.ui.notify(`${name} is idle task #${idle.completedTaskId}`, "info");
-					} else {
-						currentCtx.ui.notify(`${name} is idle`, "info");
-					}
-				}
-				continue;
-			}
-
-			currentCtx.ui.notify(`Message from ${m.from}: ${m.text}`, "info");
-		}
+		const effectiveTaskListId = taskListId ?? currentTeamId;
+		await pollLeaderInboxImpl({
+			ctx: currentCtx,
+			teamId: currentTeamId,
+			teamDir,
+			taskListId: effectiveTaskListId,
+			leadName: teamConfig?.leadName ?? "team-lead",
+			style,
+			pendingPlanApprovals,
+		});
 	};
 
 	pi.on("tool_call", (event, _ctx) => {
 		if (!delegateMode) return;
 		const blockedTools = new Set(["bash", "edit", "write"]);
-		if (blockedTools.has(event.name)) {
-			return { block: true, reason: "Delegate mode is active — use teammates for implementation." };
+		if (blockedTools.has(event.toolName)) {
+			return { block: true, reason: "Delegate mode is active - use comrades for implementation." };
 		}
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		currentCtx = ctx as ExtensionCommandContext;
+		currentCtx = ctx;
 		currentTeamId = currentCtx.sessionManager.getSessionId();
-		if (!taskListId) taskListId = currentTeamId;
+		// Keep the task list aligned with the active session. If you want a shared namespace,
+		// use `/team task use <taskListId>` after switching.
+		taskListId = currentTeamId;
 
 		// Claude-style: a persisted team config file.
 		await ensureTeamConfig(getTeamDir(currentTeamId), {
 			teamId: currentTeamId,
 			taskListId: taskListId,
 			leadName: "team-lead",
+			style,
 		});
 
 		await refreshTasks();
@@ -723,30 +431,49 @@ export function runLeader(pi: ExtensionAPI): void {
 		stopLoops();
 		refreshTimer = setInterval(async () => {
 			if (isStopping) return;
-			await refreshTasks();
-			renderWidget();
+			if (refreshInFlight) return;
+			refreshInFlight = true;
+			try {
+				await refreshTasks();
+				renderWidget();
+			} finally {
+				refreshInFlight = false;
+			}
 		}, 1000);
 
 		inboxTimer = setInterval(async () => {
 			if (isStopping) return;
-			await pollLeaderInbox();
+			if (inboxInFlight) return;
+			inboxInFlight = true;
+			try {
+				await pollLeaderInbox();
+			} finally {
+				inboxInFlight = false;
+			}
 		}, 700);
 	});
 
 	pi.on("session_switch", async (_event, ctx) => {
 		if (currentCtx) {
-			await stopAllTeammates(currentCtx, "Stopped due to leader session switch");
+			const strings = getTeamsStrings(style);
+			await stopAllTeammates(
+				currentCtx,
+				style === "soviet" ? `The ${strings.teamNoun} is dissolved — leader moved on` : "Stopped due to session switch",
+			);
 		}
 		stopLoops();
 
-		currentCtx = ctx as ExtensionCommandContext;
+		currentCtx = ctx;
 		currentTeamId = currentCtx.sessionManager.getSessionId();
-		if (!taskListId) taskListId = currentTeamId;
+		// Keep the task list aligned with the active session. If you want a shared namespace,
+		// use `/team task use <taskListId>` after switching.
+		taskListId = currentTeamId;
 
 		await ensureTeamConfig(getTeamDir(currentTeamId), {
 			teamId: currentTeamId,
 			taskListId: taskListId,
 			leadName: "team-lead",
+			style,
 		});
 
 		await refreshTasks();
@@ -755,174 +482,133 @@ export function runLeader(pi: ExtensionAPI): void {
 		// Restart background refresh/poll loops for the new session.
 		refreshTimer = setInterval(async () => {
 			if (isStopping) return;
-			await refreshTasks();
-			renderWidget();
+			if (refreshInFlight) return;
+			refreshInFlight = true;
+			try {
+				await refreshTasks();
+				renderWidget();
+			} finally {
+				refreshInFlight = false;
+			}
 		}, 1000);
 
 		inboxTimer = setInterval(async () => {
 			if (isStopping) return;
-			await pollLeaderInbox();
+			if (inboxInFlight) return;
+			inboxInFlight = true;
+			try {
+				await pollLeaderInbox();
+			} finally {
+				inboxInFlight = false;
+			}
 		}, 700);
 	});
 
 	pi.on("session_shutdown", async () => {
 		if (!currentCtx) return;
 		stopLoops();
-		await stopAllTeammates(currentCtx, "Stopped due to leader shutdown");
+		const strings = getTeamsStrings(style);
+		await stopAllTeammates(currentCtx, style === "soviet" ? `The ${strings.teamNoun} is over` : "Stopped due to leader shutdown");
 	});
 
-	pi.registerTool({
-		name: "teams",
-		label: "Teams",
-		description: [
-			"Spawn teammates and delegate tasks using Claude-like primitives (task list + mailbox).",
-			"Defaults match Claude Teams: shared workspace, explicit assignment.",
-			"Options: workspaceMode=worktree (git worktrees), contextMode=branch (clone leader session context).",
-		].join(" "),
-		parameters: TeamsToolParams,
-
-		async execute(_toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<any>> {
-			const action = (params as any).action ?? "delegate";
-			if (action !== "delegate") {
-				return {
-					content: [{ type: "text", text: `Unsupported action: ${String(action)}` }],
-					details: { action },
-				};
-			}
-
-			const inputTasks = (params as any).tasks;
-			if (!Array.isArray(inputTasks) || inputTasks.length === 0) {
-				return {
-					content: [
-						{ type: "text", text: "No tasks provided. Provide tasks: [{text, assignee?}, ...]" },
-					],
-					details: { action },
-				};
-			}
-
-			const contextMode: ContextMode = (params as any).contextMode === "branch" ? "branch" : "fresh";
-			const requestedWorkspaceMode: WorkspaceMode =
-				(params as any).workspaceMode === "worktree" ? "worktree" : "shared";
-
-			const teamId = ctx.sessionManager.getSessionId();
-			const teamDir = getTeamDir(teamId);
-			await ensureTeamConfig(teamDir, { teamId, taskListId: taskListId ?? teamId, leadName: "team-lead" });
-
-			let teammateNames: string[] = [];
-			const explicit = (params as any).teammates;
-			if (Array.isArray(explicit) && explicit.length) {
-				teammateNames = explicit.map((n: any) => sanitizeName(String(n))).filter(Boolean);
-			}
-
-			if (teammateNames.length === 0 && teammates.size > 0) {
-				teammateNames = Array.from(teammates.keys());
-			}
-
-			if (teammateNames.length === 0) {
-				const maxTeammates = Math.max(1, Math.min(16, Number((params as any).maxTeammates ?? 4) || 4));
-				const count = Math.min(maxTeammates, inputTasks.length);
-				teammateNames = Array.from({ length: count }, (_, i) => `agent${i + 1}`);
-			}
-
-			const spawned: string[] = [];
-			const warnings: string[] = [];
-
-			for (const name of teammateNames) {
-				if (signal?.aborted) break;
-				if (teammates.has(name)) continue;
-				const res = await spawnTeammate(ctx, {
-					name,
-					mode: contextMode,
-					workspaceMode: requestedWorkspaceMode,
-				});
-				if (!res.ok) {
-					warnings.push(`Failed to spawn '${name}': ${res.error}`);
-					continue;
-				}
-				spawned.push(res.name);
-				warnings.push(...res.warnings);
-			}
-
-			// Assign tasks (explicit assignee wins; otherwise round-robin)
-			const assignments: Array<{ taskId: string; assignee: string; subject: string }> = [];
-			let rr = 0;
-			for (const t of inputTasks) {
-				if (signal?.aborted) break;
-
-				const text = typeof t?.text === "string" ? t.text.trim() : "";
-				if (!text) {
-					warnings.push("Skipping empty task");
-					continue;
-				}
-
-				const explicitAssignee = typeof t?.assignee === "string" ? sanitizeName(t.assignee) : undefined;
-				const assignee = explicitAssignee ?? teammateNames[rr++ % teammateNames.length];
-				if (!assignee) {
-					warnings.push(`No assignee available for task: ${text.slice(0, 60)}`);
-					continue;
-				}
+	registerTeamsTool({
+		pi,
+		teammates,
+		spawnTeammate,
+		getTaskListId: () => taskListId,
+		taskAssignmentPayload,
+		refreshTasks,
+		renderWidget,
+	});
 
-				// Ensure assignee exists
-				if (!teammates.has(assignee)) {
-					const res = await spawnTeammate(ctx, {
-						name: assignee,
-						mode: contextMode,
-						workspaceMode: requestedWorkspaceMode,
-					});
-					if (res.ok) {
-						spawned.push(res.name);
-						warnings.push(...res.warnings);
-					} else {
-						warnings.push(`Failed to spawn assignee '${assignee}': ${res.error}`);
-						continue;
-					}
+	const openWidget = async (ctx: ExtensionCommandContext) => {
+		const teamId = ctx.sessionManager.getSessionId();
+		const teamDir = getTeamDir(teamId);
+		const effectiveTlId = taskListId ?? teamId;
+		const leadName = teamConfig?.leadName ?? "team-lead";
+		const strings = getTeamsStrings(style);
+
+		await openInteractiveWidget(ctx, {
+			getTeammates: () => teammates,
+			getTracker: () => tracker,
+			getTranscript: (n: string) => transcriptTracker.get(n),
+			getTasks: () => tasks,
+			getTeamConfig: () => teamConfig,
+			getStyle: () => style,
+			isDelegateMode: () => delegateMode,
+			async sendMessage(name: string, message: string) {
+				const rpc = teammates.get(name);
+				if (rpc) {
+					if (rpc.status === "streaming") await rpc.followUp(message);
+					else await rpc.prompt(message);
+					return;
 				}
 
-				const description = text;
-				const subject = description.split("\n")[0].slice(0, 120);
-				const effectiveTlId = taskListId ?? teamId;
-				const task = await createTask(teamDir, effectiveTlId, { subject, description, owner: assignee });
-
-				await writeToMailbox(teamDir, effectiveTlId, assignee, {
-					from: "team-lead",
-					text: JSON.stringify(taskAssignmentPayload(task, "team-lead")),
+				await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+					from: leadName,
+					text: message,
 					timestamp: new Date().toISOString(),
 				});
+			},
+			abortComrade(name: string) {
+				const rpc = teammates.get(name);
+				if (rpc) void rpc.abort();
+			},
+			killComrade(name: string) {
+				const rpc = teammates.get(name);
+				if (!rpc) return;
+
+				void rpc.stop();
+				teammates.delete(name);
+
+				const displayName = formatMemberDisplayName(style, name);
+				void unassignTasksForAgent(teamDir, effectiveTlId, name, `${displayName} ${strings.killedVerb}`);
+				void setMemberStatus(teamDir, name, "offline", { meta: { killedAt: new Date().toISOString() } });
+				void refreshTasks();
+			},
+			suppressWidget() {
+				widgetSuppressed = true;
+				ctx.ui.setWidget("pi-teams", undefined);
+			},
+			restoreWidget() {
+				widgetSuppressed = false;
+				renderWidget();
+			},
+		});
+	};
 
-				assignments.push({ taskId: task.id, assignee, subject });
-			}
+	pi.registerCommand("tw", {
+		description: "Teams: open interactive widget panel",
+		handler: async (_args, ctx) => {
+			currentCtx = ctx;
+			currentTeamId = ctx.sessionManager.getSessionId();
+			await openWidget(ctx);
+		},
+	});
 
-			// Best-effort widget refresh
-			void refreshTasks().finally(renderWidget);
+	pi.registerCommand("team-widget", {
+		description: "Teams: open interactive widget panel (alias for /team widget)",
+		handler: async (_args, ctx) => {
+			currentCtx = ctx;
+			currentTeamId = ctx.sessionManager.getSessionId();
+			await openWidget(ctx);
+		},
+	});
 
-			const lines: string[] = [];
-			if (spawned.length) lines.push(`Spawned: ${spawned.join(", ")}`);
-			lines.push(`Delegated ${assignments.length} task(s):`);
-			for (const a of assignments) {
-				lines.push(`- #${a.taskId} → ${a.assignee}: ${a.subject}`);
-			}
-			if (warnings.length) {
-				lines.push("\nWarnings:");
-				for (const w of warnings) lines.push(`- ${w}`);
+	pi.registerCommand("swarm", {
+		description: "Start a team of agents to work on a task",
+		handler: async (args, _ctx) => {
+			const task = args.trim();
+			if (!task) {
+				pi.sendUserMessage("Use your /team commands to spawn a team of agents and coordinate them to complete my next request. Ask me what I'd like done.");
+				return;
 			}
-
-			return {
-				content: [{ type: "text", text: lines.join("\n") }],
-				details: {
-					action,
-					teamId,
-					contextMode,
-					workspaceMode: requestedWorkspaceMode,
-					spawned,
-					assignments,
-					warnings,
-				},
-			};
+			pi.sendUserMessage(`Use your /team commands to spawn a team of agents and coordinate them to complete this task:\n\n${task}`);
 		},
 	});
 
 	pi.registerCommand("team", {
-		description: "Teams: spawn teammates + coordinate via Claude-like task list",
+		description: "Teams: spawn comrades + coordinate via Claude-like task list",
 		handler: async (args, ctx) => {
 			currentCtx = ctx;
 			currentTeamId = ctx.sessionManager.getSessionId();
@@ -935,6 +621,7 @@ export function runLeader(pi: ExtensionAPI): void {
 						"  /team id",
 						"  /team env <name>",
 						"  /team spawn <name> [fresh|branch] [shared|worktree] [plan]",
+						"  /team panel",
 						"  /team send <name> <msg...>",
 						"  /team dm <name> <msg...>",
 						"  /team broadcast <msg...>",
@@ -965,920 +652,207 @@ export function runLeader(pi: ExtensionAPI): void {
 
 			switch (sub) {
 				case "list": {
-					await refreshTasks();
-
-					const cfgWorkers = (teamConfig?.members ?? []).filter((m) => m.role === "worker");
-					const cfgByName = new Map<string, TeamMember>();
-					for (const m of cfgWorkers) cfgByName.set(m.name, m);
-
-					const names = new Set<string>();
-					for (const name of teammates.keys()) names.add(name);
-					for (const name of cfgByName.keys()) names.add(name);
-
-					if (names.size === 0) {
-						ctx.ui.notify("No teammates", "info");
-						renderWidget();
-						return;
-					}
-
-					const lines: string[] = [];
-					for (const name of Array.from(names).sort()) {
-						const rpc = teammates.get(name);
-						const cfg = cfgByName.get(name);
-						const status = rpc ? rpc.status : cfg?.status ?? "offline";
-						const kind = rpc ? "rpc" : cfg ? "manual" : "unknown";
-						lines.push(`${name}: ${status} (${kind})`);
-					}
-
-					ctx.ui.notify(lines.join("\n"), "info");
-					renderWidget();
+					await handleTeamListCommand({
+						ctx,
+						teammates,
+						getTeamConfig: () => teamConfig,
+						style,
+						refreshTasks,
+						renderWidget,
+					});
 					return;
 				}
 
 				case "id": {
-					const teamId = ctx.sessionManager.getSessionId();
-					const effectiveTlId = taskListId ?? teamId;
-					const leadName = "team-lead";
-					const teamsRoot = getTeamsRootDir();
-					const teamDir = getTeamDir(teamId);
-
-					ctx.ui.notify(
-						[
-							`teamId: ${teamId}`,
-							`taskListId: ${effectiveTlId}`,
-							`leadName: ${leadName}`,
-							`teamsRoot: ${teamsRoot}`,
-							`teamDir: ${teamDir}`,
-						].join("\n"),
-						"info",
-					);
+					await handleTeamIdCommand({
+						ctx,
+						taskListId,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+					});
 					return;
 				}
 
 				case "env": {
-					const nameRaw = rest[0];
-					if (!nameRaw) {
-						ctx.ui.notify("Usage: /team env <name>", "error");
-						return;
-					}
-
-					const name = sanitizeName(nameRaw);
-					const teamId = ctx.sessionManager.getSessionId();
-					const effectiveTlId = taskListId ?? teamId;
-					const leadName = "team-lead";
-					const teamsRoot = getTeamsRootDir();
-					const teamDir = getTeamDir(teamId);
-					const autoClaim = (process.env.PI_TEAMS_DEFAULT_AUTO_CLAIM ?? "1") === "1" ? "1" : "0";
-
-					const teamsEntry = getTeamsExtensionEntryPath();
-					const piCmd = teamsEntry ? `pi --no-extensions -e ${shellQuote(teamsEntry)}` : "pi";
-
-					const env: Record<string, string> = {
-						PI_TEAMS_ROOT_DIR: teamsRoot,
-						PI_TEAMS_WORKER: "1",
-						PI_TEAMS_TEAM_ID: teamId,
-						PI_TEAMS_TASK_LIST_ID: effectiveTlId,
-						PI_TEAMS_AGENT_NAME: name,
-						PI_TEAMS_LEAD_NAME: leadName,
-						PI_TEAMS_AUTO_CLAIM: autoClaim,
-					};
-
-					const exportLines = Object.entries(env)
-						.map(([k, v]) => `export ${k}=${shellQuote(v)}`)
-						.join("\n");
-
-					const oneLiner = Object.entries(env)
-						.map(([k, v]) => `${k}=${shellQuote(v)}`)
-						.join(" ")
-						.concat(` ${piCmd}`);
-
-					ctx.ui.notify(
-						[
-							`teamId: ${teamId}`,
-							`taskListId: ${effectiveTlId}`,
-							`leadName: ${leadName}`,
-							`teamsRoot: ${teamsRoot}`,
-							`teamDir: ${teamDir}`,
-							"",
-							"Env (copy/paste):",
-							exportLines,
-							"",
-							"Run:",
-							oneLiner,
-						].join("\n"),
-						"info",
-					);
+					await handleTeamEnvCommand({
+						ctx,
+						rest,
+						taskListId,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						getTeamsExtensionEntryPath,
+						shellQuote,
+					});
 					return;
 				}
 
 				case "cleanup": {
-					const flags = rest.filter((a) => a.startsWith("--"));
-					const argsOnly = rest.filter((a) => !a.startsWith("--"));
-					const force = flags.includes("--force");
-
-					const unknownFlags = flags.filter((f) => f !== "--force");
-					if (unknownFlags.length) {
-						ctx.ui.notify(`Unknown flag(s): ${unknownFlags.join(", ")}`, "error");
-						return;
-					}
-					if (argsOnly.length) {
-						ctx.ui.notify("Usage: /team cleanup [--force]", "error");
-						return;
-					}
-
-					const teamId = ctx.sessionManager.getSessionId();
-					const teamsRoot = getTeamsRootDir();
-					const teamDir = getTeamDir(teamId);
-
-					if (!force && teammates.size > 0) {
-						ctx.ui.notify(
-							`Refusing to cleanup while ${teammates.size} RPC teammate(s) are running. Stop them first or use --force.`,
-							"error",
-						);
-						return;
-					}
-
-					await refreshTasks();
-					const inProgress = tasks.filter((t) => t.status === "in_progress");
-					if (!force && inProgress.length > 0) {
-						ctx.ui.notify(
-							`Refusing to cleanup with ${inProgress.length} in_progress task(s). Complete/unassign them first or use --force.`,
-							"error",
-						);
-						return;
-					}
-
-					if (!force) {
-						// Only prompt in interactive TTY mode. In RPC mode, confirm() would require
-						// the host to send extension_ui_response messages.
-						if (process.stdout.isTTY && process.stdin.isTTY) {
-							const ok = await ctx.ui.confirm(
-								"Cleanup team",
-								[
-									"Delete ALL team artifacts for this session?",
-									"",
-									`teamId: ${teamId}`,
-									`teamDir: ${teamDir}`,
-									`tasks: ${tasks.length} (in_progress: ${inProgress.length})`,
-								].join("\n"),
-							);
-							if (!ok) return;
-						} else {
-							ctx.ui.notify("Refusing to cleanup in non-interactive mode without --force", "error");
-							return;
-						}
-					}
-
-					try {
-						await cleanupTeamDir(teamsRoot, teamDir);
-					} catch (err) {
-						ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
-						return;
-					}
-
-					ctx.ui.notify(`Cleaned up team directory: ${teamDir}`, "warning");
-					await refreshTasks();
-					renderWidget();
+					await handleTeamCleanupCommand({
+						ctx,
+						rest,
+						teammates,
+						refreshTasks,
+						getTasks: () => tasks,
+						renderWidget,
+						style,
+					});
 					return;
 				}
 
 				case "delegate": {
-					const arg = rest[0];
-					if (arg === "on") delegateMode = true;
-					else if (arg === "off") delegateMode = false;
-					else delegateMode = !delegateMode;
-					ctx.ui.notify(`Delegate mode ${delegateMode ? "ON" : "OFF"}`, "info");
-					renderWidget();
+					await handleTeamDelegateCommand({
+						ctx,
+						rest,
+						getDelegateMode: () => delegateMode,
+						setDelegateMode: (next) => {
+							delegateMode = next;
+						},
+						renderWidget,
+					});
 					return;
 				}
 
 				case "shutdown": {
-					const nameRaw = rest[0];
-
-					// /team shutdown <name> [reason...] = request graceful worker shutdown via mailbox
-					if (nameRaw) {
-						const name = sanitizeName(nameRaw);
-						const reason = rest.slice(1).join(" ").trim() || undefined;
-
-						const teamId = ctx.sessionManager.getSessionId();
-						const teamDir = getTeamDir(teamId);
-
-						const requestId = randomUUID();
-						const ts = new Date().toISOString();
-						const payload: any = {
-							type: "shutdown_request",
-							requestId,
-							from: "team-lead",
-							timestamp: ts,
-						};
-						if (reason) payload.reason = reason;
-
-						await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-							from: "team-lead",
-							text: JSON.stringify(payload),
-							timestamp: ts,
-						});
-
-						// Best-effort: record in member metadata (if present).
-						void setMemberStatus(teamDir, name, "online", {
-							meta: {
-								shutdownRequestedAt: ts,
-								shutdownRequestId: requestId,
-								...(reason ? { shutdownReason: reason } : {}),
-							},
-						});
-
-						ctx.ui.notify(`Shutdown requested for ${name}`, "info");
-
-						// Optional fallback for RPC teammates: force stop if it doesn't exit.
-						const t = teammates.get(name);
-						if (t) {
-							setTimeout(() => {
-								if (currentCtx?.sessionManager.getSessionId() !== teamId) return;
-								if (t.status === "stopped" || t.status === "error") return;
-								void (async () => {
-									try {
-										await t.stop();
-										await setMemberStatus(teamDir, name, "offline", {
-											meta: { shutdownFallback: true, shutdownRequestId: requestId },
-										});
-										currentCtx?.ui.notify(`Shutdown timeout; killed ${name}`, "warning");
-									} catch {
-										// ignore
-									}
-								})();
-							}, 10_000);
-						}
-
-						return;
-					}
-
-					// /team shutdown (no args) = shutdown leader + all teammates
-					// Only prompt in interactive TTY mode. In RPC mode, confirm() would require
-					// the host to send extension_ui_response messages.
-					if (process.stdout.isTTY && process.stdin.isTTY) {
-						const ok = await ctx.ui.confirm("Shutdown", "Exit pi and stop all teammates?");
-						if (!ok) return;
-					}
-					// In RPC mode, shutdown is deferred until the next input line is handled.
-					// Teammates are stopped in the session_shutdown handler.
-					ctx.ui.notify("Shutdown requested", "info");
-					ctx.shutdown();
+					await handleTeamShutdownCommand({
+						ctx,
+						rest,
+						teammates,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						getCurrentCtx: () => currentCtx,
+					});
 					return;
 				}
 
 				case "spawn": {
-					const nameRaw = rest[0];
-					const spawnArgs = rest.slice(1);
-
-					let mode: ContextMode = "fresh";
-					let workspaceMode: WorkspaceMode = "shared";
-					let planRequired = false;
-					for (const a of spawnArgs) {
-						if (a === "fresh" || a === "branch") mode = a;
-						if (a === "shared" || a === "worktree") workspaceMode = a;
-						if (a === "plan") planRequired = true;
-					}
-
-					if (!nameRaw) {
-						ctx.ui.notify("Usage: /team spawn <name> [fresh|branch] [shared|worktree] [plan]", "error");
-						return;
-					}
-
-					const res = await spawnTeammate(ctx, { name: nameRaw, mode, workspaceMode, planRequired });
-					if (!res.ok) {
-						ctx.ui.notify(res.error, "error");
-						return;
-					}
-
-					for (const w of res.warnings) ctx.ui.notify(w, "warning");
-					ctx.ui.notify(
-						`Spawned teammate '${res.name}' (${res.mode}${res.note ? ", " + res.note : ""} • ${res.workspaceMode})`,
-						"info",
-					);
+					await handleTeamSpawnCommand({ ctx, rest, teammates, style, spawnTeammate });
+					return;
+				}
+
+				case "style": {
+					const teamId = ctx.sessionManager.getSessionId();
+					const teamDir = getTeamDir(teamId);
+					await handleTeamStyleCommand({
+						ctx,
+						rest,
+						teamDir,
+						getStyle: () => style,
+						setStyle: (next) => {
+							style = next;
+						},
+						refreshTasks,
+						renderWidget,
+					});
+					return;
+				}
+
+				case "panel":
+				case "widget": {
+					await openWidget(ctx);
 					return;
 				}
 
 				case "send": {
-					const nameRaw = rest[0];
-					const msg = rest.slice(1).join(" ").trim();
-					if (!nameRaw || !msg) {
-						ctx.ui.notify("Usage: /team send <name> <msg...>", "error");
-						return;
-					}
-					const name = sanitizeName(nameRaw);
-					const t = teammates.get(name);
-					if (!t) {
-						ctx.ui.notify(`Unknown teammate: ${name}`, "error");
-						return;
-					}
-					if (t.status === "streaming") await t.followUp(msg);
-					else await t.prompt(msg);
-					ctx.ui.notify(`Sent to ${name}`, "info");
-					renderWidget();
+					await handleTeamSendCommand({
+						ctx,
+						rest,
+						teammates,
+						style,
+						renderWidget,
+					});
 					return;
 				}
 
 				case "steer": {
-					const nameRaw = rest[0];
-					const msg = rest.slice(1).join(" ").trim();
-					if (!nameRaw || !msg) {
-						ctx.ui.notify("Usage: /team steer <name> <msg...>", "error");
-						return;
-					}
-					const name = sanitizeName(nameRaw);
-					const t = teammates.get(name);
-					if (!t) {
-						ctx.ui.notify(`Unknown teammate: ${name}`, "error");
-						return;
-					}
-					await t.steer(msg);
-					ctx.ui.notify(`Steering sent to ${name}`, "info");
-					renderWidget();
+					await handleTeamSteerCommand({
+						ctx,
+						rest,
+						teammates,
+						style,
+						renderWidget,
+					});
 					return;
 				}
 
 				case "stop": {
-					const nameRaw = rest[0];
-					const reason = rest.slice(1).join(" ").trim();
-					if (!nameRaw) {
-						ctx.ui.notify("Usage: /team stop <name> [reason...]", "error");
-						return;
-					}
-					const name = sanitizeName(nameRaw);
-
-					const teamId = ctx.sessionManager.getSessionId();
-					const teamDir = getTeamDir(teamId);
-
-					// Best-effort: include current in-progress task id (if any).
-					await refreshTasks();
-					const active = tasks.find((x) => x.owner === name && x.status === "in_progress");
-					const taskId = active?.id;
-
-					const ts = new Date().toISOString();
-					await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-						from: "team-lead",
-						text: JSON.stringify({
-							type: "abort_request",
-							requestId: randomUUID(),
-							from: "team-lead",
-							taskId,
-							reason: reason || undefined,
-							timestamp: ts,
-						}),
-						timestamp: ts,
+					await handleTeamStopCommand({
+						ctx,
+						rest,
+						teammates,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						refreshTasks,
+						getTasks: () => tasks,
+						renderWidget,
 					});
-
-					const t = teammates.get(name);
-					if (t) {
-						// Fast-path for RPC teammates.
-						await t.abort();
-					}
-
-					ctx.ui.notify(
-						`Abort requested for ${name}${taskId ? ` (task #${taskId})` : ""}${t ? "" : " (mailbox only)"}`,
-						"warning",
-					);
-					renderWidget();
 					return;
 				}
 
 				case "kill": {
-					const nameRaw = rest[0];
-					if (!nameRaw) {
-						ctx.ui.notify("Usage: /team kill <name>", "error");
-						return;
-					}
-					const name = sanitizeName(nameRaw);
-					const t = teammates.get(name);
-					if (!t) {
-						ctx.ui.notify(`Unknown teammate: ${name}`, "error");
-						return;
-					}
-
-					await t.stop();
-					teammates.delete(name);
-
-					const teamId = ctx.sessionManager.getSessionId();
-					const teamDir = getTeamDir(teamId);
-					const effectiveTlId = taskListId ?? teamId;
-					await unassignTasksForAgent(teamDir, effectiveTlId, name, `Killed teammate '${name}'`);
-					await setMemberStatus(teamDir, name, "offline", { meta: { killedAt: new Date().toISOString() } });
-
-					ctx.ui.notify(`Killed teammate ${name}`, "warning");
-					await refreshTasks();
-					renderWidget();
+					await handleTeamKillCommand({
+						ctx,
+						rest,
+						teammates,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						taskListId,
+						refreshTasks,
+						renderWidget,
+					});
 					return;
 				}
 
 				case "dm": {
-					const nameRaw = rest[0];
-					const msg = rest.slice(1).join(" ").trim();
-					if (!nameRaw || !msg) {
-						ctx.ui.notify("Usage: /team dm <name> <msg...>", "error");
-						return;
-					}
-					const name = sanitizeName(nameRaw);
-					const teamId = ctx.sessionManager.getSessionId();
-					await writeToMailbox(getTeamDir(teamId), TEAM_MAILBOX_NS, name, {
-						from: "team-lead",
-						text: msg,
-						timestamp: new Date().toISOString(),
+					await handleTeamDmCommand({
+						ctx,
+						rest,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
 					});
-					ctx.ui.notify(`DM queued for ${name}`, "info");
 					return;
 				}
 
 				case "broadcast": {
-					const msg = rest.join(" ").trim();
-					if (!msg) {
-						ctx.ui.notify("Usage: /team broadcast <msg...>", "error");
-						return;
-					}
-
-					const teamId = ctx.sessionManager.getSessionId();
-					const teamDir = getTeamDir(teamId);
-					const leadName = "team-lead";
-					const cfg = await ensureTeamConfig(teamDir, { teamId, taskListId: taskListId ?? teamId, leadName });
-
-					const recipients = new Set<string>();
-					for (const m of cfg.members) {
-						if (m.role === "worker") recipients.add(m.name);
-					}
-					for (const name of teammates.keys()) recipients.add(name);
-
-					// Include task owners (helps reach manual tmux workers not tracked as RPC teammates).
-					await refreshTasks();
-					for (const t of tasks) {
-						if (t.owner && t.owner !== leadName) recipients.add(t.owner);
-					}
-
-					const names = Array.from(recipients).sort();
-					if (names.length === 0) {
-						ctx.ui.notify("No teammates to broadcast to", "warning");
-						return;
-					}
-
-					const ts = new Date().toISOString();
-					await Promise.all(
-						names.map((name) =>
-							writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-								from: "team-lead",
-								text: msg,
-								timestamp: ts,
-							}),
-						),
-					);
-
-					ctx.ui.notify(`Broadcast queued for ${names.length} teammate(s): ${names.join(", ")}`, "info");
+					await handleTeamBroadcastCommand({
+						ctx,
+						rest,
+						teammates,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						refreshTasks,
+						getTasks: () => tasks,
+						getTaskListId: () => taskListId,
+					});
 					return;
 				}
 
 				case "task": {
-					const [taskSub, ...taskRest] = rest;
-					const teamId = ctx.sessionManager.getSessionId();
-					const teamDir = getTeamDir(teamId);
-					const effectiveTlId = taskListId ?? teamId;
-
-					if (!taskSub || taskSub === "help") {
-						ctx.ui.notify(
-							[
-								"Usage:",
-								"  /team task add <text...>",
-								"  /team task assign <id> <agent>",
-								"  /team task unassign <id>",
-								"  /team task list",
-								"  /team task clear [completed|all] [--force]",
-								"  /team task show <id>",
-								"  /team task dep add <id> <depId>",
-								"  /team task dep rm <id> <depId>",
-								"  /team task dep ls <id>",
-								"  /team task use <taskListId>",
-								"Tip: prefix with assignee, e.g. 'alice: review the API surface'",
-							].join("\n"),
-							"info",
-						);
-						return;
-					}
-
-					switch (taskSub) {
-						case "add": {
-							const raw = taskRest.join(" ").trim();
-							if (!raw) {
-								ctx.ui.notify("Usage: /team task add <text...>", "error");
-								return;
-							}
-
-							const parsed = parseAssigneePrefix(raw);
-							const owner = parsed.assignee ? sanitizeName(parsed.assignee) : undefined;
-							const description = parsed.text.trim();
-							const subject = description.split("\n")[0].slice(0, 120);
-
-							const task = await createTask(teamDir, effectiveTlId, { subject, description, owner });
-
-							if (owner) {
-								const payload = taskAssignmentPayload(task, "team-lead");
-								await writeToMailbox(teamDir, effectiveTlId, owner, {
-									from: "team-lead",
-									text: JSON.stringify(payload),
-									timestamp: new Date().toISOString(),
-								});
-							}
-
-							ctx.ui.notify(`Created task #${task.id}${owner ? ` (assigned to ${owner})` : ""}`, "info");
-							await refreshTasks();
-							renderWidget();
-							return;
-						}
-
-						case "assign": {
-							const taskId = taskRest[0];
-							const agent = taskRest[1];
-							if (!taskId || !agent) {
-								ctx.ui.notify("Usage: /team task assign <id> <agent>", "error");
-								return;
-							}
-
-							const owner = sanitizeName(agent);
-							const updated = await updateTask(teamDir, effectiveTlId, taskId, (cur) => {
-								if (cur.status !== "completed") {
-									return { ...cur, owner, status: "pending" };
-								}
-								return { ...cur, owner };
-							});
-							if (!updated) {
-								ctx.ui.notify(`Task not found: ${taskId}`, "error");
-								return;
-							}
-
-							await writeToMailbox(teamDir, effectiveTlId, owner, {
-								from: "team-lead",
-								text: JSON.stringify(taskAssignmentPayload(updated, "team-lead")),
-								timestamp: new Date().toISOString(),
-							});
-
-							ctx.ui.notify(`Assigned task #${updated.id} to ${owner}`, "info");
-							await refreshTasks();
-							renderWidget();
-							return;
-						}
-
-						case "unassign": {
-							const taskId = taskRest[0];
-							if (!taskId) {
-								ctx.ui.notify("Usage: /team task unassign <id>", "error");
-								return;
-							}
-
-							const updated = await updateTask(teamDir, effectiveTlId, taskId, (cur) => {
-								if (cur.status !== "completed") {
-									return { ...cur, owner: undefined, status: "pending" };
-								}
-								return { ...cur, owner: undefined };
-							});
-							if (!updated) {
-								ctx.ui.notify(`Task not found: ${taskId}`, "error");
-								return;
-							}
-
-							ctx.ui.notify(`Unassigned task #${updated.id}`, "info");
-							await refreshTasks();
-							renderWidget();
-							return;
-						}
-
-						case "show": {
-							const taskId = taskRest[0];
-							if (!taskId) {
-								ctx.ui.notify("Usage: /team task show <id>", "error");
-								return;
-							}
-
-							const task = await getTask(teamDir, effectiveTlId, taskId);
-							if (!task) {
-								ctx.ui.notify(`Task not found: ${taskId}`, "error");
-								return;
-							}
-
-							const blocked = task.status !== "completed" && (await isTaskBlocked(teamDir, effectiveTlId, task));
-
-							const lines: string[] = [];
-							lines.push(`#${task.id} ${task.subject}`);
-							lines.push(
-								`status: ${task.status}${blocked ? " (blocked)" : ""}${task.owner ? ` • owner: ${task.owner}` : ""}`,
-							);
-							if (task.blockedBy.length) lines.push(`deps: ${task.blockedBy.join(", ")}`);
-							if (task.blocks.length) lines.push(`blocks: ${task.blocks.join(", ")}`);
-							lines.push("");
-							lines.push(task.description);
-
-							const result = typeof task.metadata?.result === "string" ? (task.metadata.result as string) : undefined;
-							if (result) {
-								lines.push("");
-								lines.push("result:");
-								lines.push(result);
-							}
-
-							ctx.ui.notify(lines.join("\n"), "info");
-							return;
-						}
-
-						case "dep": {
-							const [depSub, ...depRest] = taskRest;
-							if (!depSub || depSub === "help") {
-								ctx.ui.notify(
-									[
-										"Usage:",
-										"  /team task dep add <id> <depId>",
-										"  /team task dep rm <id> <depId>",
-										"  /team task dep ls <id>",
-									].join("\n"),
-									"info",
-								);
-								return;
-							}
-
-							switch (depSub) {
-								case "add": {
-									const taskId = depRest[0];
-									const depId = depRest[1];
-									if (!taskId || !depId) {
-										ctx.ui.notify("Usage: /team task dep add <id> <depId>", "error");
-										return;
-									}
-
-									const res = await addTaskDependency(teamDir, effectiveTlId, taskId, depId);
-									if (!res.ok) {
-										ctx.ui.notify(res.error, "error");
-										return;
-									}
-
-									ctx.ui.notify(`Added dependency: #${taskId} depends on #${depId}`, "info");
-									await refreshTasks();
-									renderWidget();
-									return;
-								}
-
-								case "rm": {
-									const taskId = depRest[0];
-									const depId = depRest[1];
-									if (!taskId || !depId) {
-										ctx.ui.notify("Usage: /team task dep rm <id> <depId>", "error");
-										return;
-									}
-
-									const res = await removeTaskDependency(teamDir, effectiveTlId, taskId, depId);
-									if (!res.ok) {
-										ctx.ui.notify(res.error, "error");
-										return;
-									}
-
-									ctx.ui.notify(`Removed dependency: #${taskId} no longer depends on #${depId}`, "info");
-									await refreshTasks();
-									renderWidget();
-									return;
-								}
-
-								case "ls": {
-									const taskId = depRest[0];
-									if (!taskId) {
-										ctx.ui.notify("Usage: /team task dep ls <id>", "error");
-										return;
-									}
-
-									await refreshTasks();
-									const task = tasks.find((t) => t.id === taskId) ?? (await getTask(teamDir, effectiveTlId, taskId));
-									if (!task) {
-										ctx.ui.notify(`Task not found: ${taskId}`, "error");
-										return;
-									}
-
-									const blocked = task.status !== "completed" && (await isTaskBlocked(teamDir, effectiveTlId, task));
-
-									const lines: string[] = [];
-									lines.push(`#${task.id} ${task.subject}`);
-									lines.push(`${blocked ? "blocked" : "unblocked"} • deps:${task.blockedBy.length} • blocks:${task.blocks.length}`);
-
-									lines.push("");
-									lines.push("blockedBy:");
-									if (!task.blockedBy.length) {
-										lines.push("  (none)");
-									} else {
-										for (const id of task.blockedBy) {
-											const dep = tasks.find((t) => t.id === id) ?? (await getTask(teamDir, effectiveTlId, id));
-											lines.push(dep ? `  - #${id} ${dep.status} ${dep.subject}` : `  - #${id} (missing)`);
-										}
-									}
-
-									lines.push("");
-									lines.push("blocks:");
-									if (!task.blocks.length) {
-										lines.push("  (none)");
-									} else {
-										for (const id of task.blocks) {
-											const child = tasks.find((t) => t.id === id) ?? (await getTask(teamDir, effectiveTlId, id));
-											lines.push(child ? `  - #${id} ${child.status} ${child.subject}` : `  - #${id} (missing)`);
-										}
-									}
-
-									ctx.ui.notify(lines.join("\n"), "info");
-									return;
-								}
-
-								default: {
-									ctx.ui.notify(`Unknown dep subcommand: ${depSub}`, "error");
-									return;
-								}
-							}
-						}
-
-						case "clear": {
-							const flags = taskRest.filter((a) => a.startsWith("--"));
-							const argsOnly = taskRest.filter((a) => !a.startsWith("--"));
-							const force = flags.includes("--force");
-
-							const unknownFlags = flags.filter((f) => f !== "--force");
-							if (unknownFlags.length) {
-								ctx.ui.notify(`Unknown flag(s): ${unknownFlags.join(", ")}`, "error");
-								return;
-							}
-
-							if (argsOnly.length > 1) {
-								ctx.ui.notify("Usage: /team task clear [completed|all] [--force]", "error");
-								return;
-							}
-
-							const modeArg = argsOnly[0];
-							if (modeArg && modeArg !== "completed" && modeArg !== "all") {
-								ctx.ui.notify("Usage: /team task clear [completed|all] [--force]", "error");
-								return;
-							}
-							const mode = modeArg === "all" ? "all" : "completed";
-
-							await refreshTasks();
-							const toDelete =
-								mode === "all" ? tasks.length : tasks.filter((t) => t.status === "completed").length;
-
-							if (!force) {
-								// Only prompt in interactive TTY mode. In RPC mode, confirm() would require
-								// the host to send extension_ui_response messages.
-								if (process.stdout.isTTY && process.stdin.isTTY) {
-									const title = mode === "all" ? "Clear task list" : "Clear completed tasks";
-									const body =
-										mode === "all"
-											? `Delete ALL ${toDelete} task(s) from the task list? This cannot be undone.`
-											: `Delete ${toDelete} completed task(s) from the task list? This cannot be undone.`;
-									const ok = await ctx.ui.confirm(title, body);
-									if (!ok) return;
-								} else {
-									ctx.ui.notify("Refusing to clear tasks in non-interactive mode without --force", "error");
-									return;
-								}
-							}
-
-							const res = await clearTasks(teamDir, effectiveTlId, mode);
-							const deleted = res.deletedTaskIds.length;
-
-							if (res.errors.length) {
-								ctx.ui.notify(
-									`Cleared ${deleted} task(s) (${mode}) with ${res.errors.length} error(s)`,
-									"warning",
-								);
-								const preview = res.errors
-									.slice(0, 8)
-									.map((e) => `- ${path.basename(e.file)}: ${e.error}`)
-									.join("\n");
-								ctx.ui.notify(`Errors:\n${preview}${res.errors.length > 8 ? `\n... +${res.errors.length - 8} more` : ""}`,
-									"warning",
-								);
-							} else if (deleted === 0) {
-								ctx.ui.notify(`No task(s) cleared (${mode})`, "info");
-							} else {
-								ctx.ui.notify(`Cleared ${deleted} task(s) (${mode})`, "warning");
-							}
-
-							await refreshTasks();
-							renderWidget();
-							return;
-						}
-
-						case "list": {
-							await refreshTasks();
-							if (!tasks.length) {
-								ctx.ui.notify("No tasks", "info");
-								return;
-							}
-
-							const slice = tasks.slice(-30);
-							const blocked = await Promise.all(
-								slice.map(async (t) => (t.status === "completed" ? false : await isTaskBlocked(teamDir, effectiveTlId, t))),
-							);
-
-							const preview = slice.map((t, i) => formatTaskLine(t, { blocked: blocked[i] })).join("\n");
-							ctx.ui.notify(preview, "info");
-							return;
-						}
-
-						case "use": {
-							const newId = taskRest[0];
-							if (!newId) {
-								ctx.ui.notify("Usage: /team task use <taskListId>", "error");
-								return;
-							}
-							taskListId = newId;
-							await ensureTeamConfig(teamDir, { teamId, taskListId: newId, leadName: "team-lead" });
-							ctx.ui.notify(`Task list ID set to: ${taskListId}`, "info");
-							await refreshTasks();
-							renderWidget();
-							return;
-						}
-
-						default: {
-							ctx.ui.notify(`Unknown task subcommand: ${taskSub}`, "error");
-							return;
-						}
-					}
+					await handleTeamTaskCommand({
+						ctx,
+						rest,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						getTaskListId: () => taskListId,
+						setTaskListId: (id) => {
+							taskListId = id;
+						},
+						getTasks: () => tasks,
+						refreshTasks,
+						renderWidget,
+						parseAssigneePrefix,
+						taskAssignmentPayload,
+					});
+					return;
 				}
 
 				case "plan": {
-					const [planSub, ...planRest] = rest;
-					if (!planSub || planSub === "help") {
-						ctx.ui.notify(
-							[
-								"Usage:",
-								"  /team plan approve <name>",
-								"  /team plan reject <name> [feedback...]",
-							].join("\n"),
-							"info",
-						);
-						return;
-					}
-
-					if (planSub === "approve") {
-						const nameRaw = planRest[0];
-						if (!nameRaw) {
-							ctx.ui.notify("Usage: /team plan approve <name>", "error");
-							return;
-						}
-						const name = sanitizeName(nameRaw);
-						const pending = pendingPlanApprovals.get(name);
-						if (!pending) {
-							ctx.ui.notify(`No pending plan approval for ${name}`, "error");
-							return;
-						}
-
-						const teamId = ctx.sessionManager.getSessionId();
-						const teamDir = getTeamDir(teamId);
-						const ts = new Date().toISOString();
-						await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-							from: "team-lead",
-							text: JSON.stringify({
-								type: "plan_approved",
-								requestId: pending.requestId,
-								from: "team-lead",
-								timestamp: ts,
-							}),
-							timestamp: ts,
-						});
-						pendingPlanApprovals.delete(name);
-						ctx.ui.notify(`Approved plan for ${name}`, "info");
-						return;
-					}
-
-					if (planSub === "reject") {
-						const nameRaw = planRest[0];
-						if (!nameRaw) {
-							ctx.ui.notify("Usage: /team plan reject <name> [feedback...]", "error");
-							return;
-						}
-						const name = sanitizeName(nameRaw);
-						const pending = pendingPlanApprovals.get(name);
-						if (!pending) {
-							ctx.ui.notify(`No pending plan approval for ${name}`, "error");
-							return;
-						}
-
-						const feedback = planRest.slice(1).join(" ").trim() || "Plan rejected";
-						const teamId = ctx.sessionManager.getSessionId();
-						const teamDir = getTeamDir(teamId);
-						const ts = new Date().toISOString();
-						await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
-							from: "team-lead",
-							text: JSON.stringify({
-								type: "plan_rejected",
-								requestId: pending.requestId,
-								from: "team-lead",
-								feedback,
-								timestamp: ts,
-							}),
-							timestamp: ts,
-						});
-						pendingPlanApprovals.delete(name);
-						ctx.ui.notify(`Rejected plan for ${name}: ${feedback}`, "info");
-						return;
-					}
-
-					ctx.ui.notify(`Unknown plan subcommand: ${planSub}`, "error");
+					await handleTeamPlanCommand({
+						ctx,
+						rest,
+						leadName: teamConfig?.leadName ?? "team-lead",
+						style,
+						pendingPlanApprovals,
+					});
 					return;
 				}