pi-squad 0.16.5 → 0.16.7

package/README.md

@@ -56,6 +56,7 @@ Squad agents—including QA/reviewer agents—produce candidate work and evidenc
 - Failed review is reworked in the **same authoritative squad**: use `squad_modify` with that `squadId` and `add_task` or `resume_task` (or `resume` when interrupted work exists). These operations reconstruct the scheduler after restart. `/squad resume <squad-id>` provides the same resume path.
 - When rework begins, the failed attempt moves to `reviewHistory`, the squad returns to `running`, and its evidence remains auditable. After every rework task settles, a fresh pending review becomes the active gate and `squad_review` is required again.
 - Pending and failed review gates survive Pi restarts and are restored on the next session. A separate squad never links to, remediates, or accepts the failed gate.
+- Every UI/status surface keeps execution progress adjacent to an explicit acceptance state: `◆ REVIEW PENDING · independent review required` means no verdict exists yet; `✗ REVIEW FAILED · awaiting same-squad rework` means the candidate was rejected. A truthful `3/3` task count never means a failed candidate was accepted.
 
 The completion report is explicitly labeled **untrusted and not yet accepted**. Main Pi must never merely relay it or ask whether verification should be run.
 
@@ -77,6 +78,18 @@ architect → frontend ─┘
 
 Architect runs first. Backend and frontend run in parallel after architect completes. QA waits for both.
 
+### Suspended Work Requires Explicit Action
+
+Suspension is an explicit pause, not a retry signal. If every remaining non-cancelled task is suspended or transitively blocked by suspended work, pi-squad durably wakes the main orchestrator once for that exact stall state. The widget shows `⚠ SUSPENDED — explicit resume required`; `squad_status` and the detail panel list every exact suspended task ID and blocked descendant.
+
+Nothing resumes automatically. Choose each task intentionally with an exact squad and task ID:
+
+```javascript
+squad_modify({ action: "resume_task", squadId: "<exact-squad-id>", taskId: "<exact-task-id>" })
+```
+
+Repeated reconciliation and restart do not create notification storms. A delivered stall remains visible until explicit resumption changes the state; a different suspended/blocked set is a new actionable episode.
+
 ### QA Rework Loop
 
 When a QA agent outputs `## Verdict: FAIL`, the scheduler automatically:
@@ -156,9 +169,13 @@ When the main agent provides tasks directly (via the `tasks` parameter), unknown
 
 ### Widget (above editor)
 
