pi-squad 0.1.0 → 0.5.0

package/src/index.ts

@@ -18,20 +18,34 @@ import type { Squad, Task, SquadConfig, PlannerOutput } from "./types.js";
 import { DEFAULT_SQUAD_CONFIG } from "./types.js";
 import { Scheduler, type SchedulerEvent } from "./scheduler.js";
 import { runPlanner } from "./planner.js";
-import { SquadPanel } from "./panel/squad-panel.js";
+import { SquadPanel, type SquadPanelResult } from "./panel/squad-panel.js";
+import { setupSquadWidget, type SquadWidgetState } from "./panel/squad-widget.js";
 import * as store from "./store.js";
 
 // ============================================================================
 // State
 // ============================================================================
 
-let activeScheduler: Scheduler | null = null;
+/** Master switch — when false, all squad tools, hooks, and widget are disabled */
+let squadEnabled = true;
+/** Registry of all running schedulers — supports multiple concurrent squads */
+const schedulers = new Map<string, Scheduler>();
+/** The currently viewed/focused squad (for widget, panel, status) */
 let activeSquadId: string | null = null;
-let activePanel: SquadPanel | null = null;
+/** Whether an overlay panel is currently open (prevents double-open) */
+let overlayOpen = false;
 /** Stored ExtensionContext for widget updates from background scheduler events */
 let uiCtx: import("@mariozechner/pi-coding-agent").ExtensionContext | null = null;
-/** Interval for periodic widget refresh */
-let widgetInterval: ReturnType<typeof setInterval> | null = null;
+/** Component-based widget state + controls */
+const widgetState: SquadWidgetState = { squadId: null, enabled: true };
+let widgetControls: { requestUpdate: () => void; dispose: () => void } | null = null;
+
+/** Get the active scheduler (for the focused squad) */
+function getActiveScheduler(): Scheduler | null {
+	if (!activeSquadId) return null;
+	return schedulers.get(activeSquadId) || null;
+}
+
 
 // ============================================================================
 // Extension Entry
@@ -53,37 +67,55 @@ export default function (pi: ExtensionAPI) {
 	// Context Injection — give main agent awareness of squad state
 	// =========================================================================
 
-	// Inject squad status before each LLM call so the main agent knows squad state
+	// Inject squad awareness before each LLM call
 	pi.on("before_agent_start", async (event, _ctx) => {
-		if (!activeSquadId) return;
-		const squad = store.loadSquad(activeSquadId);
-		if (!squad) return;
-		const tasks = store.loadAllTasks(activeSquadId);
-		if (tasks.length === 0) return;
-
-		const doneCount = tasks.filter((t) => t.status === "done").length;
-		const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
-
-		const taskLines = tasks.map((t) => {
-			const icon = t.status === "done" ? "✓" : t.status === "in_progress" ? "⏳" : t.status === "failed" ? "✗" : t.status === "blocked" ? "◻" : "·";
-			let line = `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
-			if (t.output) line += ` — ${t.output.split("\n")[0].slice(0, 80)}`;
-			if (t.error) line += ` ERROR: ${t.error.slice(0, 60)}`;
-			return line;
-		}).join("\n");
-
-		const squadContext = [
-			`<squad_status>`,
-			`Squad: ${squad.id} — ${squad.goal}`,
-			`Status: ${squad.status} | ${doneCount}/${tasks.length} tasks | $${totalCost.toFixed(2)}`,
-			taskLines,
-			`</squad_status>`,
-			`You have an active squad. Use squad_message to talk to agents, squad_status for details, squad_modify to change tasks.`,
+		if (!squadEnabled) return;
+
+		// When a squad is active, inject its status
+		if (activeSquadId) {
+			const squad = store.loadSquad(activeSquadId);
+			if (!squad) return;
+			const tasks = store.loadAllTasks(activeSquadId);
+			if (tasks.length === 0) return;
+
+			const doneCount = tasks.filter((t) => t.status === "done").length;
+			const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
+
+			const taskLines = tasks.map((t) => {
+				const icon = t.status === "done" ? "✓" : t.status === "in_progress" ? "⏳" : t.status === "failed" ? "✗" : t.status === "blocked" ? "◻" : "·";
+				let line = `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
+				if (t.output) line += ` — ${t.output.split("\n")[0].slice(0, 80)}`;
+				if (t.error) line += ` ERROR: ${t.error.slice(0, 60)}`;
+				return line;
+			}).join("\n");
+
+			const squadContext = [
+				`<squad_status>`,
+				`Squad: ${squad.id} — ${squad.goal}`,
+				`Status: ${squad.status} | ${doneCount}/${tasks.length} tasks | $${totalCost.toFixed(2)}`,
+				taskLines,
+				`</squad_status>`,
+				`You have an active squad. Use squad_message to talk to agents, squad_status for details, squad_modify to change tasks.`,
+			].join("\n");
+
+			return {
+				systemPrompt: event.systemPrompt + "\n\n" + squadContext,
+			};
+		}
+
+		// When NO squad is active, nudge the agent to consider using squad for complex tasks
+		const squadNudge = [
+			`<squad_hint>`,
+			`You have the "squad" tool available for multi-agent collaboration.`,
+			`Use it when the user's request involves multiple concerns (e.g. backend + frontend + tests + docs),`,
+			`would benefit from parallel execution, or is too large for a single agent context.`,
+			`The squad tool decomposes work into tasks, assigns specialist agents, and runs them in parallel.`,
+			`When in doubt about whether a task is complex enough, prefer using squad — it handles the coordination for you.`,
+			`</squad_hint>`,
 		].join("\n");
 
-		// Append to system prompt so the agent always sees it
 		return {
-			systemPrompt: event.systemPrompt + "\n\n" + squadContext,
+			systemPrompt: event.systemPrompt + "\n\n" + squadNudge,
 		};
 	});
 
