pi-squad 0.16.4 → 0.16.6

package/README.md

@@ -52,8 +52,10 @@ Squad agents—including QA/reviewer agents—produce candidate work and evidenc
 - Persisted status becomes `review`, never directly `done`.
 - A persistent `<squad_review_required>` system reminder tells main Pi to re-read the original conversation contract, inspect the actual diff/source, rerun verification independently, and run integration/E2E where applicable.
 - Main Pi must call `squad_review` with requirement-by-requirement contract checks, diff review, actual command/result evidence, integration/E2E evidence, and issues.
-- Only `pass` or `pass_with_issues` changes the squad to `done`; `fail` leaves it review-blocked for fixes and re-review.
-- Pending review survives Pi restarts and is restored on the next session.
+- Only `pass` or `pass_with_issues` changes the squad to `done`; `fail` leaves it review-blocked and cannot be overwritten by another verdict.
+- 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.
 
 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.
 
@@ -188,6 +190,7 @@ Full overlay with task list, live activity preview, and scrollable message view.
 | Command | Description |
 |---|---|
 | `/squad select` | Pick a squad to view |
+| `/squad resume [squad-id]` | Reconstruct and resume an exact paused/failed/failed-review squad |
 | `/squad list` | List project squads |
 | `/squad all` | List all squads |
 | `/squad agents` | Manage agent definitions |
@@ -206,7 +209,11 @@ 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 |
+| `squad_modify` | Add/cancel/complete/pause/resume tasks or squads, or replace a task's dependencies with `set_dependencies`; accepts `squadId` for exact same-squad failed-review rework |
+
+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.4",
+  "version": "0.16.6",
   "description": "Multi-agent collaboration extension for pi — task decomposition, dependency management, parallel execution, TUI panel",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -46,6 +46,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 +186,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
@@ -236,11 +278,10 @@ export default function (pi: ExtensionAPI) {
 				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 === "cancelled" ? "⊘" : "·";
 				let line = `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
 				if (t.output) line += ` — ${t.output}`;
 				if (t.error) line += ` ERROR: ${t.error}`;
@@ -250,7 +291,7 @@ export default function (pi: ExtensionAPI) {
 			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)}`,
 				taskLines,
 				`</squad_status>`,
 				...(squad.status === "review" ? [buildOrchestratorReviewGate(squad, tasks)] : []),
@@ -411,6 +452,7 @@ export default function (pi: ExtensionAPI) {
 						task.status === "in_progress" ? "⏳" :
 						task.status === "blocked" ? "◻" :
 						task.status === "failed" ? "✗" :
+						task.status === "cancelled" ? "⊘" :
 						"·";
 					let line = `${icon} ${taskId} (${task.agent}) — ${task.title} [${task.status}]`;
 					if (task.blockedBy?.length) line += ` blocked by: ${task.blockedBy.join(", ")}`;
@@ -418,9 +460,11 @@ export default function (pi: ExtensionAPI) {
 				})
 				.join("\n");
 
+			const durableTasks = store.loadAllTasks(id!);
 			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"] : []),
@@ -560,11 +604,13 @@ 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, set_dependencies (top-level depends), cancel_task, complete_task (mark done + schedule dependents), pause, resume_task, resume (including failed-review rework), cancel. 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)" })),
 			action: Type.Union(
 				[
 					Type.Literal("add_task"),
+					Type.Literal("set_dependencies"),
 					Type.Literal("cancel_task"),
 					Type.Literal("pause_task"),
 					Type.Literal("resume_task"),
@@ -576,6 +622,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({
@@ -590,45 +637,36 @@ 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();
-
-					wireSchedulerEvents(pi, scheduler, squadId);
+				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);
+				return { content: [{ type: "text" as const, text: `Squad "${squad.id}" resumed (${formatTaskProgress(tasks)}). 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 === "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) {
+				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": {
@@ -645,17 +683,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,
@@ -664,14 +704,32 @@ 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 "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 };
 				}
 
@@ -683,10 +741,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": {
@@ -767,7 +827,7 @@ export default function (pi: ExtensionAPI) {
 		// 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);
@@ -796,7 +856,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,
 				});
@@ -866,12 +926,13 @@ 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)" },
@@ -941,6 +1002,24 @@ 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);
+					ctx.ui.notify(`Resumed: ${squad.id} (${formatTaskProgress(tasks)})`, "info");
+					return;
+				}
+
 				case "widget": {
 					widgetState.enabled = !widgetState.enabled;
 					if (widgetState.enabled) {
@@ -1112,10 +1191,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)}`;
 						}),
 					];
 
@@ -1398,7 +1476,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");
 			}
 		},
 	});
