pi-squad 0.16.5 → 0.16.6

package/README.md

@@ -209,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; 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`; 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.5",
+  "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.
@@ -268,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}`;
@@ -282,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)] : []),
@@ -443,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(", ")}`;
@@ -450,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"] : []),
@@ -592,12 +604,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 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"),
@@ -609,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({
@@ -638,8 +652,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 +660,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 +712,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 };
 				}
 
@@ -799,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);
@@ -828,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,
 				});
@@ -988,8 +1016,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;
 				}
 
@@ -1164,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)}`;
 						}),
 					];
 
@@ -1474,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);
@@ -1511,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");
 }
 
 // ============================================================================
@@ -1552,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/scheduler.ts

@@ -258,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);
@@ -308,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);
+		}
 	}
 
 	// =========================================================================
@@ -658,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 || "";
@@ -787,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.
@@ -838,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);
@@ -907,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(),
@@ -1148,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) {
@@ -1163,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 });
@@ -1297,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,
@@ -1353,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}`;
@@ -1387,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
@@ -1405,6 +1421,86 @@ export class Scheduler {
 		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> {
@@ -1434,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);
@@ -1467,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

@@ -122,7 +122,7 @@ export interface Squad {
 // 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;