@@ -96,9 +128,12 @@ export default function (pi: ExtensionAPI) {
 		label: "Squad",
 		description: [
 			"Start a multi-agent squad for complex, multi-step tasks.",
-			"Use when a task needs multiple specialized skills (backend + frontend + testing),",
-			"has natural parallelism, or would overflow a single agent's context.",
-			"Don't use for simple single-file changes or tasks a single agent can handle.",
+			"ALWAYS use squad when a task involves 2+ of: backend, frontend, testing, docs, devops, security.",
+			"Use when a task has natural parallelism, touches multiple files/systems, or would overflow a single agent's context.",
+			"Examples that NEED squad: 'build a REST API with auth and tests', 'add a feature with frontend + backend + docs',",
+			"'refactor the auth system and update tests', 'set up CI/CD with Docker and deployment'.",
+			"Do NOT use for simple single-file changes, quick bug fixes, or tasks a single agent can handle in a few minutes.",
+			"When in doubt about complexity, use squad — it's better to parallelize than to do everything sequentially.",
 			"Non-blocking: returns immediately with the plan while agents work in background.",
 		].join(" "),
 		parameters: Type.Object({
@@ -131,23 +166,17 @@ export default function (pi: ExtensionAPI) {
 			),
 		}),
 
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			if (!squadEnabled) return { content: [{ type: "text" as const, text: "Squad is disabled. Use /squad enable to re-enable." }] };
 			if (!uiCtx) uiCtx = ctx;
 
-			if (activeScheduler) {
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text: `A squad is already running (${activeSquadId}). Use squad_status to check progress, or squad_modify to cancel it.`,
-						},
-					],
-				};
-			}
+			// Check if the user cancelled before we start
+			if (signal?.aborted) return { content: [{ type: "text" as const, text: "Cancelled." }] };
+
+			// Multiple squads can run concurrently — no guard needed
 
 			const squadId = store.makeTaskId(params.goal);
 			if (store.squadExists(squadId)) {
-				// Append timestamp to make unique
 				const uniqueId = `${squadId}-${Date.now().toString(36)}`;
 				return await startSquad(uniqueId, params, ctx.cwd, squadSkillPaths, pi);
 			}
@@ -182,9 +211,8 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// If scheduler is running, force a context refresh
-			if (activeScheduler && activeSquadId === id) {
-				activeScheduler.updateContext();
-			}
+			const sched = schedulers.get(id!);
+				if (sched) sched.updateContext();
 
 			const context = store.loadContext(id);
 			if (!context) {
@@ -234,6 +262,7 @@ export default function (pi: ExtensionAPI) {
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const activeScheduler = getActiveScheduler();
 			if (!activeScheduler || !activeSquadId) {
 				return { content: [{ type: "text" as const, text: "No active squad." }] };
 			}
@@ -249,7 +278,7 @@ export default function (pi: ExtensionAPI) {
 				return { content: [{ type: "text" as const, text: "Could not determine target task. Provide taskId or an agent name that is currently running." }] };
 			}
 
-			const sent = await activeScheduler.sendHumanMessage(taskId, params.message);
+			const sent = await activeScheduler!.sendHumanMessage(taskId, params.message);
 			const status = sent ? "delivered" : "queued for when the agent starts";
 
 			return { content: [{ type: "text" as const, text: `Message ${status}: "${params.message}"` }] };
@@ -290,9 +319,86 @@ export default function (pi: ExtensionAPI) {
 			),
 		}),
 
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			// Resume can work without an active scheduler — it recreates one from disk
+			if (params.action === "resume") {
+				// Find a squad to resume: use activeSquadId or find the latest paused one
+				const squadId = activeSquadId || store.findActiveSquads()
+					.filter((s) => s.cwd === ctx.cwd && s.status === "paused")
+					.sort((a, b) => b.created.localeCompare(a.created))[0]?.id;
+
+				if (!squadId) {
+					return { content: [{ type: "text" as const, text: "No paused squad found to resume." }] };
+				}
+
+				// Create a fresh scheduler if needed
+				if (!schedulers.has(squadId)) {
+					const scheduler = new Scheduler(squadId, squadSkillPaths);
+					schedulers.set(squadId, scheduler);
+					activeSquadId = squadId;
+
+					// Activate widget
+					widgetState.squadId = squadId;
+					widgetState.enabled = true;
+					widgetControls?.requestUpdate();
+
+					// Wire up events (same as startSquad)
+					scheduler.onEvent((event: SchedulerEvent) => {
+						forceWidgetUpdate();
+						switch (event.type) {
+							case "squad_completed": {
+								const tasks = store.loadAllTasks(squadId);
+								const summary = tasks
+									.filter((t) => t.status === "done")
+									.map((t) => `- ${t.id} (${t.agent}): ${t.output?.slice(0, 150) || "done"}`)
+									.join("\n");
+								const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
+								const s = schedulers.get(squadId); if (s) s.updateContext();
+								pi.sendMessage({
+									customType: "squad-completed",
+									content: `[squad] Squad "${squadId}" completed all ${tasks.length} tasks.\n\nSummary:\n${summary}\n\nTotal cost: $${totalCost.toFixed(4)}`,
+									display: true,
+								});
+								schedulers.delete(squadId);
+								forceWidgetUpdate();
+								break;
+							}
+							case "squad_failed": {
+								const tasks = store.loadAllTasks(squadId);
+								const failed = tasks.filter((t) => t.status === "failed");
+								const done = tasks.filter((t) => t.status === "done");
+								pi.sendMessage({
+									customType: "squad-failed",
+									content: `[squad] Squad "${squadId}" has stalled. ${done.length}/${tasks.length} done, ${failed.length} failed.\nFailed: ${failed.map((t) => `${t.id}: ${t.error?.slice(0, 100)}`).join("; ")}`,
+									display: true,
+								}, { triggerTurn: true });
+								forceWidgetUpdate();
+								break;
+							}
+							case "escalation": {
+								pi.sendMessage({
+									customType: "squad-escalation",
+									content: `[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n${event.message}`,
+									display: true,
+								}, { triggerTurn: true });
+								break;
+							}
+						}
+					});
+				}
+
+				const resumeSched = schedulers.get(squadId)!;
+				resumeSched.resume().catch((err) => {
+					console.error(`[squad] Resume error: ${(err as Error).message}`);
+				});
+
+				const tasks = store.loadAllTasks(squadId);
+				const done = tasks.filter(t => t.status === "done").length;
+				return { content: [{ type: "text" as const, text: `Squad "${squadId}" resumed (${done}/${tasks.length} done). Agents restarting in background.` }] };
+			}
+
 			if (!activeScheduler || !activeSquadId) {
-				return { content: [{ type: "text" as const, text: "No active squad." }] };
+				return { content: [{ type: "text" as const, text: "No active squad. Use squad_modify with action 'resume' to resume a paused squad, or start a new one with the squad tool." }] };
 			}
 
 			switch (params.action) {
@@ -333,7 +439,9 @@ export default function (pi: ExtensionAPI) {
 
 				case "resume_task": {
 					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }] };