-Shows live squad progress. Truncated to terminal width — no wrapping, deterministic height.
+Shows live execution progress plus a distinct acceptance/attention state. Truncation is viewport-only: no wrapping, deterministic height, with complete IDs and evidence retained for detail/status output.
 
 ```
+◆ squad Build task API 3/3 · ◆ REVIEW PENDING · independent review required
+✗ squad Build task API 3/3 · ✗ REVIEW FAILED · awaiting same-squad rework
+⚠ SUSPENDED — explicit resume required · ^q detail
+
 ⏳ squad Build task API 2/3 $0.58 3m12s  ^q detail · /squad msg
   ✓ api (backend) 2m12s Created CRUD REST API with validation
   ⏳ tests (qa) 45s → bash npm test
@@ -197,7 +214,7 @@ Full overlay with task list, live activity preview, and scrollable message view.
 | `/squad msg [task-id\|running-agent] text` | Message an exact task, or use an agent name only when it has one live task |
 | `/squad widget` | Toggle widget |
 | `/squad panel` | Toggle panel |
-| `/squad cancel` | Cancel running squad |
+| `/squad cancel` | Cancel the visibly focused squad; the notification names it and the focused widget/status clear |
 | `/squad clear` | Dismiss widget |
 | `/squad cleanup` | Delete squad data |
 | `/squad enable/disable` | Enable/disable the extension |
@@ -209,7 +226,13 @@ Full overlay with task list, live activity preview, and scrollable message view.
 | `squad` | Start a squad with goal + optional tasks/config |
 | `squad_status` | Check progress, costs, task states |
 | `squad_message` | Durably message an exact task; completed tasks reopen on their original session |
-| `squad_modify` | Add/cancel/complete/pause/resume tasks or squads; accepts `squadId` for exact same-squad failed-review rework |
+| `squad_modify` | Add/cancel/complete/pause/resume tasks or squads, or replace a task's dependencies with `set_dependencies`; exact `squadId` is required for destructive whole-squad `cancel` and recommended for all task actions |
+
+Tool-level whole-squad cancellation never infers a target: `squad_modify({ action: "cancel", squadId: "<exact-squad-id>" })` affects only that persisted squad and names it in the result. Omitting `squadId` is rejected without changing any squad. Interactive `/squad cancel` instead uses the squad visibly focused in the current UI and names the affected squad.
+
+Dependency repair uses top-level `taskId` and `depends`, for example `squad_modify({ action: "set_dependencies", taskId: "publish", depends: ["build"] })`. The replacement is validated atomically (known IDs, no self-reference, duplicates, or cycles) and is allowed only while the task is not running or done.
+
+`cancel_task` is refused while any non-cancelled task directly depends on the target. Update every listed dependent explicitly with `set_dependencies`, then retry cancellation. Cancellation never cascades to dependents and never rewrites their dependency lists automatically; cancelled tasks remain visible in squad history and can be revived only with explicit `resume_task`.
 
 The main agent sees available agents in its system prompt and squad state when a squad is active.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-squad",
-  "version": "0.16.5",
+  "version": "0.16.7",
   "description": "Multi-agent collaboration extension for pi — task decomposition, dependency management, parallel execution, TUI panel",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -14,9 +14,9 @@ import * as path from "node:path";
 import * as fs from "node:fs";
 import { Type } from "typebox";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Squad, Task, SquadConfig, PlannerOutput } from "./types.js";
+import type { Squad, Task, SquadConfig, PlannerOutput, SuspendedStallAttention } from "./types.js";
 import { DEFAULT_SQUAD_CONFIG, THINKING_LEVELS } from "./types.js";
-import { Scheduler, type SchedulerEvent, type SchedulerSpawnContext } from "./scheduler.js";
+import { Scheduler, formatSuspendedStallAttention, type SchedulerEvent, type SchedulerSpawnContext } from "./scheduler.js";
 import { runPlanner } from "./planner.js";
 import { validatePlan, PLAN_STRUCTURE_RULES } from "./plan-rules.js";
 import { ADVISOR_SYSTEM_PROMPT, buildAdvisorConsultText, type AdvisorConsultInput } from "./advisor.js";
@@ -27,6 +27,7 @@ import * as store from "./store.js";
 import { debug, logError } from "./logger.js";
 import { buildCompletionSummary, buildFailureSummary } from "./report.js";
 import { buildOrchestratorReviewGate, recordOrchestratorReview } from "./review.js";
+import { formatSuspendedAttention, getReviewPresentation } from "./presentation.js";
 
 // ============================================================================
 // State
@@ -46,6 +47,16 @@ let uiCtx: import("@earendil-works/pi-coding-agent").ExtensionContext | null = n
 const widgetState: SquadWidgetState = { squadId: null, enabled: true };
 let widgetControls: { requestUpdate: () => void; dispose: () => void } | null = null;
 
+/** Format completion against active work while retaining cancelled history. */
+function formatTaskProgress(tasks: Task[]): string {
+	const done = tasks.filter((task) => task.status === "done").length;
+	const cancelled = tasks.filter((task) => task.status === "cancelled").length;
+	const active = tasks.length - cancelled;
+	return cancelled > 0
+		? `${done}/${active} active tasks done · ${cancelled} cancelled · ${tasks.length} total`
+		: `${done}/${tasks.length} tasks done`;
+}
+
 /**
  * Resolve a model string (or null = session default) to its context window.
  * Reads uiCtx lazily so it always uses the live session's registry.
@@ -176,6 +187,21 @@ function getActiveScheduler(): Scheduler | null {
 	return schedulers.get(activeSquadId) || null;
 }
 
+/** Restore the single focus/widget invariant after destructive exact cancellation. */
+function repairFocusAfterCancellation(cancelledId: string): void {
+	if (activeSquadId === cancelledId || (activeSquadId !== null && !store.loadSquad(activeSquadId))) {
+		activeSquadId = null;
+	}
+	widgetState.squadId = activeSquadId;
+	widgetControls?.requestUpdate();
+}
+
+function activeSuspendedAttentionForProject(cwd: string): Array<{ squadId: string; attention: SuspendedStallAttention }> {
+	return store.listSquadsForProject(cwd)
+		.filter((squad) => Boolean(squad.suspendedStallAttention))
+		.map((squad) => ({ squadId: squad.id, attention: squad.suspendedStallAttention! }));
+}
+
 /** 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);
@@ -234,6 +260,24 @@ export default function (pi: ExtensionAPI) {
 	const skillsDir = path.join(path.dirname(new URL(import.meta.url).pathname), "skills");
 	const squadSkillPaths = getSquadSkillPaths(skillsDir);
 
+	/** Cancel one persisted exact squad without ever inferring or changing focus. */
+	const cancelExactSquad = async (squadId: string): Promise<boolean> => {
+		const squad = store.loadSquad(squadId);
+		if (!squad) return false;
+		const live = schedulers.get(squadId);
+		if (live) await live.stop();
+		else await new Scheduler(squadId, squadSkillPaths, schedulerSpawnContext).stop();
+		const fresh = store.loadSquad(squadId);
+		if (fresh) {
+			fresh.status = "failed";
+			delete fresh.suspendedStallAttention;
+			store.saveSquad(fresh);
+		}
+		schedulers.delete(squadId);
+		repairFocusAfterCancellation(squadId);
+		return true;
+	};
+
 	// =========================================================================
 	// Context Injection — give main agent awareness of squad state
 	// =========================================================================
@@ -245,9 +289,12 @@ export default function (pi: ExtensionAPI) {
 		const pendingReviewGates = store.findActiveSquads()
 			.filter((s) => s.cwd === ctx.cwd && s.status === "review")
 			.map((s) => ({ squad: s, gate: buildOrchestratorReviewGate(s, store.loadAllTasks(s.id)) }));
+		const suspendedAttention = activeSuspendedAttentionForProject(ctx.cwd)
+			.map(({ squadId, attention }) => formatSuspendedStallAttention(squadId, attention));
+		const durablePrompts = [...pendingReviewGates.map(({ gate }) => gate), ...suspendedAttention];
 		if (!squadEnabled) {
-			if (pendingReviewGates.length === 0) return;
-			return { systemPrompt: event.systemPrompt + "\n\n" + pendingReviewGates.map(({ gate }) => gate).join("\n\n") };
+			if (durablePrompts.length === 0) return;
+			return { systemPrompt: event.systemPrompt + "\n\n" + durablePrompts.join("\n\n") };
 		}
 
 		// When a squad is active, inject its status
@@ -255,38 +302,41 @@ export default function (pi: ExtensionAPI) {
 			const squad = store.loadSquad(activeSquadId);
 			if (!squad) {
 				activeSquadId = null;
-				if (pendingReviewGates.length > 0) {
-					return { systemPrompt: event.systemPrompt + "\n\n" + pendingReviewGates.map(({ gate }) => gate).join("\n\n") };
+				widgetState.squadId = null;
+				if (durablePrompts.length > 0) {
+					return { systemPrompt: event.systemPrompt + "\n\n" + durablePrompts.join("\n\n") };
 				}
 				return;
 			}
 			const tasks = store.loadAllTasks(activeSquadId);
 			if (tasks.length === 0) {
-				if (pendingReviewGates.length > 0) {
-					return { systemPrompt: event.systemPrompt + "\n\n" + pendingReviewGates.map(({ gate }) => gate).join("\n\n") };
+				if (durablePrompts.length > 0) {
+					return { systemPrompt: event.systemPrompt + "\n\n" + durablePrompts.join("\n\n") };
 				}
 				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" ? "◻" : "·";
+				const icon = t.status === "done" ? "✓" : t.status === "in_progress" ? "⏳" : t.status === "failed" ? "✗" : t.status === "blocked" ? "◻" : t.status === "suspended" ? "⏸" : t.status === "cancelled" ? "⊘" : "·";
 				let line = `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
 				if (t.output) line += ` — ${t.output}`;
 				if (t.error) line += ` ERROR: ${t.error}`;
 				return line;
 			}).join("\n");
 
