pi-squad 0.16.3 → 0.16.5

package/src/index.ts

@@ -176,6 +176,38 @@ function getActiveScheduler(): Scheduler | null {
 	return schedulers.get(activeSquadId) || null;
 }
 
+/** Reconstruct and focus one exact persisted squad without creating/linking another. */
+function ensureScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	let scheduler = schedulers.get(squadId);
+	if (!scheduler) {
+		scheduler = new Scheduler(squadId, skillPaths, schedulerSpawnContext);
+		schedulers.set(squadId, scheduler);
+		wireSchedulerEvents(pi, scheduler, squadId);
+	}
+	activeSquadId = squadId;
+	widgetState.squadId = squadId;
+	widgetState.enabled = true;
+	widgetControls?.requestUpdate();
+	return scheduler;
+}
+
+function isResumeCandidate(squad: Squad): boolean {
+	return squad.status === "paused" || squad.status === "failed" ||
+		(squad.status === "review" && squad.review?.status === "failed") ||
+		store.loadAllTasks(squad.id).some((task) => task.status === "suspended" || task.status === "failed");
+}
+
+function resolveResumeSquad(cwd: string, explicitId?: string): Squad | null {
+	if (explicitId) return store.loadSquad(explicitId);
+	if (activeSquadId) {
+		const active = store.loadSquad(activeSquadId);
+		if (active?.cwd === cwd && isResumeCandidate(active)) return active;
+	}
+	return store.listSquadsForProject(cwd)
+		.filter(isResumeCandidate)
+		.sort((a, b) => b.created.localeCompare(a.created))[0] ?? null;
+}
+
 
 // ============================================================================
 // Extension Entry
@@ -504,7 +536,7 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "squad_message",
 		label: "Squad Message",