-					await activeScheduler.resumeTask(params.taskId);
+					activeScheduler.resumeTask(params.taskId).catch((err) => {
+						console.error(`[squad] Resume task error: ${(err as Error).message}`);
+					});
 					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed.` }] };
 				}
 
@@ -348,7 +456,7 @@ export default function (pi: ExtensionAPI) {
 				}
 
 				case "resume": {
-					await activeScheduler.resume();
+					// Handled above (before the activeScheduler guard)
 					return { content: [{ type: "text" as const, text: "Squad resumed." }] };
 				}
 
@@ -359,7 +467,7 @@ export default function (pi: ExtensionAPI) {
 						squad.status = "failed";
 						store.saveSquad(squad);
 					}
-					activeScheduler = null;
+					schedulers.delete(activeSquadId);
 					activeSquadId = null;
 					return { content: [{ type: "text" as const, text: "Squad cancelled." }] };
 				}
@@ -376,40 +484,72 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		uiCtx = ctx;
-		// Check for active squads for this project
-		const active = store.findActiveSquads()
-			.filter((s) => s.cwd === ctx.cwd);
-		if (active.length > 0) {
-			const squad = active[0];
-			pi.sendUserMessage(
-				`[squad] Found suspended squad "${squad.id}" (${squad.goal}). ` +
-				`Use squad_modify with action "resume" to continue, or start a new squad.`,
-				{ deliverAs: "followUp" },
-			);
+
+		// Install component-based widget
+		if (ctx.hasUI) {
+			widgetControls = setupSquadWidget(ctx, widgetState);
+		}
+
+		// Clean up orphaned squads from crashed sessions:
+		// If a squad is "running" but has no live scheduler, its parent died.
+		// Suspend in-progress tasks and mark the squad as paused so it doesn't
+		// block new squads or trigger confusing followUp messages.
+		const orphaned = store.findActiveSquads()
+			.filter((s) => s.cwd === ctx.cwd && s.status === "running");
+		for (const squad of orphaned) {
+			const tasks = store.loadAllTasks(squad.id);
+			let hadInProgress = false;
+			for (const task of tasks) {
+				if (task.status === "in_progress") {
+					store.updateTaskStatus(squad.id, task.id, "suspended");
+					hadInProgress = true;
+				}
+			}
+			if (hadInProgress) {
+				squad.status = "paused";
+				store.saveSquad(squad);
+			}
+		}
+
+		// Notify about paused squads only if they have real completed work
+		const paused = store.findActiveSquads()
+			.filter((s) => s.cwd === ctx.cwd && s.status === "paused");
+		if (paused.length > 0) {
+			const squad = paused[0];
+			const tasks = store.loadAllTasks(squad.id);
+			const done = tasks.filter(t => t.status === "done").length;
+			// Only notify if at least 1 task completed — worth resuming
+			if (done > 0) {
+				pi.sendMessage({
+					customType: "squad-paused",
+					content: `[squad] Found paused squad "${squad.id}" (${squad.goal}) — ${done}/${tasks.length} done. ` +
+						`Use squad_modify with action "resume" to continue, or start a new squad.`,
+					display: true,
+				});
+			}
 		}
 
 		// Register Ctrl+Q terminal input handler for panel toggle
 		if (ctx.hasUI) {
 			ctx.ui.onTerminalInput((data) => {
 				if (data === "\x11") {
-					if (!activePanel) {
-						// Auto-pick a squad if none active
-						if (!activeSquadId) {
-							const latest = store.findLatestSquad(ctx.cwd)
-								|| store.listSquads().map((id) => store.loadSquad(id)).filter((s): s is Squad => s !== null).sort((a, b) => b.created.localeCompare(a.created))[0];
-							if (latest) {
-								activateSquadView(latest.id, ctx);
-							} else {
-								ctx.ui.notify("No squads found. Use /squad or the squad tool.", "info");
-								return { consume: true };
-							}
-						}
-						if (activeSquadId) {
-							const sched = activeScheduler || new Scheduler(activeSquadId, squadSkillPaths);
-							createPanel(ctx, sched, activeSquadId);
+					// If overlay is already open, let the panel's own handler deal with it
+					if (overlayOpen) return undefined;
+
+					// Auto-pick a squad if none active
+					if (!activeSquadId) {
+						const latest = store.findLatestSquad(ctx.cwd)
+							|| store.listSquads().map((id) => store.loadSquad(id)).filter((s): s is Squad => s !== null).sort((a, b) => b.created.localeCompare(a.created))[0];
+						if (latest) {
+							activateSquadView(latest.id, ctx);
+						} else {
+							ctx.ui.notify("No squads found. Use /squad or the squad tool.", "info");
+							return { consume: true };
 						}
-					} else {
-						activePanel.toggleFocus();
+					}
+
+					if (activeSquadId) {
+						openPanel(ctx, schedulers.get(activeSquadId) || new Scheduler(activeSquadId, squadSkillPaths), activeSquadId);
 					}
 					return { consume: true };
 				}
@@ -419,16 +559,13 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async () => {
-		clearWidgetRefresh();
-		if (activePanel) {
-			activePanel.dispose();
-			activePanel = null;
-		}
-		if (activeScheduler) {
-			await activeScheduler.stop();
-			activeScheduler = null;
-			activeSquadId = null;
+		widgetControls?.dispose();
+		widgetControls = null;
+		for (const [id, sched] of schedulers) {
+			await sched.stop();
 		}
+		schedulers.clear();
+		activeSquadId = null;
 		uiCtx = null;
 	});
 
@@ -437,17 +574,21 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 
 	pi.registerCommand("squad", {
-		description: "Browse, select, and manage squads. Usage: /squad [list|all|select|msg|widget|panel|cancel|clear]",
+		description: "Browse, select, and manage squads. Usage: /squad [list|all|select|agents|msg|widget|panel|cancel|clear]",
 		getArgumentCompletions: (prefix) => {
 			const subs = [
 				{ value: "list", label: "list", description: "List squads for current project" },
 				{ value: "all", label: "all", description: "List all squads, select to activate" },
 				{ value: "select", label: "select", description: "Pick a squad to view (interactive)" },
+				{ value: "agents", label: "agents", description: "List, view, or edit agent definitions" },
 				{ value: "msg", label: "msg", description: "Send message to agent: /squad msg [agent] text" },
 				{ value: "widget", label: "widget", description: "Toggle live widget" },
 				{ value: "panel", label: "panel", description: "Toggle overlay panel" },
 				{ value: "cancel", label: "cancel", description: "Cancel running squad" },
 				{ value: "clear", label: "clear", description: "Dismiss widget and deactivate squad" },
+				{ value: "cleanup", label: "cleanup", description: "Delete squad data (select or all)" },
+				{ value: "enable", label: "enable", description: "Enable pi-squad (tools, widget, system prompt)" },
+				{ value: "disable", label: "disable", description: "Disable pi-squad completely" },
 			];
 			return subs.filter((s) => s.value.startsWith(prefix));
 		},
@@ -507,21 +648,16 @@ export default function (pi: ExtensionAPI) {
 				}
 
 				case "widget": {
-					if (!widgetEnabled) {
-						widgetEnabled = true;
-						// If no active squad, try to pick one
+					widgetState.enabled = !widgetState.enabled;
+					if (widgetState.enabled) {
 						if (!activeSquadId) {
 							const latest = store.findLatestSquad(ctx.cwd);
 							if (latest) activateSquadView(latest.id, ctx);
 						}
-						updateWidget();
-						ctx.ui.notify("Squad widget enabled", "info");
-					} else {
-						widgetEnabled = false;
-						ctx.ui.setWidget("squad-tasks", undefined);
-						ctx.ui.setStatus("squad", undefined);
-						ctx.ui.notify("Squad widget disabled", "info");
 					}
+					// requestUpdate handles both enable (renders) and disable (clears)
+					widgetControls?.requestUpdate();
+					ctx.ui.notify(`Squad widget ${widgetState.enabled ? "enabled" : "disabled"}`, "info");
 					return;
 				}
 
@@ -536,12 +672,9 @@ export default function (pi: ExtensionAPI) {
 							return;
 						}
 					}
-					if (!activePanel && activeSquadId) {
-						// Panel needs a scheduler — create a dummy one for view-only if none running
-						const sched = activeScheduler || new Scheduler(activeSquadId, squadSkillPaths);
-						createPanel(ctx, sched, activeSquadId);
-					} else if (activePanel) {
-						activePanel.toggleFocus();
+					if (activeSquadId) {
+						const sched = schedulers.get(activeSquadId) || new Scheduler(activeSquadId, squadSkillPaths);
+						openPanel(ctx, sched, activeSquadId);
 					}
 					return;
 				}
@@ -598,8 +731,9 @@ export default function (pi: ExtensionAPI) {
 						}
 					}
 
-					if (activeScheduler) {
-						await activeScheduler.sendHumanMessage(targetTaskId, msgText);
+					const msgSched = getActiveScheduler();
+					if (msgSched) {
+						await msgSched.sendHumanMessage(targetTaskId, msgText);
 						ctx.ui.notify(`Sent to ${targetAgent}: "${msgText.slice(0, 50)}"`, "info");
 					} else {
 						store.appendMessage(activeSquadId, targetTaskId, {
@@ -610,36 +744,254 @@ export default function (pi: ExtensionAPI) {
 						});
 						ctx.ui.notify(`Logged to ${targetTaskId} (agent not running)`, "info");
 					}
-					updateWidget();
+					forceWidgetUpdate();
 					return;
 				}
 
 				case "cancel": {
-					if (!activeScheduler) {
+					const cancelSched = getActiveScheduler();
+					if (!cancelSched) {
 						ctx.ui.notify("No running squad to cancel", "info");
 						return;
 					}
-					await activeScheduler.stop();
+					await cancelSched.stop();
 					const squad = store.loadSquad(activeSquadId!);
 					if (squad) { squad.status = "failed"; store.saveSquad(squad); }
-					activeScheduler = null;
-					clearWidgetRefresh();
-					updateWidget();
+					if (activeSquadId) schedulers.delete(activeSquadId);
+					forceWidgetUpdate();
 					ctx.ui.notify("Squad cancelled", "info");
 					return;
 				}
 
 				case "clear": {
+					if (activeSquadId) schedulers.delete(activeSquadId);
 					activeSquadId = null;
-					activeScheduler = null;
-					clearWidgetRefresh();
-					if (activePanel) { activePanel.dispose(); activePanel = null; }
-					ctx.ui.setWidget("squad-tasks", undefined);
-					ctx.ui.setStatus("squad", undefined);
+					widgetState.squadId = null;
+					widgetControls?.dispose();
 					ctx.ui.notify("Squad view cleared", "info");
 					return;
 				}
 
+				case "cleanup": {
+					const cleanupArg = parts[1];
+					const allSquadIds = store.listSquads();
+
+					if (allSquadIds.length === 0) {
+						ctx.ui.notify("No squads to clean up", "info");
+						return;
+					}
+
+					if (cleanupArg === "all") {
+						// Stop any running schedulers first
+						for (const [id, sched] of schedulers) {
+							await sched.stop();
+						}
+						schedulers.clear();
+						activeSquadId = null;
+						widgetState.squadId = null;
+						widgetControls?.requestUpdate();
+
+						let count = 0;
+						for (const id of allSquadIds) {
+							fs.rmSync(store.getSquadDir(id), { recursive: true, force: true });
+							count++;
+						}
+						ctx.ui.notify(`Deleted ${count} squad(s)`, "info");
+						return;
+					}
+
+					// Interactive: pick squads to delete
+					const squads = allSquadIds
+						.map((id) => store.loadSquad(id))
+						.filter((s): s is Squad => s !== null)
+						.sort((a, b) => b.created.localeCompare(a.created));
+
+					const options = [
+						"🗑  Delete ALL squads",
+						...squads.map((s) => {
+							const tasks = store.loadAllTasks(s.id);
+							const done = tasks.filter((t) => t.status === "done").length;
+							const cost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
+							const icon = s.status === "done" ? "✓" : s.status === "running" ? "⏳" : s.status === "failed" ? "✗" : "·";
+							return `${icon} ${s.id} [${s.status}] ${done}/${tasks.length} $${cost.toFixed(2)}`;
+						}),
+					];
+
+					const choice = await ctx.ui.select("Delete squad data", options);
+					if (!choice) return;
+
+					if (choice.startsWith("🗑")) {
+						// Delete all
+						for (const [id, sched] of schedulers) {
+							await sched.stop();
+						}
+						schedulers.clear();
+						activeSquadId = null;
+						widgetState.squadId = null;
+						widgetControls?.requestUpdate();
+						let count = 0;
+						for (const id of allSquadIds) {
+							fs.rmSync(store.getSquadDir(id), { recursive: true, force: true });
+							count++;
+						}
+						ctx.ui.notify(`Deleted ${count} squad(s)`, "info");
+					} else {
+						// Delete selected
+						const idx = options.indexOf(choice) - 1; // -1 for the "Delete ALL" option
+						if (idx >= 0 && idx < squads.length) {
+							const squad = squads[idx];
+							// Stop scheduler if running
+							const sched = schedulers.get(squad.id);
+							if (sched) {
+								await sched.stop();
+								schedulers.delete(squad.id);
+							}
+							if (activeSquadId === squad.id) {
+								activeSquadId = null;
+								widgetState.squadId = null;
+								widgetControls?.requestUpdate();
+							}
+							fs.rmSync(store.getSquadDir(squad.id), { recursive: true, force: true });
+							ctx.ui.notify(`Deleted: ${squad.id}`, "info");
+						}
+					}
+					return;
+				}
+
+				case "enable": {
+					squadEnabled = true;
+					widgetControls?.requestUpdate();
+					ctx.ui.notify("pi-squad enabled — tools, widget, and system prompt active", "info");
+					return;
+				}
+
+				case "disable": {
+					squadEnabled = false;
+					// Stop all running schedulers
+					for (const [id, sched] of schedulers) {
+						await sched.stop();
+					}
+					schedulers.clear();
+					activeSquadId = null;
+					widgetState.squadId = null;
+					widgetState.enabled = false;
+					widgetControls?.requestUpdate();
+					ctx.ui.notify("pi-squad disabled — all tools, widget, and system prompt injection stopped", "info");
+					return;
+				}
+
+				case "agents": {
+					const agentArg = parts[1];
+					const allAgents = store.loadAllAgentDefs(ctx.cwd);
+
+					if (!agentArg) {
+						// List all agents — interactive selector
+						if (allAgents.length === 0) {
+							ctx.ui.notify("No agents found", "info");
+							return;
+						}
+						const options = allAgents.map((a) => {
+							const model = a.model ? ` [${a.model}]` : " [default]";
+							const status = a.disabled ? " ✗ disabled" : "";
+							return `${a.name} — ${a.role}${model}${status}`;
+						});
+						const choice = await ctx.ui.select("Squad Agents (select to view/edit)", options);
+						if (!choice) return;
+						const selectedName = choice.split(" — ")[0];
+						const agent = allAgents.find((a) => a.name === selectedName);
+						if (!agent) return;
+
+						// Show agent details and offer actions
+						const disableLabel = agent.disabled ? "Enable agent" : "Disable agent";
+						const actions = [
+							"View details",
+							"Edit in editor",
+							"Change model",
+							"Toggle tools (restrict/unrestrict)",
+							disableLabel,
+							"Cancel",
+						];
+						const action = await ctx.ui.select(`${agent.name} (${agent.role})`, actions);
+						if (!action || action === "Cancel") return;
+
+						if (action === "View details") {
+							const details = [
+								`Name: ${agent.name}`,
+								`Role: ${agent.role}`,
+								`Description: ${agent.description}`,
+								`Model: ${agent.model || "(default)"}`,
+								`Tools: ${agent.tools ? agent.tools.join(", ") : "(all)"}`,
+								`Tags: ${agent.tags.join(", ")}`,
+								``,
+								`Prompt:`,
+								`${agent.prompt.slice(0, 300)}${agent.prompt.length > 300 ? "..." : ""}`,
+								``,
+								`File: ${store.getGlobalAgentsDir()}/${agent.name}.json`,
+							].join("\n");
+							ctx.ui.notify(details, "info");
+						} else if (action === "Edit in editor") {
+							// Check for local override first, fall back to global
+							const localPath = `${store.getLocalAgentsDir(ctx.cwd)}/${agent.name}.json`;
+							const globalPath = `${store.getGlobalAgentsDir()}/${agent.name}.json`;
+							const filePath = fs.existsSync(localPath) ? localPath : globalPath;
+							pi.sendMessage({
+								customType: "squad-edit-agent",
+								content: `Edit agent file: ${filePath}`,
+								display: true,
+							}, { triggerTurn: true });
+						} else if (action === "Change model") {
+							const newModel = await ctx.ui.input(
+								`Model for ${agent.name} (empty = default)`,
+								agent.model || "",
+							);
+							if (newModel !== undefined) {
+								agent.model = newModel.trim() || null;
+								store.saveAgentDef(agent);
+								ctx.ui.notify(`${agent.name} model → ${agent.model || "(default)"}`, "info");
+							}
+						} else if (action === disableLabel) {
+							agent.disabled = !agent.disabled;
+							store.saveAgentDef(agent);
+							const newState = agent.disabled ? "disabled — planner will not assign tasks to this agent" : "enabled";
+							ctx.ui.notify(`${agent.name}: ${newState}`, "info");
+						} else if (action === "Toggle tools") {
+							if (agent.tools) {
+								agent.tools = null;
+								store.saveAgentDef(agent);
+								ctx.ui.notify(`${agent.name}: all tools enabled`, "info");
+							} else {
+								const toolList = await ctx.ui.input(
+									`Tools for ${agent.name} (comma-separated)`,
+									"bash,read,write,edit",
+								);
+								if (toolList) {
+									agent.tools = toolList.split(",").map((t) => t.trim()).filter(Boolean);
+									store.saveAgentDef(agent);
+									ctx.ui.notify(`${agent.name}: tools = [${agent.tools.join(", ")}]`, "info");
+								}
+							}
+						}
+						return;
+					}
+
+					// /squad agents <name> — show specific agent
+					const agent = store.loadAgentDef(agentArg, ctx.cwd);
+					if (agent) {
+						const status = agent.disabled ? " ✗ DISABLED" : "";
+						const details = [
+							`${agent.name} — ${agent.role}${status}`,
+							`${agent.description}`,
+							`Model: ${agent.model || "(default)"}`,
+							`Tools: ${agent.tools ? agent.tools.join(", ") : "(all)"}`,
+							`Tags: ${agent.tags.join(", ")}`,
+						].join("\n");
+						ctx.ui.notify(details, "info");
+					} else {
+						ctx.ui.notify(`Agent '${agentArg}' not found`, "warning");
+					}
+					return;
+				}
+
 				default:
 					// Treat as a squad ID — try to activate it directly
 					const direct = store.loadSquad(sub);
@@ -699,176 +1051,59 @@ function activateSquadView(squadId: string, ctx: import("@mariozechner/pi-coding
 
 	activeSquadId = squadId;
 
-	// Show widget for this squad
-	widgetEnabled = true;
-	updateWidget();
-
-	// Start refresh if squad is still running (live updates from disk)
-	if (squad.status === "running" || squad.status === "paused") {
-		startWidgetRefresh();
-	}
+	// Update widget to show the new squad. The widget reads squadId on each
+	// render, so just updating the state and requesting a render is enough.
+	widgetState.squadId = squadId;
+	widgetState.enabled = true;
+	widgetControls?.requestUpdate();
 
+	// Compact notification — widget already shows full task details.
+	// Avoid large multi-line notifications that can break TUI layout.
 	const tasks = store.loadAllTasks(squadId);
 	const done = tasks.filter((t) => t.status === "done").length;
 	const cost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
-	const project = squad.cwd.split("/").pop();
-
-	const taskLines = tasks.map((t) => {
-		const icon = t.status === "done" ? "✓" : t.status === "in_progress" ? "⏳" : t.status === "failed" ? "✗" : t.status === "blocked" ? "◻" : "·";
-		return `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
-	}).join("\n");
-
-	ctx.ui.notify(
-		`Viewing: ${squad.id} [${squad.status}]\n` +
-		`Project: ${project}\n` +
-		`Tasks: ${done}/${tasks.length} done · $${cost.toFixed(2)}\n` +
-		taskLines,
-		"info",
-	);
+	ctx.ui.notify(`Viewing: ${squad.id} [${squad.status}] ${done}/${tasks.length} $${cost.toFixed(2)}`, "info");
 }
 
 // ============================================================================