+			const reviewPresentation = getReviewPresentation(squad);
 			const squadContext = [
 				`<squad_status>`,
 				`Squad: ${squad.id} — ${squad.goal}`,
-				`Status: ${squad.status} | ${doneCount}/${tasks.length} tasks | $${totalCost.toFixed(2)}`,
+				`Status: ${squad.status} | ${formatTaskProgress(tasks)} | $${totalCost.toFixed(2)}`,
+				...(reviewPresentation ? [`Acceptance: ${reviewPresentation.label}`] : []),
 				taskLines,
 				`</squad_status>`,
 				...(squad.status === "review" ? [buildOrchestratorReviewGate(squad, tasks)] : []),
 				...pendingReviewGates.filter(({ squad: pending }) => pending.id !== squad.id).map(({ gate }) => gate),
+				...suspendedAttention,
 				`You have an active squad. Use squad_message to talk to agents, squad_status for details, squad_modify to change tasks.`,
 				`Do NOT poll squad_status in a loop or sleep-wait — the squad wakes you automatically on completion, failure, or escalation. Keep helping the user with other work, or end your turn and stay idle.`,
 			].join("\n");
@@ -314,7 +364,7 @@ export default function (pi: ExtensionAPI) {
 
 		return {
 			systemPrompt: event.systemPrompt + "\n\n" + squadNudge +
-				(pendingReviewGates.length > 0 ? "\n\n" + pendingReviewGates.map(({ gate }) => gate).join("\n\n") : ""),
+				(durablePrompts.length > 0 ? "\n\n" + durablePrompts.join("\n\n") : ""),
 		};
 	});
 