-		description: "Send a request to a specific agent/task. The agent's next substantive assistant response is durably forwarded back to the main Pi session and wakes it.",
+		description: "Send a durable request to a specific task. Existing tasks reopen their original Pi session; only a currently running task may be selected by agent name.",
 		parameters: Type.Object({
 			message: Type.String({ description: "Message to send" }),
 			taskId: Type.Optional(Type.String({ description: "Target task ID" })),
@@ -513,23 +545,40 @@ export default function (pi: ExtensionAPI) {
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			const activeScheduler = getActiveScheduler();
-			if (!activeScheduler || !activeSquadId) {
+			if (!activeSquadId) {
 				return { content: [{ type: "text" as const, text: "No active squad." }], details: undefined };
 			}
 
+			let activeScheduler = getActiveScheduler();
 			let taskId = params.taskId;
 
-			// If agent specified but no taskId, find their current task
-			if (!taskId && params.agent) {
-				taskId = activeScheduler.getPool().getTaskIdForAgent(params.agent) || undefined;
+			// Agent name is safe shorthand only when it identifies one live task.
+			// Multiple concurrent tasks can share a role, so never guess between them.
+			if (!taskId && params.agent && activeScheduler) {
+				const liveMatches = store.loadAllTasks(activeSquadId).filter(
+					(task) => task.agent === params.agent && activeScheduler!.getPool().isRunning(task.id),
+				);
+				if (liveMatches.length === 1) taskId = liveMatches[0].id;
 			}
 
 			if (!taskId) {
 				return { content: [{ type: "text" as const, text: "Could not determine target task. Provide taskId or an agent name that is currently running." }], details: undefined };
 			}
+			if (!store.loadTask(activeSquadId, taskId)) {
+				return { content: [{ type: "text" as const, text: `Task not found: ${taskId}` }], details: undefined };
+			}
+
+			// Review/done squads have no live scheduler after a process restart. An
+			// exact task ID is enough to reconstruct it from disk and reopen only that
+			// task; the task's immutable session binding supplies --session.
+			if (!activeScheduler) {
+				activeScheduler = new Scheduler(activeSquadId, squadSkillPaths, schedulerSpawnContext);
+				schedulers.set(activeSquadId, activeScheduler);
+				wireSchedulerEvents(pi, activeScheduler, activeSquadId);
+				await activeScheduler.start();
+			}
 
-			const sent = await activeScheduler!.sendHumanMessage(taskId, params.message, params.expectReply ?? true);
+			const sent = await activeScheduler.sendHumanMessage(taskId, params.message, params.expectReply ?? true);
 			const status = sent ? "delivered" : "queued for when the agent starts";
 
 			return { content: [{ type: "text" as const, text: `Message ${status}: "${params.message}"` }], details: undefined };
@@ -543,8 +592,9 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "squad_modify",
 		label: "Squad Modify",
-		description: "Modify the running squad: add_task, cancel_task, complete_task (mark done + schedule dependents), pause, resume (also recovers failed squads), cancel (entire squad).",
+		description: "Modify one exact squad: add_task, cancel_task, complete_task (mark done + schedule dependents), pause, resume_task, resume (including failed-review rework), cancel. add_task/resume_task/resume reconstruct the persisted scheduler after restart.",
 		parameters: Type.Object({
+			squadId: Type.Optional(Type.String({ description: "Exact squad to modify (recommended for failed-review rework; default: focused/recoverable project squad)" })),
 			action: Type.Union(
 				[
 					Type.Literal("add_task"),
@@ -573,95 +623,37 @@ export default function (pi: ExtensionAPI) {
 		}),
 
 		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" || s.status === "failed"))
-					.sort((a, b) => b.created.localeCompare(a.created))[0]?.id;
-
-				if (!squadId) {
-					return { content: [{ type: "text" as const, text: "No paused or failed squad found to resume." }], details: undefined };
+				const squad = resolveResumeSquad(ctx.cwd, params.squadId);
+				if (!squad) {
+					const text = params.squadId
+						? `Squad '${params.squadId}' not found.`
+						: "No paused, failed, or failed-review squad found to resume.";
+					return { content: [{ type: "text" as const, text }], details: undefined };
 				}
-
-				// Create a fresh scheduler if needed
-				if (!schedulers.has(squadId)) {
-					const scheduler = new Scheduler(squadId, squadSkillPaths, schedulerSpawnContext);
-					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_review_required": {
-								const tasks = store.loadAllTasks(squadId);
-								const summary = buildCompletionSummary(tasks);
-								const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
-								const s = schedulers.get(squadId); if (s) s.updateContext();
-								const squad = store.loadSquad(squadId)!;
-								// Wake the main agent into an explicit acceptance gate. Agent reports
-								// are untrusted inputs; only independent orchestrator evidence can pass it.
-								pi.sendMessage({
-									customType: "squad-review-required",
-									content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\nSquad claims (review inputs only):\n${summary}\n\nTotal cost: $${totalCost.toFixed(4)}\n\n${buildOrchestratorReviewGate(squad, tasks)}`,
-									display: true,
-								}, { triggerTurn: true, deliverAs: "followUp" });
-								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: ${buildFailureSummary(tasks)}`,
-									display: true,
-								}, { triggerTurn: true, deliverAs: "followUp" });
-								forceWidgetUpdate();
-								break;
-							}
-							case "orchestrator_reply": {
-								pi.sendMessage({
-									customType: "squad-agent-reply",
-									content: `[squad] Direct reply from '${event.agentName}' on task '${event.taskId}':\n${event.message}`,
-									display: true,
-								}, { triggerTurn: true, deliverAs: "followUp" });
-								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 = ensureScheduler(pi, squad.id, squadSkillPaths);
+				try {
+					await resumeSched.resume();
+				} catch (err) {
+					return { content: [{ type: "text" as const, text: `Resume failed: ${(err as Error).message}` }], details: undefined };
 				}
-
-				const resumeSched = schedulers.get(squadId)!;
-				resumeSched.resume().catch((err) => {
-					logError("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.` }], details: undefined };
+				const tasks = store.loadAllTasks(squad.id);
+				const done = tasks.filter((task) => task.status === "done").length;
+				return { content: [{ type: "text" as const, text: `Squad "${squad.id}" resumed (${done}/${tasks.length} done). Agents restarting in background.` }], details: undefined };
 			}
 
-			const activeScheduler = getActiveScheduler();
-			if (!activeScheduler || !activeSquadId) {
-				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." }], details: undefined };
+			const squadId = params.squadId || activeSquadId;
+			if (!squadId || !store.loadSquad(squadId)) {
+				return { content: [{ type: "text" as const, text: params.squadId ? `Squad '${params.squadId}' not found.` : "No active squad. Provide squadId, select the squad, or start a new one." }], details: undefined };
 			}
+			let activeScheduler = schedulers.get(squadId) || null;
+			if (!activeScheduler && (params.action === "add_task" || params.action === "resume_task")) {
+				activeScheduler = ensureScheduler(pi, squadId, squadSkillPaths);
+			}
+			if (!activeScheduler) {
+				return { content: [{ type: "text" as const, text: `Squad '${squadId}' has no active scheduler. Use resume, add_task, or resume_task to reconstruct it.` }], details: undefined };
+			}
+			activeSquadId = squadId;
 
 			switch (params.action) {
 				case "add_task": {
@@ -678,17 +670,19 @@ export default function (pi: ExtensionAPI) {
 					if (badDeps.length > 0) {
 						return { content: [{ type: "text" as const, text: `Unknown dependency task(s): ${badDeps.join(", ")}. Existing tasks: ${[...existingIds].join(", ")}` }], details: undefined };
 					}
-					if (!store.loadAgentDef(params.task.agent, ctx.cwd)) {
-						const available = store.loadAllAgentDefs(ctx.cwd).filter((a) => !a.disabled).map((a) => a.name).join(", ");
+					const targetCwd = store.loadSquad(squadId)!.cwd;
+					if (!store.loadAgentDef(params.task.agent, targetCwd)) {
+						const available = store.loadAllAgentDefs(targetCwd).filter((a) => !a.disabled).map((a) => a.name).join(", ");
 						return { content: [{ type: "text" as const, text: `Unknown agent '${params.task.agent}'. Available: ${available}` }], details: undefined };
 					}
+					const dependencies = params.task.depends || [];
 					const task: Task = {
 						id: params.task.id,
 						title: params.task.title,
 						description: params.task.description || "",
 						agent: params.task.agent,
-						status: "pending",
-						depends: params.task.depends || [],
+						status: dependencies.every((dependency) => existing.find((candidate) => candidate.id === dependency)?.status === "done") ? "pending" : "blocked",
+						depends: dependencies,
 						...(params.task.inheritContext ? { inheritContext: true } : {}),
 						created: store.now(),
 						started: null,
@@ -697,9 +691,12 @@ export default function (pi: ExtensionAPI) {
 						error: null,
 						usage: { inputTokens: 0, outputTokens: 0, cost: 0, turns: 0 },
 					};
-					store.createTask(activeSquadId, task);
-					activeScheduler.updateContext();
-					return { content: [{ type: "text" as const, text: `Task '${task.id}' added.` }], details: undefined };
+					try {
+						await activeScheduler.addTask(task);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `add_task failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${task.id}' added to squad '${squadId}'.` }], details: undefined };
 				}
 
 				case "cancel_task": {
@@ -716,10 +713,12 @@ export default function (pi: ExtensionAPI) {
 
 				case "resume_task": {
 					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
-					activeScheduler.resumeTask(params.taskId).catch((err) => {
-						logError("squad", `Resume task error: ${(err as Error).message}`);
-					});
-					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed.` }], details: undefined };
+					try {
+						await activeScheduler.resumeTask(params.taskId);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `resume_task failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed in squad '${squadId}'.` }], details: undefined };
 				}
 
 				case "complete_task": {
@@ -795,6 +794,29 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
+		// Mailbox recovery is automatic after extension/main-process restart. Scan
+		// every project squad (including accepted done squads) because a crash can
+		// occur after the mailbox-first write but before the squad/task is reopened.
+		const pendingMailSquads = store.listSquadsForProject(ctx.cwd)
+			.filter((squad) => store.loadAllTasks(squad.id)
+				.some((task) => store.loadPendingTaskMessages(squad.id, task.id).length > 0))
+			.sort((a, b) => b.created.localeCompare(a.created));
+		for (const squad of pendingMailSquads) {
+			let scheduler = schedulers.get(squad.id);
+			if (!scheduler) {
+				scheduler = new Scheduler(squad.id, squadSkillPaths, schedulerSpawnContext);
+				schedulers.set(squad.id, scheduler);
+				wireSchedulerEvents(pi, scheduler, squad.id);
+			}
+			await scheduler.start();
+		}
+		if (pendingMailSquads.length > 0) {
+			activeSquadId = pendingMailSquads[0].id;
+			widgetState.squadId = activeSquadId;
+			widgetState.enabled = true;
+			widgetControls?.requestUpdate();
+		}
+
 		// Notify about paused squads only if they have real completed work
 		const paused = store.findActiveSquads()
 			.filter((s) => s.cwd === ctx.cwd && s.status === "paused");
@@ -851,7 +873,7 @@ export default function (pi: ExtensionAPI) {
 					}
 
 					if (activeSquadId) {
-						openPanel(ctx, schedulers.get(activeSquadId) || new Scheduler(activeSquadId, squadSkillPaths, schedulerSpawnContext), activeSquadId);
+						openPanel(pi, ctx, schedulers.get(activeSquadId) || new Scheduler(activeSquadId, squadSkillPaths, schedulerSpawnContext), activeSquadId);
 					}
 					return { consume: true };
 				}
@@ -876,16 +898,17 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 
 	pi.registerCommand("squad", {
-		description: "Browse, select, and manage squads. Usage: /squad [list|all|select|agents|msg|widget|panel|cancel|clear]",
+		description: "Browse, select, and manage squads. Usage: /squad [list|all|select|resume|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: "resume", label: "resume", description: "Resume an exact paused/failed/failed-review squad" },
 				{ value: "agents", label: "agents", description: "List, view, or edit agent definitions" },
 				{ value: "defaults", label: "defaults", description: "Default model/thinking for agents (follow main session, pi default, or fixed)" },
 				{ value: "advisor", label: "advisor", description: "Advisor-first rescue for stuck agents (on/off, model, limits)" },
-				{ value: "msg", label: "msg", description: "Send message to agent: /squad msg [agent] text" },
+				{ value: "msg", label: "msg", description: "Message a task: /squad msg [task-id|running-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" },
@@ -951,6 +974,25 @@ export default function (pi: ExtensionAPI) {
 					return;
 				}
 
+				case "resume": {
+					const squad = resolveResumeSquad(ctx.cwd, parts[1]);
+					if (!squad) {
+						ctx.ui.notify(parts[1] ? `Squad '${parts[1]}' not found` : "No paused, failed, or failed-review squad found", "warning");
+						return;
+					}
+					const scheduler = ensureScheduler(pi, squad.id, squadSkillPaths);
+					try {
+						await scheduler.resume();
+					} catch (error) {
+						ctx.ui.notify(`Resume failed: ${(error as Error).message}`, "error");
+						return;
+					}
+					const tasks = store.loadAllTasks(squad.id);
+					const done = tasks.filter((task) => task.status === "done").length;
+					ctx.ui.notify(`Resumed: ${squad.id} (${done}/${tasks.length} done)`, "info");
+					return;
+				}
+
 				case "widget": {
 					widgetState.enabled = !widgetState.enabled;
 					if (widgetState.enabled) {
@@ -978,7 +1020,7 @@ export default function (pi: ExtensionAPI) {
 					}
 					if (activeSquadId) {
 						const sched = schedulers.get(activeSquadId) || new Scheduler(activeSquadId, squadSkillPaths, schedulerSpawnContext);
-						openPanel(ctx, sched, activeSquadId);
+						openPanel(pi, ctx, sched, activeSquadId);
 					}
 					return;
 				}
@@ -989,11 +1031,8 @@ export default function (pi: ExtensionAPI) {
 						return;
 					}
 					const msgSquad = store.loadSquad(activeSquadId);
-					if (!msgSquad || msgSquad.status !== "running") {
-						ctx.ui.notify("Squad is not running — messages only reach running agents.", "info");
-						return;
-					}
-					// Parse: /squad msg [agent] message text
+					if (!msgSquad) return;
+					// Parse: /squad msg [task-id|running-agent] message text
 					const msgParts = parts.slice(1);
 					let targetAgent: string | undefined;
 					let msgText: string;
@@ -1014,40 +1053,51 @@ export default function (pi: ExtensionAPI) {
 						}
 					}
 
-					// Find target task
+					// Find one exact target task. A task ID can address completed or
+					// stopped work; an agent name remains shorthand for a live task only.
 					const msgTasks = store.loadAllTasks(activeSquadId);
 					let targetTaskId: string | undefined;
-
-					if (targetAgent) {
-						const agentTask = msgTasks.find((t) => t.agent === targetAgent && t.status === "in_progress");
-						targetTaskId = agentTask?.id;
+					const explicitTask = msgParts.length > 1
+						? msgTasks.find((task) => task.id === msgParts[0])
+						: undefined;
+					if (explicitTask) {
+						targetTaskId = explicitTask.id;
+						targetAgent = explicitTask.agent;
+						msgText = msgParts.slice(1).join(" ");
+					} else if (targetAgent) {
+						const liveMatches = msgTasks.filter(
+							(task) => task.agent === targetAgent && getActiveScheduler()?.getPool().isRunning(task.id),
+						);
+						if (liveMatches.length === 1) targetTaskId = liveMatches[0].id;
 						if (!targetTaskId) {
-							ctx.ui.notify(`Agent '${targetAgent}' has no running task`, "warning");
+							ctx.ui.notify(`Agent '${targetAgent}' is not working on exactly one live task; provide an exact task ID`, "warning");
 							return;
 						}
 					} else {
-						const runningTask = msgTasks.find((t) => t.status === "in_progress");
-						targetTaskId = runningTask?.id;
-						targetAgent = runningTask?.agent;
-						if (!targetTaskId) {
-							ctx.ui.notify("No running tasks to message", "warning");
+						const liveTasks = msgTasks.filter((task) =>
+							getActiveScheduler()?.getPool().isRunning(task.id),
+						);
+						if (liveTasks.length === 1) {
+							targetTaskId = liveTasks[0].id;
+							targetAgent = liveTasks[0].agent;
+						} else {
+							ctx.ui.notify("No unique live task to message; provide an exact task ID", "warning");
 							return;
 						}
 					}
 
-					const msgSched = getActiveScheduler();
-					if (msgSched) {
-						await msgSched.sendHumanMessage(targetTaskId, msgText);
-						ctx.ui.notify(`Sent to ${targetAgent}: "${msgText}"`, "info");
-					} else {
-						store.appendMessage(activeSquadId, targetTaskId, {
-							ts: store.now(),
-							from: "human",
-							type: "message",
-							text: msgText,
-						});
-						ctx.ui.notify(`Logged to ${targetTaskId} (agent not running)`, "info");
+					let msgSched = getActiveScheduler();
+					if (!msgSched) {
+						msgSched = new Scheduler(activeSquadId, squadSkillPaths, schedulerSpawnContext);
+						schedulers.set(activeSquadId, msgSched);
+						wireSchedulerEvents(pi, msgSched, activeSquadId);
+						await msgSched.start();
 					}
+					const delivered = await msgSched.sendHumanMessage(targetTaskId, msgText);
+					ctx.ui.notify(
+						delivered ? `Sent to ${targetAgent}: "${msgText}"` : `Queued durably for ${targetTaskId}`,
+						"info",
+					);
 					forceWidgetUpdate();
 					return;
 				}
@@ -1400,7 +1450,7 @@ export default function (pi: ExtensionAPI) {
 						activateSquadView(direct.id, ctx);
 						return;
 					}
-					ctx.ui.notify(`Unknown: /squad ${sub}. Try: list, all, select, agents, defaults, msg, widget, panel, cancel, clear, cleanup`, "warning");
+					ctx.ui.notify(`Unknown: /squad ${sub}. Try: list, all, select, resume, agents, defaults, msg, widget, panel, cancel, clear, cleanup`, "warning");
 			}
 		},
 	});
@@ -1475,6 +1525,63 @@ function forceWidgetUpdate(): void {
 	widgetControls?.requestUpdate();
 }
 
+/** Wire one scheduler to durable main-session notifications. */
+function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squadId: string): void {
+	scheduler.onEvent((event: SchedulerEvent) => {
+		forceWidgetUpdate();
+		switch (event.type) {
+			case "squad_review_required": {
+				const tasks = store.loadAllTasks(squadId);
+				const summary = buildCompletionSummary(tasks);
+				const totalCost = tasks.reduce((sum, task) => sum + task.usage.cost, 0);
+				scheduler.updateContext();
+				const squad = store.loadSquad(squadId);
+				if (!squad) break;
+				pi.sendMessage({
+					customType: "squad-review-required",
+					content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
+						`Squad claims (review inputs only):\n${summary}\n\n` +
+						`Total cost: $${totalCost.toFixed(4)}\n\n` +
+						buildOrchestratorReviewGate(squad, tasks),
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				// Keep the settled scheduler addressable. A later exact-task message
+				// can reopen the task immediately on its bound durable Pi session.
+				break;
+			}
+			case "squad_failed": {
+				const tasks = store.loadAllTasks(squadId);
+				const failed = tasks.filter((task) => task.status === "failed");
+				const done = tasks.filter((task) => task.status === "done");
+				pi.sendMessage({
+					customType: "squad-failed",
+					content: `[squad] Squad "${squadId}" has stalled. ` +
+						`${done.length}/${tasks.length} tasks done, ${failed.length} failed.\n` +
+						`Failed: ${buildFailureSummary(tasks)}\n` +
+						"Use squad_status for details or squad_modify to adjust.",
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			}
+			case "orchestrator_reply":
+				pi.sendMessage({
+					customType: "squad-agent-reply",
+					content: `[squad] Direct reply from '${event.agentName}' on task '${event.taskId}':\n${event.message}`,
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			case "escalation":
+				pi.sendMessage({
+					customType: "squad-escalation",
+					content: `[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n` +
+						`${event.message}\n\nReply to me and I'll forward your answer, or use the squad panel.`,
+					display: true,
+				}, { triggerTurn: true });
+				break;
+		}
+	});
+}
+
 // ============================================================================
 // Panel — overlay via ctx.ui.custom() with proper done() lifecycle
 // ============================================================================
@@ -1485,6 +1592,7 @@ function forceWidgetUpdate(): void {
  * that resolves when done() is called. The panel calls done() on close.
  */
 function openPanel(
+	pi: ExtensionAPI,
 	ctx: import("@earendil-works/pi-coding-agent").ExtensionContext,
 	scheduler: Scheduler,
 	squadId: string,
@@ -1502,18 +1610,19 @@ function openPanel(
 				const task = store.loadTask(squadId, taskId);
 				const agentName = task?.agent || taskId;
 				const input = await ctx.ui.input(`Message to ${agentName}`, "Type your message...");
-				const panelSched = schedulers.get(squadId);
-				if (input && panelSched) {
-					await panelSched.sendHumanMessage(taskId, input);
-					ctx.ui.notify(`Sent to ${agentName}: "${input}"`, "info");
-				} else if (input) {
-					store.appendMessage(squadId, taskId, {
-						ts: store.now(),
-						from: "human",
-						type: "message",
-						text: input,
-					});
-					ctx.ui.notify(`Logged to ${taskId}`, "info");
+				if (input) {
+					let panelSched = schedulers.get(squadId);
+					if (!panelSched) {
+						panelSched = scheduler;
+						schedulers.set(squadId, panelSched);
+						wireSchedulerEvents(pi, panelSched, squadId);
+						await panelSched.start();
+					}
+					const delivered = await panelSched.sendHumanMessage(taskId, input);
+					ctx.ui.notify(
+						delivered ? `Sent to ${agentName}: "${input}"` : `Queued durably for ${taskId}`,
+						"info",
+					);
 				}
 				tui.requestRender();
 			};
@@ -1666,82 +1775,8 @@ async function startSquad(
 	widgetState.enabled = true;
 	widgetControls?.requestUpdate();
 
-	// Wire up completion/escalation notifications to main agent
-	scheduler.onEvent((event: SchedulerEvent) => {
-		// Update widget on every scheduler event
-		forceWidgetUpdate();
-		switch (event.type) {
-				case "squad_review_required": {
-				const tasks = store.loadAllTasks(squadId);
-				const summary = buildCompletionSummary(tasks);
-				const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
-
-				// Final context update before clearing scheduler
-				const completedSched = schedulers.get(squadId);
-				if (completedSched) {
-					completedSched.updateContext();
-				}
-				const squad = store.loadSquad(squadId)!;
-
-				// Wake the main agent into an explicit acceptance gate. Never frame
-				// agent execution or squad QA as trusted completion.
-				pi.sendMessage({
-					customType: "squad-review-required",
-					content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
-						`Squad claims (review inputs only):\n${summary}\n\n` +
-						`Total cost: $${totalCost.toFixed(4)}\n\n` +
-						buildOrchestratorReviewGate(squad, tasks),
-					display: true,
-				}, { triggerTurn: true, deliverAs: "followUp" });
-
-				// Clear scheduler but keep activeSquadId so squad_status still works
-				schedulers.delete(squadId);
-				forceWidgetUpdate(); // Final update showing done state
-				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} tasks done, ${failed.length} failed.\n` +
-						`Failed: ${buildFailureSummary(tasks)}\n` +
-						`Use squad_status for details or squad_modify to adjust.`,
-					display: true,
-				}, { triggerTurn: true, deliverAs: "followUp" });
-				forceWidgetUpdate();
-				break;
-			}
-
-			case "orchestrator_reply": {
-				// Push the complete requested response back into the main session and
-				// wake it; ordinary task activity remains panel-only.
-				pi.sendMessage({
-					customType: "squad-agent-reply",
-					content: `[squad] Direct reply from '${event.agentName}' on task '${event.taskId}':\n${event.message}`,
-					display: true,
-				}, { triggerTurn: true, deliverAs: "followUp" });
-				break;
-			}
-
-			case "escalation": {
-				// 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;
-			}
-		}
-	});
+	// Wire up completion/escalation notifications to main agent.
+	wireSchedulerEvents(pi, scheduler, squadId);
 
 	// Start scheduling — fire and forget, don't block the tool call.
 	// scheduler.start() spawns agents which can take seconds per agent.