-// Widget — live task status above the editor
+// Widget — component-based, event-driven (inspired by pi-interactive-shell)
 // ============================================================================
 
-function updateWidget(): void {
-	if (!uiCtx?.hasUI || !widgetEnabled || !activeSquadId) return;
-
-	const tasks = store.loadAllTasks(activeSquadId);
-	const squad = store.loadSquad(activeSquadId);
-	if (!squad || tasks.length === 0) return;
-
-	const th = uiCtx.ui.theme;
-
-	// Build widget lines
-	const lines: string[] = [];
-
-	const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
-	const doneCount = tasks.filter((t) => t.status === "done").length;
-	const elapsed = Date.now() - new Date(squad.created).getTime();
-	const elapsedStr = formatElapsedShort(elapsed);
-
-	// Header line with shortcut hint
-	const statusIcon = squad.status === "done" ? th.fg("success", "✓")
-		: squad.status === "failed" ? th.fg("error", "✗")
-		: th.fg("warning", "⏳");
-	const hint = th.fg("dim", "ctrl+q panel · /squad");
-	lines.push(
-		`${statusIcon} ${th.fg("accent", "squad")} ${th.fg("dim", squad.goal.slice(0, 30))} ` +
-		`${th.fg("muted", `${doneCount}/${tasks.length}`)} ` +
-		`${th.fg("dim", `$${totalCost.toFixed(2)}`)} ` +
-		`${th.fg("dim", elapsedStr)} ` +
-		`${hint}`
-	);
-
-	// Task lines
-	for (const task of tasks) {
-		const icon = task.status === "done" ? th.fg("success", "✓")
-			: task.status === "in_progress" ? th.fg("warning", "⏳")
-			: task.status === "failed" ? th.fg("error", "✗")
-			: task.status === "blocked" ? th.fg("muted", "◻")
-			: th.fg("dim", "·");
-
-		let line = `  ${icon} ${th.fg("muted", task.id)} ${th.fg("dim", `(${task.agent})`)}`;
-
-		// Show live activity for in_progress tasks
-		if (task.status === "in_progress") {
-			const messages = store.loadMessages(activeSquadId, task.id);
-			const lastTool = [...messages].reverse().find((m) => m.type === "tool");
-			const lastText = [...messages].reverse().find((m) => m.type === "text" && m.from !== "system");
-			if (lastTool) {
-				const toolPreview = lastTool.name || lastTool.text;
-				const argPreview = lastTool.args?.path || lastTool.args?.command || "";
-				const preview = argPreview ? `${toolPreview} ${argPreview}` : toolPreview;
-				line += ` ${th.fg("dim", "→ " + preview.slice(0, 40))}`;
-			} else if (lastText) {
-				line += ` ${th.fg("dim", lastText.text.split("\n")[0].slice(0, 40))}`;
-			}
-		} else if (task.status === "done" && task.output) {
-			line += ` ${th.fg("dim", task.output.split("\n")[0].slice(0, 40))}`;
-		} else if (task.status === "failed" && task.error) {
-			line += ` ${th.fg("error", task.error.slice(0, 40))}`;
-		} else if (task.status === "blocked") {
-			const blockers = task.depends.filter((d) => {
-				const dep = tasks.find((t) => t.id === d);
-				return dep && dep.status !== "done";
-			});
-			if (blockers.length > 0) {
-				line += ` ${th.fg("dim", "← " + blockers.join(", "))}`;
-			}
-		}
-
-		lines.push(line);
-	}
-
-	uiCtx.ui.setWidget("squad-tasks", lines);
-
-	// Footer status
-	const statusText = squad.status === "done"
-		? th.fg("success", `✓ squad ${doneCount}/${tasks.length}`)
-		: squad.status === "failed"
-		? th.fg("error", `✗ squad ${doneCount}/${tasks.length}`)
-		: th.fg("accent", `⏳ squad ${doneCount}/${tasks.length} $${totalCost.toFixed(2)}`);
-	uiCtx.ui.setStatus("squad", statusText);
-}
-
-function clearWidget(): void {
-	if (uiCtx?.hasUI) {
-		uiCtx.ui.setWidget("squad-tasks", undefined);
-		uiCtx.ui.setStatus("squad", undefined);
-	}
-}
-
-function startWidgetRefresh(): void {
-	if (widgetInterval) return;
-	updateWidget();
-	widgetInterval = setInterval(() => updateWidget(), 2000);
+/** Trigger widget re-render from scheduler events */
+function forceWidgetUpdate(): void {
+	widgetControls?.requestUpdate();
 }
 
-function clearWidgetRefresh(): void {
-	if (widgetInterval) {
-		clearInterval(widgetInterval);
-		widgetInterval = null;
-	}
-}
-
-function formatElapsedShort(ms: number): string {
-	const s = Math.floor(ms / 1000);
-	const m = Math.floor(s / 60);
-	const h = Math.floor(m / 60);
-	if (h > 0) return `${h}h${m % 60}m`;
-	if (m > 0) return `${m}m${s % 60}s`;
-	return `${s}s`;
-}
-
-/** Shared widget-enabled flag — declared in the extension body, referenced here */
-let widgetEnabled = true;
-
 // ============================================================================
-// Panel Creation
+// Panel — overlay via ctx.ui.custom() with proper done() lifecycle
 // ============================================================================
 
-function createPanel(
+/**
+ * Open the squad panel overlay.
+ * Uses the pi-interactive-shell pattern: ctx.ui.custom() returns a Promise
+ * that resolves when done() is called. The panel calls done() on close.
+ */
+function openPanel(
 	ctx: import("@mariozechner/pi-coding-agent").ExtensionContext,
 	scheduler: Scheduler,
 	squadId: string,
 ): void {
-	// Fire and forget — never awaited. The custom() Promise resolves when done() is called,
-	// but we never call done() because the panel is persistent.
-	ctx.ui.custom(
-		(tui, theme, _kb, _done) => {
-			const panel = new SquadPanel(tui, theme, scheduler, squadId);
-			activePanel = panel;
+	if (overlayOpen) return;
+	overlayOpen = true;
+
+	// The promise resolves when the panel calls done()
+	const panelPromise = ctx.ui.custom<SquadPanelResult>(
+		(tui, theme, _kb, done) => {
+			const panel = new SquadPanel(tui, theme, scheduler, squadId, done);
 
 			// Wire up message sending from panel
 			panel.onSendMessage = async (taskId: string, _prefill: string) => {
-				// Temporarily release panel focus so input dialog works
-				(panel as any).handle?.unfocus();
 				const task = store.loadTask(squadId, taskId);
 				const agentName = task?.agent || taskId;
 				const input = await ctx.ui.input(`Message to ${agentName}`, "Type your message...");
-				if (input && activeScheduler) {
-					await activeScheduler.sendHumanMessage(taskId, input);
+				const panelSched = schedulers.get(squadId);
+				if (input && panelSched) {
+					await panelSched.sendHumanMessage(taskId, input);
 					ctx.ui.notify(`Sent to ${agentName}: "${input.slice(0, 50)}"`, "info");
 				} else if (input) {
 					store.appendMessage(squadId, taskId, {
@@ -879,8 +1114,6 @@ function createPanel(
 					});
 					ctx.ui.notify(`Logged to ${taskId}`, "info");
 				}
-				// Re-focus panel after input
-				(panel as any).handle?.focus();
 				tui.requestRender();
 			};
 
@@ -888,29 +1121,22 @@ function createPanel(
 		},
 		{
 			overlay: true,
-			overlayOptions: () => {
-				const wide = (process.stdout.columns || 80) >= 160;
-				if (wide) {
-					return {
-						anchor: "top-right" as const,
-						width: "35%" as const,
-						maxHeight: "100%" as const,
-						margin: { top: 0, right: 0, bottom: 1, left: 0 },
-					};
-				}
-				return {
-					anchor: "center" as const,
-					width: "90%" as const,
-					maxHeight: "85%" as const,
-				};
-			},
-			onHandle: (handle) => {
-				if (activePanel) {
-					(activePanel as any).handle = handle;
-				}
+			overlayOptions: {
+				anchor: "center" as const,
+				width: "80%" as const,
+				maxHeight: "80%" as const,
+				margin: 2,
 			},
 		},
 	);
+
+	// When panel closes (done() called), clean up
+	panelPromise.then(() => {
+		overlayOpen = false;
+		forceWidgetUpdate();
+	}).catch(() => {
+		overlayOpen = false;
+	});
 }
 
 // ============================================================================
@@ -1019,16 +1245,18 @@ async function startSquad(
 
 	// Start scheduler
 	const scheduler = new Scheduler(squadId, skillPaths);
-	activeScheduler = scheduler;
+	schedulers.set(squadId, scheduler);
 	activeSquadId = squadId;
 
-	// Start live widget updates
-	startWidgetRefresh();
+	// Activate widget for this squad
+	widgetState.squadId = squadId;
+	widgetState.enabled = true;
+	widgetControls?.requestUpdate();
 
 	// Wire up completion/escalation notifications to main agent
 	scheduler.onEvent((event: SchedulerEvent) => {
 		// Update widget on every scheduler event
-		updateWidget();
+		forceWidgetUpdate();
 		switch (event.type) {
 			case "squad_completed": {
 				const tasks = store.loadAllTasks(squadId);
@@ -1039,21 +1267,24 @@ async function startSquad(
 				const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 
 				// Final context update before clearing scheduler
-				if (activeScheduler) {
-					activeScheduler.updateContext();
+				const completedSched = schedulers.get(squadId);
+				if (completedSched) {
+					completedSched.updateContext();
 				}
 
-				pi.sendUserMessage(
-					`[squad] Squad "${squadId}" completed all ${tasks.length} tasks.\n\n` +
-					`Summary:\n${summary}\n\n` +
-					`Total cost: $${totalCost.toFixed(4)}`,
-					{ deliverAs: "followUp" },
-				);
+				// Use sendMessage with display:true — visible to user but doesn't
+				// pollute LLM message history. No triggerTurn needed for completions.
+				pi.sendMessage({
+					customType: "squad-completed",
+					content: `[squad] Squad "${squadId}" completed all ${tasks.length} tasks.\n\n` +
+						`Summary:\n${summary}\n\n` +
+						`Total cost: $${totalCost.toFixed(4)}`,
+					display: true,
+				});
 
 				// Clear scheduler but keep activeSquadId so squad_status still works
-				activeScheduler = null;
-				clearWidgetRefresh();
-				updateWidget(); // Final update showing done state
+				schedulers.delete(squadId);
+				forceWidgetUpdate(); // Final update showing done state
 				break;
 			}
 
@@ -1062,32 +1293,42 @@ async function startSquad(
 				const failed = tasks.filter((t) => t.status === "failed");
 				const done = tasks.filter((t) => t.status === "done");
 
-				pi.sendUserMessage(
-					`[squad] Squad "${squadId}" has stalled. ` +
-					`${done.length}/${tasks.length} tasks done, ${failed.length} failed.\n` +
-					`Failed: ${failed.map((t) => `${t.id}: ${t.error?.slice(0, 100)}`).join("; ")}\n` +
-					`Use squad_status for details or squad_modify to adjust.`,
-					{ deliverAs: "followUp" },
-				);
-				clearWidgetRefresh();
-				updateWidget();
+				// Squad failed — notify user. Use triggerTurn so the agent can
+				// suggest next steps (retry, modify, cancel).
+				pi.sendMessage({
+					customType: "squad-failed",
+					content: `[squad] Squad "${squadId}" has stalled. ` +
+						`${done.length}/${tasks.length} tasks done, ${failed.length} failed.\n` +
+						`Failed: ${failed.map((t) => `${t.id}: ${t.error?.slice(0, 100)}`).join("; ")}\n` +
+						`Use squad_status for details or squad_modify to adjust.`,
+					display: true,
+				}, { triggerTurn: true });
+				forceWidgetUpdate();
 				break;
 			}
 
 			case "escalation": {
-				pi.sendUserMessage(
-					`[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n` +
-					`${event.message}\n\n` +
-					`Reply to me and I'll forward your answer, or use the squad panel.`,
-					{ deliverAs: "followUp" },
-				);
+				// Escalation — agent needs help. triggerTurn so the main agent
+				// can respond and relay help.
+				pi.sendMessage({
+					customType: "squad-escalation",
+					content: `[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n` +
+						`${event.message}\n\n` +
+						`Reply to me and I'll forward your answer, or use the squad panel.`,
+					display: true,
+				}, { triggerTurn: true });
 				break;
 			}
 		}
 	});
 
-	// Start scheduling
-	await scheduler.start();
+	// Start scheduling — fire and forget, don't block the tool call.
+	// scheduler.start() spawns agents which can take seconds per agent.
+	// We must return immediately so the main agent's turn completes
+	// and the user regains interactive control.
+	scheduler.start().catch((err) => {
+		console.error(`[squad] Scheduler start error: ${(err as Error).message}`);
+	});
 
 	// Build response
 	const taskSummary = plan.tasks