@@ -443,6 +493,8 @@ export default function (pi: ExtensionAPI) {
 						task.status === "in_progress" ? "⏳" :
 						task.status === "blocked" ? "◻" :
 						task.status === "failed" ? "✗" :
+						task.status === "suspended" ? "⏸" :
+						task.status === "cancelled" ? "⊘" :
 						"·";
 					let line = `${icon} ${taskId} (${task.agent}) — ${task.title} [${task.status}]`;
 					if (task.blockedBy?.length) line += ` blocked by: ${task.blockedBy.join(", ")}`;
@@ -450,12 +502,17 @@ export default function (pi: ExtensionAPI) {
 				})
 				.join("\n");
 
+			const durableTasks = store.loadAllTasks(id!);
+			const squad = store.loadSquad(id!);
+			const review = squad ? getReviewPresentation(squad) : null;
 			const summary = [
 				`Squad: ${id}`,
 				`Status: ${context.status}`,
+				`Progress: ${formatTaskProgress(durableTasks)}`,
 				`Elapsed: ${context.elapsed}`,
 				`Cost: $${context.costs.total.toFixed(4)}`,
-				...(context.status === "review" ? ["Acceptance: BLOCKED — independent main-orchestrator review required via squad_review"] : []),
+				...(review ? [`Acceptance: ${review.label}`] : []),
+				...(squad ? formatSuspendedAttention(squad) : []),
 				"",
 				"Tasks:",
 				taskLines,
@@ -592,12 +649,13 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "squad_modify",
 		label: "Squad Modify",
-		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.",
+		description: "Modify a squad. The destructive cancel action requires an exact squadId and never infers focus; task actions reconstruct the persisted scheduler after restart when needed.",
 		parameters: Type.Object({
-			squadId: Type.Optional(Type.String({ description: "Exact squad to modify (recommended for failed-review rework; default: focused/recoverable project squad)" })),
+			squadId: Type.Optional(Type.String({ description: "Exact squad to modify; required for cancel (other actions may use the focused/recoverable project squad)" })),
 			action: Type.Union(
 				[
 					Type.Literal("add_task"),
+					Type.Literal("set_dependencies"),
 					Type.Literal("cancel_task"),
 					Type.Literal("pause_task"),
 					Type.Literal("resume_task"),
@@ -609,6 +667,7 @@ export default function (pi: ExtensionAPI) {
 				{ description: "Action to perform" },
 			),
 			taskId: Type.Optional(Type.String({ description: "Task ID for task-specific actions" })),
+			depends: Type.Optional(Type.Array(Type.String(), { description: "Complete replacement dependency list; required at top level for set_dependencies" })),
 			output: Type.Optional(Type.String({ description: "Result summary for complete_task (what was accomplished)" })),
 			task: Type.Optional(
 				Type.Object({
@@ -623,6 +682,22 @@ export default function (pi: ExtensionAPI) {
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			if (params.action === "cancel") {
+				if (!params.squadId?.trim()) {
+					return { content: [{ type: "text" as const, text: "cancel requires exact squadId; no squad was changed." }], details: undefined };
+				}
+				const squadId = params.squadId.trim();
+				if (!store.loadSquad(squadId)) {
+					return { content: [{ type: "text" as const, text: `Squad '${squadId}' not found; no squad was changed.` }], details: undefined };
+				}
+				try {
+					await cancelExactSquad(squadId);
+				} catch (error) {
+					return { content: [{ type: "text" as const, text: `Cancel failed for squad '${squadId}': ${(error as Error).message}` }], details: undefined };
+				}
+				return { content: [{ type: "text" as const, text: `Squad '${squadId}' cancelled.` }], details: undefined };
+			}
+
 			if (params.action === "resume") {
 				const squad = resolveResumeSquad(ctx.cwd, params.squadId);
 				if (!squad) {
@@ -638,8 +713,7 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text" as const, text: `Resume failed: ${(err as Error).message}` }], 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 };
+				return { content: [{ type: "text" as const, text: `Squad "${squad.id}" resumed (${formatTaskProgress(tasks)}). Agents restarting in background.` }], details: undefined };
 			}
 
 			const squadId = params.squadId || activeSquadId;
@@ -647,7 +721,7 @@ export default function (pi: ExtensionAPI) {
 				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")) {
+			if (!activeScheduler && (params.action === "add_task" || params.action === "set_dependencies" || params.action === "cancel_task" || params.action === "resume_task" || params.action === "complete_task" || params.action === "pause_task")) {
 				activeScheduler = ensureScheduler(pi, squadId, squadSkillPaths);
 			}
 			if (!activeScheduler) {
@@ -699,9 +773,24 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text" as const, text: `Task '${task.id}' added to squad '${squadId}'.` }], details: undefined };
 				}
 
+				case "set_dependencies": {
+					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
+					if (!params.depends) return { content: [{ type: "text" as const, text: "Provide top-level depends for set_dependencies (use [] to remove all dependencies)." }], details: undefined };
+					try {
+						await activeScheduler.setDependencies(params.taskId, params.depends);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `set_dependencies failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' dependencies updated in squad '${squadId}'.` }], details: undefined };
+				}
+
 				case "cancel_task": {
 					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
-					await activeScheduler.cancelTask(params.taskId);
+					try {
+						await activeScheduler.cancelTask(params.taskId);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `cancel_task failed: ${(err as Error).message}` }], details: undefined };
+					}
 					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' cancelled.` }], details: undefined };
 				}
 
@@ -714,9 +803,12 @@ export default function (pi: ExtensionAPI) {
 				case "resume_task": {
 					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
 					try {
-						await activeScheduler.resumeTask(params.taskId);
+						const result = await activeScheduler.resumeTask(params.taskId);
+						if (result === "already_running") {
+							return { content: [{ type: "text" as const, text: `Task '${params.taskId}' is already running in squad '${squadId}'; no duplicate resume was started.` }], details: undefined };
+						}
 					} 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: `resume_task failed for task '${params.taskId}' in squad '${squadId}': ${(err as Error).message}` }], details: undefined };
 					}
 					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed in squad '${squadId}'.` }], details: undefined };
 				}
@@ -741,19 +833,7 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text" as const, text: "Squad paused. Use squad_modify with action 'resume' to continue." }], details: undefined };
 				}
 
-				// Note: "resume" is handled above, before the activeScheduler guard.
-
-				case "cancel": {
-					await activeScheduler.stop();
-					const squad = store.loadSquad(activeSquadId);
-					if (squad) {
-						squad.status = "failed";
-						store.saveSquad(squad);
-					}
-					schedulers.delete(activeSquadId);
-					activeSquadId = null;
-					return { content: [{ type: "text" as const, text: "Squad cancelled." }], details: undefined };
-				}
+				// Note: "resume" and exact-ID "cancel" are handled above.
 
 				default:
 					return { content: [{ type: "text" as const, text: `Unknown action: ${params.action}` }], details: undefined };
@@ -794,12 +874,27 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
+		// Reconstruct schedulers for explicit-suspension stalls without resuming any
+		// task. Reconcile derives/persists a missing outbox record and emits only a
+		// pending fingerprint; delivered attention remains durable and silent.
+		const suspensionCandidates = store.listSquadsForProject(ctx.cwd)
+			.filter((squad) => Boolean(squad.suspendedStallAttention) || store.loadAllTasks(squad.id).some((task) => task.status === "suspended"));
+		for (const squad of suspensionCandidates) {
+			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();
+		}
+
 		// 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))
+				.some((task) => task.status !== "cancelled" && 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);
@@ -828,7 +923,7 @@ export default function (pi: ExtensionAPI) {
 			if (done > 0) {
 				pi.sendMessage({
 					customType: "squad-paused",
-					content: `[squad] Found paused squad "${squad.id}" (${squad.goal}) — ${done}/${tasks.length} done. ` +
+					content: `[squad] Found paused squad "${squad.id}" (${squad.goal}) — ${formatTaskProgress(tasks)}. ` +
 						`Use squad_modify with action "resume" to continue, or start a new squad.`,
 					display: true,
 				});
@@ -988,8 +1083,7 @@ export default function (pi: ExtensionAPI) {
 						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");
+					ctx.ui.notify(`Resumed: ${squad.id} (${formatTaskProgress(tasks)})`, "info");
 					return;
 				}
 
@@ -1103,17 +1197,13 @@ export default function (pi: ExtensionAPI) {
 				}
 
 				case "cancel": {
-					const cancelSched = getActiveScheduler();
-					if (!cancelSched) {
-						ctx.ui.notify("No running squad to cancel", "info");
+					const cancelledId = activeSquadId;
+					if (!cancelledId) {
+						ctx.ui.notify("No focused squad to cancel", "info");
 						return;
 					}
-					await cancelSched.stop();
-					const squad = store.loadSquad(activeSquadId!);
-					if (squad) { squad.status = "failed"; store.saveSquad(squad); }
-					if (activeSquadId) schedulers.delete(activeSquadId);
-					forceWidgetUpdate();
-					ctx.ui.notify("Squad cancelled", "info");
+					await cancelExactSquad(cancelledId);
+					ctx.ui.notify(`Squad '${cancelledId}' cancelled`, "info");
 					return;
 				}
 
@@ -1164,10 +1254,9 @@ export default function (pi: ExtensionAPI) {
 						"🗑  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 === "review" ? "◆" : s.status === "failed" ? "✗" : "·";
-							return `${icon} ${s.id} [${s.status}] ${done}/${tasks.length} $${cost.toFixed(2)}`;
+							return `${icon} ${s.id} [${s.status}] ${formatTaskProgress(tasks)} $${cost.toFixed(2)}`;
 						}),
 					];
 
@@ -1474,11 +1563,12 @@ async function pickSquad(
 
 	const options = 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 === "review" ? "◆" : s.status === "failed" ? "✗" : "·";
+		const review = getReviewPresentation(s);
+		const icon = review?.icon ?? (s.status === "done" ? "✓" : s.status === "running" ? "⏳" : s.status === "failed" ? "✗" : "·");
+		const acceptance = review ? ` ${review.label}` : ` [${s.status}]`;
 		const project = showProject ? ` — ${s.cwd.split("/").pop()}` : "";
-		return `${icon} ${s.id} [${s.status}] ${done}/${tasks.length} $${cost.toFixed(2)}${project}`;
+		return `${icon} ${s.id}${acceptance} · ${formatTaskProgress(tasks)} $${cost.toFixed(2)}${project}`;
 	});
 
 	const choice = await ctx.ui.select("Select a squad", options);
@@ -1511,9 +1601,8 @@ function activateSquadView(squadId: string, ctx: import("@earendil-works/pi-codi
 	// 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);
-	ctx.ui.notify(`Viewing: ${squad.id} [${squad.status}] ${done}/${tasks.length} $${cost.toFixed(2)}`, "info");
+	ctx.ui.notify(`Viewing: ${squad.id} [${squad.status}] ${formatTaskProgress(tasks)} $${cost.toFixed(2)}`, "info");
 }
 
 // ============================================================================
@@ -1549,14 +1638,27 @@ function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squadId: st
 				// can reopen the task immediately on its bound durable Pi session.
 				break;
 			}
+			case "suspended_stall": {
+				try {
+					const attention = event.data as SuspendedStallAttention;
+					pi.sendMessage({
+						customType: `squad-suspended-stall:${squadId}:${attention.fingerprint}`,
+						content: formatSuspendedStallAttention(squadId, attention),
+						display: true,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+					scheduler.acknowledgeSuspendedStall(attention.fingerprint);
+				} catch (error) {
+					logError("squad-scheduler", `suspended-stall delivery failed for ${squadId}: ${(error as Error).message}`);
+				}
+				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` +
+						`${formatTaskProgress(tasks)}, ${failed.length} failed.\n` +
 						`Failed: ${buildFailureSummary(tasks)}\n` +
 						"Use squad_status for details or squad_modify to adjust.",
 					display: true,

package/src/panel/squad-widget.ts

@@ -14,6 +14,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { TaskMessage, TaskStatus } from "../types.js";
+import { getReviewPresentation, getSuspendedAttention, SUSPENDED_ATTENTION_LABEL } from "../presentation.js";
 import * as store from "../store.js";
 
 function statusIcon(status: TaskStatus, th: Theme): string {
@@ -23,6 +24,7 @@ function statusIcon(status: TaskStatus, th: Theme): string {
 		case "blocked": return th.fg("muted", "◻");
 		case "failed": return th.fg("error", "✗");
 		case "suspended": return th.fg("muted", "⏸");
+		case "cancelled": return th.fg("muted", "⊘");
 		default: return th.fg("dim", "·");
 	}
 }
@@ -75,6 +77,11 @@ export function setupSquadWidget(
 		const lines: string[] = [];
 		const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 		const doneCount = tasks.filter((t) => t.status === "done").length;
+		const cancelledCount = tasks.filter((t) => t.status === "cancelled").length;
+		const activeCount = tasks.length - cancelledCount;
+		const progressText = cancelledCount > 0
+			? `${doneCount}/${activeCount} active tasks done · ${cancelledCount} cancelled · ${tasks.length} total`
+			: `${doneCount}/${tasks.length}`;
 		const elapsed = Date.now() - new Date(squad.created).getTime();
 		const taskMessages = new Map<string, TaskMessage[]>();
 		const recentOrchestratorByTask = new Map<string, TaskMessage>();
@@ -93,21 +100,25 @@ export function setupSquadWidget(
 			if (recentOrchestrator) recentOrchestratorByTask.set(task.id, recentOrchestrator);
 		}
 
-		const sIcon = squad.status === "done" ? th.fg("success", "✓")
+		const review = getReviewPresentation(squad);
+		const attention = getSuspendedAttention(squad);
+		const sIcon = review ? th.fg(review.tone, review.icon)
+			: squad.status === "done" ? th.fg("success", "✓")
 			: squad.status === "failed" ? th.fg("error", "✗")
-			: squad.status === "review" ? th.fg("warning", "◆")
 			: th.fg("warning", "⏳");
 
 		const orchestratorSignal = recentOrchestratorByTask.size > 0
 			? ` ${th.fg("accent", `✉ ${recentOrchestratorByTask.size > 1 ? recentOrchestratorByTask.size + " " : ""}ORCH`)}`
 			: "";
+		const acceptanceText = review ? ` · ${th.fg(review.tone, review.label)}` : "";
 		lines.push(
 			`${sIcon} ${th.fg("accent", "squad")}${orchestratorSignal} ${th.fg("dim", squad.goal.slice(0, 35))} ` +
-			`${th.fg("muted", `${doneCount}/${tasks.length}`)} ` +
+			`${th.fg("muted", progressText)}${acceptanceText} ` +
 			`${th.fg("dim", `$${totalCost.toFixed(2)}`)} ` +
 			`${th.fg("dim", formatElapsed(elapsed))} ` +
 			`${th.fg("dim", "^q detail · /squad msg")}`
 		);
+		if (attention) lines.push(`  ${th.fg("warning", SUSPENDED_ATTENTION_LABEL)} ${th.fg("dim", "· ^q detail")}`);
 
 		// Cap visible tasks based on total count
 		const maxVisible = tasks.length > 6 ? 4 : tasks.length;
@@ -144,6 +155,8 @@ export function setupSquadWidget(
 						line += ` ${th.fg("dim", (detail ? `${toolStr} ${detail}` : toolStr).slice(0, 30))}`;
 					}
 				}
+			} else if (task.status === "cancelled") {
+				line += ` ${th.fg("muted", "cancelled")}`;
 			} else if (task.status === "blocked") {
 				const blockers = task.depends.filter((d) => {
 					const dep = tasks.find((t) => t.id === d);
@@ -161,15 +174,17 @@ export function setupSquadWidget(
 			lines.push(`  ${th.fg("dim", `  +${tasks.length - maxVisible} more · ^q detail`)}`);
 		}
 
-		const cacheKey = `${squad.status}:${tasks.map(t => `${t.id}=${t.status}:${t.usage.turns}`).join(",")}:${recentMessageKeys.join(",")}`;
+		const cacheKey = `${state.squadId}:${squad.status}:${squad.review?.status ?? "none"}:${attention?.fingerprint ?? "no-attention"}:${tasks.map(t => `${t.id}=${t.status}:${t.usage.turns}`).join(",")}:${recentMessageKeys.join(",")}`;
 
-		const statusText = squad.status === "done"
-			? th.fg("success", `✓ squad ${doneCount}/${tasks.length}`)
+		const statusText = review
+			? th.fg(review.tone, `${review.label} · ${progressText}`)
+			: attention
+			? th.fg("warning", `${SUSPENDED_ATTENTION_LABEL} · ${progressText}`)
+			: squad.status === "done"
+			? th.fg("success", `✓ squad ${progressText}`)
 			: squad.status === "failed"
-			? th.fg("error", `✗ squad ${doneCount}/${tasks.length}`)
-			: squad.status === "review"
-			? th.fg("warning", `◆ squad review required`)
-			: th.fg("accent", `⏳ squad ${doneCount}/${tasks.length} $${totalCost.toFixed(2)}`);
+			? th.fg("error", `✗ squad ${progressText}`)
+			: th.fg("accent", `⏳ squad ${progressText} $${totalCost.toFixed(2)}`);
 
 		return { lines, cacheKey, statusText };
 	}
@@ -208,6 +223,8 @@ export function setupSquadWidget(
 			ctx.ui.setWidget("squad-tasks", undefined);
 			ctx.ui.setStatus("squad", undefined);
 			widgetInstalled = false;
+			widgetComponent = null;
+			lastCacheKey = "";
 			return;
 		}