@@ -1422,11 +1500,10 @@ 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 project = showProject ? ` — ${s.cwd.split("/").pop()}` : "";
-		return `${icon} ${s.id} [${s.status}] ${done}/${tasks.length} $${cost.toFixed(2)}${project}`;
+		return `${icon} ${s.id} [${s.status}] ${formatTaskProgress(tasks)} $${cost.toFixed(2)}${project}`;
 	});
 
 	const choice = await ctx.ui.select("Select a squad", options);
@@ -1459,9 +1536,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");
 }
 
 // ============================================================================
@@ -1500,11 +1576,10 @@ function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squadId: st
 			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

@@ -23,6 +23,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 +76,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>();
@@ -103,7 +109,7 @@ export function setupSquadWidget(
 			: "";
 		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)} ` +
 			`${th.fg("dim", `$${totalCost.toFixed(2)}`)} ` +
 			`${th.fg("dim", formatElapsed(elapsed))} ` +
 			`${th.fg("dim", "^q detail · /squad msg")}`
@@ -144,6 +150,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);
@@ -164,12 +172,12 @@ export function setupSquadWidget(
 		const cacheKey = `${squad.status}:${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}`)
+			? th.fg("success", `✓ squad ${progressText}`)
 			: squad.status === "failed"
-			? th.fg("error", `✗ squad ${doneCount}/${tasks.length}`)
+			? th.fg("error", `✗ squad ${progressText}`)
 			: squad.status === "review"
 			? th.fg("warning", `◆ squad review required`)
-			: th.fg("accent", `⏳ squad ${doneCount}/${tasks.length} $${totalCost.toFixed(2)}`);
+			: th.fg("accent", `⏳ squad ${progressText} $${totalCost.toFixed(2)}`);
 
 		return { lines, cacheKey, statusText };
 	}

package/src/panel/task-list.ts

@@ -24,6 +24,8 @@ function statusIcon(status: TaskStatus, th: Theme): string {
 			return th.fg("error", "✗");
 		case "suspended":
 			return th.fg("muted", "⏸");
+		case "cancelled":
+			return th.fg("muted", "⊘");
 		case "pending":
 		default:
 			return th.fg("dim", "·");
@@ -42,6 +44,8 @@ function statusLabel(status: TaskStatus): string {
 			return "FAILED";
 		case "suspended":
 			return "paused";
+		case "cancelled":
+			return "cancelled";
 		case "pending":
 			return "pending";
 	}
@@ -241,11 +245,15 @@ export class TaskListView {
 	private renderSummary(tasks: Task[], width: number): string {
 		const th = this.theme;
 		const done = tasks.filter((t) => t.status === "done").length;
+		const cancelled = tasks.filter((t) => t.status === "cancelled").length;
 		const total = tasks.length;
+		const activeTotal = total - cancelled;
 		const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 
 		const parts: string[] = [];
-		parts.push(th.fg("accent", `${done}/${total}`));
+		parts.push(th.fg("accent", cancelled > 0
+			? `${done}/${activeTotal} active tasks done · ${cancelled} cancelled · ${total} total`
+			: `${done}/${total}`));
 		if (totalCost > 0) parts.push(th.fg("dim", `$${totalCost.toFixed(4)}`));
 
 		// Find squad creation time for elapsed

package/src/report.ts

@@ -5,10 +5,18 @@ import type { Task } from "./types.js";
  * This is durable report data, not a UI preview: never shorten task output.
  */
 export function buildCompletionSummary(tasks: Task[]): string {
-	return tasks
+	const completed = tasks
 		.filter((task) => task.status === "done")
 		.map((task) => `- ${task.id} (${task.agent}): ${task.output || "done"}`)
 		.join("\n");
+	const cancelled = tasks
+		.filter((task) => task.status === "cancelled")
+		.map((task) => `- ${task.id} (${task.agent}): cancelled`)
+		.join("\n");
+
+	return [completed, cancelled ? `CANCELLED TASKS (neutral; not successful output)\n${cancelled}` : ""]
+		.filter(Boolean)
+		.join("\n\n");
 }
 
 /** Build the full failure handoff without shortening diagnostics. */

package/src/review.ts

@@ -11,6 +11,18 @@ export interface OrchestratorReviewInput {
 	issues: string[];
 }
 
+/**
+ * Start same-squad rework without discarding completed review evidence.
+ * The next all-tasks-done transition creates a new active pending review.
+ */
+export function beginOrchestratorRework(squad: Squad): void {
+	if (squad.review && squad.review.status !== "pending") {
+		squad.reviewHistory = [...(squad.reviewHistory ?? []), { ...squad.review }];
+	}
+	delete squad.review;
+	squad.status = "running";
+}
+
 /** Move a squad from agent execution into mandatory independent main-session review. */
 export function beginOrchestratorReview(squad: Squad): void {
 	squad.status = "review";
@@ -35,6 +47,9 @@ export function recordOrchestratorReview(squad: Squad, input: OrchestratorReview
 	if (squad.status !== "review" || !squad.review) {
 		throw new Error(`Squad '${squad.id}' is not awaiting orchestrator review`);
 	}
+	if (squad.review.status !== "pending") {
+		throw new Error(`Squad '${squad.id}' review attempt is already ${squad.review.status}; begin same-squad rework before submitting a fresh review`);
+	}
 
 	const contractChecks = cleanList(input.contractChecks);
 	const verificationEvidence = cleanList(input.verificationEvidence);

package/src/scheduler.ts

@@ -19,7 +19,7 @@ import * as store from "./store.js";
 import { debug, logError } from "./logger.js";
 import { buildAgentSystemPrompt } from "./protocol.js";
 import { buildAdvisorConsultText, formatAdvisorSteerMessage, adviceNeedsHuman, type AdvisorConsultInput } from "./advisor.js";
-import { beginOrchestratorReview } from "./review.js";
+import { beginOrchestratorReview, beginOrchestratorRework } from "./review.js";
 
 // ============================================================================
 // Types
@@ -170,6 +170,10 @@ export class Scheduler {
 
 	/** Start the scheduler — begins scheduling ready tasks */
 	async start(): Promise<void> {
+		if (this.running) {
+			await this.reconcile();
+			return;
+		}
 		this.running = true;
 		this.monitor.start();
 		await this.reconcile();
@@ -200,13 +204,15 @@ export class Scheduler {
 		await this.pool.killAll();
 	}
 
-	/** Resume from suspended OR failed state. Failure is never terminal:
-	 * failed tasks are reset to pending and a failed squad becomes running. */
+	/** Resume suspended/failed work. A failed review is archived only when
+	 * resumable work actually exists; a bare resume cannot bypass the gate. */
 	async resume(): Promise<void> {
 		const tasks = store.loadAllTasks(this.squadId);
+		let resumedWork = false;
 		for (const task of tasks) {
 			if (task.status === "suspended") {
 				store.updateTaskStatus(this.squadId, task.id, "pending");
+				resumedWork = true;
 			} else if (task.status === "failed") {
 				store.updateTaskStatus(this.squadId, task.id, "pending", { error: null });
 				store.appendMessage(this.squadId, task.id, {
@@ -215,13 +221,19 @@ export class Scheduler {
 					type: "status",
 					text: "Reset failed → pending on squad resume",
 				});
+				resumedWork = true;
 			}
 		}
 
 		const squad = store.loadSquad(this.squadId);
-		if (squad && (squad.status === "paused" || squad.status === "failed")) {
-			squad.status = "running";
-			store.saveSquad(squad);
+		if (squad) {
+			if (resumedWork && squad.status === "review" && squad.review?.status === "failed") {
+				beginOrchestratorRework(squad);
+				store.saveSquad(squad);
+			} else if (squad.status === "paused" || squad.status === "failed") {
+				squad.status = "running";
+				store.saveSquad(squad);
+			}
 		}
 
 		await this.start();
@@ -246,6 +258,7 @@ export class Scheduler {
 		// mutation/RPC delivery, reopen exactly that task on reconstruction.
 		let recoveredMailbox = false;
 		for (const task of tasks) {
+			if (task.status === "cancelled") continue;
 			if (this.pool.isRunning(task.id)) continue;
 			if (store.loadPendingTaskMessages(this.squadId, task.id).length === 0) continue;
 			if (task.status === "done") await this.invalidateDescendants(task.id);
@@ -262,8 +275,7 @@ export class Scheduler {
 			recoveredMailbox = true;
 		}
 		if (recoveredMailbox && squad.status !== "running") {
-			squad.status = "running";
-			delete squad.review;
+			beginOrchestratorRework(squad);
 			store.saveSquad(squad);
 		}
 
@@ -297,6 +309,11 @@ export class Scheduler {
 		}
 
 		await this.scheduleReadyTasks();
+
+		const freshSquad = store.loadSquad(this.squadId);
+		if (freshSquad && (freshSquad.status === "running" || freshSquad.status === "failed")) {
+			this.checkSquadCompletion(store.loadAllTasks(this.squadId), freshSquad);
+		}
 	}
 
 	// =========================================================================
@@ -647,6 +664,7 @@ export class Scheduler {
 	}
 
 	private handleUnexpectedAgentExit(event: AgentEvent): void {
+		if (store.loadTask(this.squadId, event.taskId)?.status === "cancelled") return;
 		const exitCode = event.data?.exitCode ?? 1;
 		const turnCount = event.data?.turnCount ?? 0;
 		const stderr = event.data?.stderr || "";
@@ -776,6 +794,7 @@ export class Scheduler {
 			}
 
 			case "agent_settled": {
+				if (store.loadTask(this.squadId, event.taskId)?.status === "cancelled") return;
 				// A mailbox entry not acknowledged by Pi outranks this run's candidate
 				// completion. Reopen the same session so accepted-at-least-once delivery
 				// occurs before the task can become done.
@@ -827,8 +846,8 @@ export class Scheduler {
 		const task = store.loadTask(this.squadId, taskId);
 		if (!task) return;
 
-		// Guard against double-completion
-		if (task.status === "done") return;
+		// Guard against double-completion and late callbacks after cancellation.
+		if (task.status === "done" || task.status === "cancelled") return;
 
 		// Extract output from last messages
 		const messages = store.loadMessages(this.squadId, taskId);
@@ -896,6 +915,7 @@ export class Scheduler {
 	}
 
 	private handleTaskFailed(taskId: string, error: string): void {
+		if (store.loadTask(this.squadId, taskId)?.status === "cancelled") return;
 		store.updateTaskStatus(this.squadId, taskId, "failed", {
 			error,
 			completed: store.now(),
@@ -1137,10 +1157,11 @@ export class Scheduler {
 	private checkSquadCompletion(tasks: Task[], squad: Squad): void {
 		if (tasks.length === 0) return;
 
-		const allDone = tasks.every((t) => t.status === "done");
-		const anyFailed = tasks.some((t) => t.status === "failed");
-		const anyInProgress = tasks.some(
-			(t) => t.status === "in_progress" || t.status === "pending",
+		const relevant = tasks.filter((task) => task.status !== "cancelled");
+		const allDone = relevant.every((task) => task.status === "done");
+		const anyFailed = relevant.some((task) => task.status === "failed");
+		const anyInProgress = relevant.some(
+			(task) => task.status === "in_progress" || task.status === "pending",
 		);
 
 		if (allDone) {
@@ -1152,9 +1173,9 @@ export class Scheduler {
 			this.emit({ type: "squad_review_required", squadId: this.squadId });
 		} else if (anyFailed && !anyInProgress) {
 			// All remaining tasks are blocked/failed with no way forward
-			const blockedCount = tasks.filter((t) => t.status === "blocked").length;
-			const failedCount = tasks.filter((t) => t.status === "failed").length;
-			if (blockedCount + failedCount === tasks.filter((t) => t.status !== "done").length) {
+			const blockedCount = relevant.filter((task) => task.status === "blocked").length;
+			const failedCount = relevant.filter((task) => task.status === "failed").length;
+			if (blockedCount + failedCount === relevant.filter((task) => task.status !== "done").length) {
 				squad.status = "failed";
 				store.saveSquad(squad);
 				this.emit({ type: "squad_failed", squadId: this.squadId });
@@ -1286,6 +1307,7 @@ export class Scheduler {
 			if (seen.has(descendant.id)) continue;
 			seen.add(descendant.id);
 			queue.push(...(byDependency.get(descendant.id) ?? []));
+			if (descendant.status === "cancelled") continue;
 			store.updateTaskStatus(this.squadId, descendant.id, "blocked", {
 				completed: null,
 				error: null,
@@ -1301,6 +1323,17 @@ export class Scheduler {
 		await Promise.all(kills);
 	}
 
+	private reopenSquadForWork(): void {
+		const squad = store.loadSquad(this.squadId);
+		if (!squad) throw new Error(`Squad not found: ${this.squadId}`);
+		if (squad.status === "review" || squad.status === "done" || squad.review) {
+			beginOrchestratorRework(squad);
+		} else if (squad.status !== "running") {
+			squad.status = "running";
+		}
+		store.saveSquad(squad);
+	}
+
 	private async reopenTaskForMessage(task: Task): Promise<void> {
 		if (task.status === "done") await this.invalidateDescendants(task.id);
 		const tasks = store.loadAllTasks(this.squadId);
@@ -1313,14 +1346,7 @@ export class Scheduler {
 			completed: null,
 		});
 
-		const squad = store.loadSquad(this.squadId);
-		if (squad && squad.status !== "running") {
-			squad.status = "running";
-			// Any prior acceptance/review applies to the pre-resume result. The
-			// normal all-done path will require a fresh independent review.
-			delete squad.review;
-			store.saveSquad(squad);
-		}
+		this.reopenSquadForWork();
 	}
 
 	/** Send a main-orchestrator request to one exact task and await its next reply. */
@@ -1338,6 +1364,8 @@ export class Scheduler {
 			expectsReply,
 		});
 
+		if (task.status === "cancelled") return false;
+
 		const request = expectsReply
 			? `[squad] Main orchestrator requests a direct response:\n${message}\n\nReply directly in your next assistant message. That complete message will be forwarded automatically to the main session.`
 			: `[squad] Main orchestrator message:\n${message}`;
@@ -1372,6 +1400,9 @@ export class Scheduler {
 
 	/** Pause a running task */
 	async pauseTask(taskId: string): Promise<void> {
+		const task = store.loadTask(this.squadId, taskId);
+		if (!task) throw new Error(`Task not found: ${taskId}`);
+		if (task.status === "cancelled") throw new Error(`Task '${taskId}' is cancelled; use resume_task to revive it.`);
 		if (this.pool.isRunning(taskId)) {
 			await this.pool.steer(taskId, "[squad] Task paused by user. Summarize your current state.");
 			// Give agent a moment to respond, then kill
@@ -1381,10 +1412,112 @@ export class Scheduler {
 		this.updateContext();
 	}
 
-	/** Resume a suspended/failed task. Reconciles so a failed squad heals too. */
+	/** Add work to this exact squad and schedule it, reconstructing safely after restart. */
+	async addTask(task: Task): Promise<void> {
+		if (store.loadTask(this.squadId, task.id)) throw new Error(`Task already exists: ${task.id}`);
+		store.createTask(this.squadId, task);
+		this.reopenSquadForWork();
+		await this.start();
+		this.updateContext();
+	}
+
+	/** Atomically replace one task's dependency list after validating the complete historical DAG. */
+	async setDependencies(taskId: string, depends: string[]): Promise<void> {
+		const tasks = store.loadAllTasks(this.squadId);
+		const target = tasks.find((task) => task.id === taskId);
+		if (!target) throw new Error(`Task not found: ${taskId}`);
+		if (target.status === "in_progress") {
+			throw new Error(`Cannot edit dependencies for in_progress task '${taskId}'; pause or cancel it first.`);
+		}
+		if (target.status === "done") {
+			throw new Error(`Cannot edit dependencies for done task '${taskId}'; resume it first so descendant invalidation remains authoritative.`);
+		}
+
+		const duplicate = depends.find((dependency, index) => depends.indexOf(dependency) !== index);
+		if (duplicate) throw new Error(`Duplicate dependency '${duplicate}' for task '${taskId}'.`);
+		if (depends.includes(taskId)) throw new Error(`Task '${taskId}' cannot depend on itself.`);
+		const known = new Set(tasks.map((task) => task.id));
+		const unknown = depends.filter((dependency) => !known.has(dependency));
+		if (unknown.length > 0) throw new Error(`Unknown dependency task(s): ${unknown.join(", ")}.`);
+
+		const wasRunnable = target.status === "pending" && target.depends.every(
+			(dependency) => tasks.find((candidate) => candidate.id === dependency)?.status === "done",
+		);
+		const graph = new Map(tasks.map((task) => [task.id, [...task.depends]]));
+		graph.set(taskId, [...depends]);
+		for (const [id, dependencies] of graph) {
+			const seen = new Set<string>();
+			for (const dependency of dependencies) {
+				if (!known.has(dependency)) throw new Error(`Task '${id}' depends on unknown task '${dependency}'.`);
+				if (dependency === id) throw new Error(`Task '${id}' cannot depend on itself.`);
+				if (seen.has(dependency)) throw new Error(`Duplicate dependency '${dependency}' for task '${id}'.`);
+				seen.add(dependency);
+			}
+		}
+		const color = new Map<string, 0 | 1 | 2>();
+		const stack: string[] = [];
+		const visit = (id: string): void => {
+			const state = color.get(id) ?? 0;
+			if (state === 2) return;
+			if (state === 1) {
+				const start = stack.indexOf(id);
+				const cycle = [...stack.slice(start), id];
+				throw new Error(`Dependency cycle detected: ${cycle.join(" -> ")}`);
+			}
+			color.set(id, 1);
+			stack.push(id);
+			for (const dependency of graph.get(id) ?? []) visit(dependency);
+			stack.pop();
+			color.set(id, 2);
+		};
+		for (const id of graph.keys()) visit(id);
+
+		target.depends = [...depends];
+		if (target.status === "pending" || target.status === "blocked") {
+			target.status = depends.every(
+				(dependency) => tasks.find((candidate) => candidate.id === dependency)?.status === "done",
+			) ? "pending" : "blocked";
+		}
+		store.saveTask(this.squadId, target);
+		store.appendMessage(this.squadId, taskId, {
+			ts: store.now(),
+			from: "system",
+			type: "status",
+			text: `Dependencies updated: ${depends.length > 0 ? depends.join(", ") : "none"}`,
+		});
+
+		this.killBlockedAgents();
+		const squad = store.loadSquad(this.squadId);
+		const runnable = target.status === "pending" && target.depends.every(
+			(dependency) => tasks.find((candidate) => candidate.id === dependency)?.status === "done",
+		);
+		const createdRunnableWork = runnable && !wasRunnable;
+		if (createdRunnableWork && squad && squad.status !== "paused" && squad.status !== "running") {
+			this.reopenSquadForWork();
+			await this.start();
+		} else if (squad?.status === "running") {
+			await this.start();
+		}
+		this.updateContext();
+	}
+
+	/** Resume one exact task. Reopening completed work invalidates descendants and
+	 * archives a completed active review before fresh scheduling begins. */
 	async resumeTask(taskId: string): Promise<void> {
-		store.updateTaskStatus(this.squadId, taskId, "pending", { error: null });
-		await this.reconcile();
+		const task = store.loadTask(this.squadId, taskId);
+		if (!task) throw new Error(`Task not found: ${taskId}`);
+		if (task.status === "done") await this.invalidateDescendants(taskId);
+		const tasks = store.loadAllTasks(this.squadId);
+		const dependenciesDone = task.depends.every(
+			(depId) => tasks.find((candidate) => candidate.id === depId)?.status === "done",
+		);
+		store.updateTaskStatus(this.squadId, taskId, dependenciesDone ? "pending" : "blocked", {
+			error: null,
+			completed: null,
+		});
+		this.reopenSquadForWork();
+		await this.start();
+		this.updateContext();
 	}
 
 	/**
@@ -1397,6 +1530,7 @@ export class Scheduler {
 		const task = store.loadTask(this.squadId, taskId);
 		if (!task) throw new Error(`Task not found: ${taskId}`);
 		if (task.status === "done") return;
+		if (task.status === "cancelled") throw new Error(`Task '${taskId}' is cancelled; resume it before marking it done.`);
 
 		if (this.pool.isRunning(taskId)) {
 			await this.pool.kill(taskId);
@@ -1430,14 +1564,45 @@ export class Scheduler {
 		this.updateContext();
 	}
 
-	/** Cancel a task */
+	/** Cancel one task after ensuring no live historical task still depends on it. */
 	async cancelTask(taskId: string): Promise<void> {
-		if (this.pool.isRunning(taskId)) {
-			await this.pool.kill(taskId);
+		const task = store.loadTask(this.squadId, taskId);
+		if (!task) throw new Error(`Task not found: ${taskId}`);
+		if (task.status === "cancelled") return;
+
+		const dependents = store.loadAllTasks(this.squadId)
+			.filter((candidate) => candidate.status !== "cancelled" && candidate.depends.includes(taskId))
+			.sort((left, right) => left.id.localeCompare(right.id));
+		if (dependents.length > 0) {
+			throw new Error([
+				`Cannot cancel task '${taskId}': it is still required by:`,
+				...dependents.map((dependent) => `- ${dependent.id} [${dependent.status}]`),
+				"",
+				'Update each dependent first with squad_modify action "set_dependencies",',
+				"then retry cancel_task. Cancellation does not rewrite or cascade dependencies.",
+			].join("\n"));
 		}
-		store.updateTaskStatus(this.squadId, taskId, "failed", {
-			error: "Cancelled by user",
+
+		if (this.pool.isRunning(taskId)) await this.pool.kill(taskId);
+		store.updateTaskStatus(this.squadId, taskId, "cancelled", {
+			error: null,
+			completed: store.now(),
 		});
+		store.appendMessage(this.squadId, taskId, {
+			ts: store.now(),
+			from: "system",
+			type: "status",
+			text: "Task cancelled by orchestrator",
+		});
+
+		const squad = store.loadSquad(this.squadId);
+		if (squad) {
+			if (squad.status === "done" || (squad.status === "review" && squad.review?.status !== "pending")) {
+				beginOrchestratorRework(squad);
+				store.saveSquad(squad);
+			}
+			this.checkSquadCompletion(store.loadAllTasks(this.squadId), squad);
+		}
 		this.updateContext();
 	}
 

package/src/skills/squad-supervisor/SKILL.md

@@ -142,14 +142,15 @@ Send small, scoped corrections instead of restarting the task:
 - Name exactly what to change and what to keep: "Change only the header component — keep the layout and routes as they are."
 - Add missing information the moment you learn it — don't wait for the agent to get stuck
 - If the user manually edited or reverted files the agent touched, tell the agent immediately so it doesn't overwrite the human's changes
-- If an agent starts doing work that's no longer needed, narrow its scope via `squad_message` or stop it with `squad_modify` `cancel_task` — don't let it burn tokens on obsolete work
+- If an agent starts doing work that's no longer needed, narrow its scope via `squad_message`. Before using `squad_modify` `cancel_task`, repair every direct dependent explicitly as described below.
 
 ## Modifying a Running Squad
 
 Use `squad_modify` when:
 - **`add_task`**: User requests something not in the original plan
-- **`cancel_task`**: A task is no longer needed
-- **`pause_task`** / **`resume_task`**: Temporarily halt an agent
+- **`set_dependencies`**: Replace a task's dependency list with top-level `taskId` and `depends`, e.g. `{ action: "set_dependencies", taskId: "publish", depends: ["build"] }`. This is allowed only for tasks that are not running or done; the complete replacement is validated atomically for unknown IDs, self-dependencies, duplicates, and cycles.
+- **`cancel_task`**: A task is no longer needed. Cancellation is refused while any non-cancelled task directly depends on it. First call `set_dependencies` for every dependent named in the refusal, then retry `cancel_task`. Cancellation never cascades and never removes or rewrites dependencies automatically.
+- **`pause_task`** / **`resume_task`**: Temporarily halt or explicitly revive an agent; `resume_task` is also the only action that revives a cancelled task.
 - **`pause`** / **`resume`**: Stop/restart the entire squad
 - **`cancel`**: Abort everything (user changed their mind)
 

package/src/store.ts

@@ -356,8 +356,15 @@ export function findLatestSquad(projectCwd?: string): Squad | null {
 // Tasks
 // ============================================================================
 
+function normalizeLegacyCancelledTask(task: Task | null): Task | null {
+	if (task?.status === "failed" && task.error === "Cancelled by user") {
+		return { ...task, status: "cancelled", error: null };
+	}
+	return task;
+}
+
 export function loadTask(squadId: string, taskId: string, parentPath?: string): Task | null {
-	return readJson<Task>(getTaskFilePath(squadId, taskId, parentPath));
+	return normalizeLegacyCancelledTask(readJson<Task>(getTaskFilePath(squadId, taskId, parentPath)));
 }
 
 export function saveTask(squadId: string, task: Task, parentPath?: string): void {
@@ -377,7 +384,7 @@ export function loadAllTasks(squadId: string): Task[] {
 		if (!entry.isDirectory()) continue;
 		if (entry.name === "knowledge") continue;
 		const taskFile = path.join(squadDir, entry.name, "task.json");
-		const task = readJson<Task>(taskFile);
+		const task = normalizeLegacyCancelledTask(readJson<Task>(taskFile));
 		if (task && !seen.has(task.id)) {
 			seen.add(task.id);
 			tasks.push(task);
@@ -401,7 +408,7 @@ function collectSubtasks(squadDir: string, parentPath: string, tasks: Task[], se
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		const taskFile = path.join(parentDir, entry.name, "task.json");
-		const task = readJson<Task>(taskFile);
+		const task = normalizeLegacyCancelledTask(readJson<Task>(taskFile));
 		if (task && !seen.has(task.id)) {
 			seen.add(task.id);
 			tasks.push(task);

package/src/types.ts

@@ -112,15 +112,17 @@ export interface Squad {
 	/** Agent name → overrides. Keys must exist in .pi/squad/agents/ */
 	agents: Record<string, SquadAgentEntry>;
 	config: SquadConfig;
-	/** Mandatory independent main-session review; absent on legacy/running squads. */
+	/** Mandatory independent main-session review; absent while rework is running. */
 	review?: SquadReview;
+	/** Completed prior review attempts retained as same-squad audit evidence. */
+	reviewHistory?: SquadReview[];
 }
 
 // ============================================================================
 // Tasks
 // ============================================================================
 
-export type TaskStatus = "pending" | "blocked" | "in_progress" | "done" | "failed" | "suspended";
+export type TaskStatus = "pending" | "blocked" | "in_progress" | "done" | "failed" | "suspended" | "cancelled";
 
 export interface TaskUsage {
 	inputTokens: number;