pi-squad 0.16.4 → 0.16.5

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,7 @@ 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; accepts `squadId` for exact same-squad failed-review rework |
 
 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.5",
   "description": "Multi-agent collaboration extension for pi — task decomposition, dependency management, parallel execution, TUI panel",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -176,6 +176,38 @@ function getActiveScheduler(): Scheduler | null {
 	return schedulers.get(activeSquadId) || null;
 }
 
+/** Reconstruct and focus one exact persisted squad without creating/linking another. */
+function ensureScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	let scheduler = schedulers.get(squadId);
+	if (!scheduler) {
+		scheduler = new Scheduler(squadId, skillPaths, schedulerSpawnContext);
+		schedulers.set(squadId, scheduler);
+		wireSchedulerEvents(pi, scheduler, squadId);
+	}
+	activeSquadId = squadId;
+	widgetState.squadId = squadId;
+	widgetState.enabled = true;
+	widgetControls?.requestUpdate();
+	return scheduler;
+}
+
+function isResumeCandidate(squad: Squad): boolean {
+	return squad.status === "paused" || squad.status === "failed" ||
+		(squad.status === "review" && squad.review?.status === "failed") ||
+		store.loadAllTasks(squad.id).some((task) => task.status === "suspended" || task.status === "failed");
+}
+
+function resolveResumeSquad(cwd: string, explicitId?: string): Squad | null {
+	if (explicitId) return store.loadSquad(explicitId);
+	if (activeSquadId) {
+		const active = store.loadSquad(activeSquadId);
+		if (active?.cwd === cwd && isResumeCandidate(active)) return active;
+	}
+	return store.listSquadsForProject(cwd)
+		.filter(isResumeCandidate)
+		.sort((a, b) => b.created.localeCompare(a.created))[0] ?? null;
+}
+
 
 // ============================================================================
 // Extension Entry
@@ -560,8 +592,9 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "squad_modify",
 		label: "Squad Modify",
-		description: "Modify the running squad: add_task, cancel_task, complete_task (mark done + schedule dependents), pause, resume (also recovers failed squads), cancel (entire squad).",
+		description: "Modify one exact squad: add_task, cancel_task, complete_task (mark done + schedule dependents), pause, resume_task, resume (including failed-review rework), cancel. add_task/resume_task/resume reconstruct the persisted scheduler after restart.",
 		parameters: Type.Object({
+			squadId: Type.Optional(Type.String({ description: "Exact squad to modify (recommended for failed-review rework; default: focused/recoverable project squad)" })),
 			action: Type.Union(
 				[
 					Type.Literal("add_task"),
@@ -590,45 +623,37 @@ export default function (pi: ExtensionAPI) {
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			// Resume can work without an active scheduler — it recreates one from disk
 			if (params.action === "resume") {
-				// Find a squad to resume: use activeSquadId or find the latest paused one
-				const squadId = activeSquadId || store.findActiveSquads()
-					.filter((s) => s.cwd === ctx.cwd && (s.status === "paused" || s.status === "failed"))
-					.sort((a, b) => b.created.localeCompare(a.created))[0]?.id;
-
-				if (!squadId) {
-					return { content: [{ type: "text" as const, text: "No paused or failed squad found to resume." }], details: undefined };
+				const squad = resolveResumeSquad(ctx.cwd, params.squadId);
+				if (!squad) {
+					const text = params.squadId
+						? `Squad '${params.squadId}' not found.`
+						: "No paused, failed, or failed-review squad found to resume.";
+					return { content: [{ type: "text" as const, text }], details: undefined };
 				}
-
-				// Create a fresh scheduler if needed
-				if (!schedulers.has(squadId)) {
-					const scheduler = new Scheduler(squadId, squadSkillPaths, schedulerSpawnContext);
-					schedulers.set(squadId, scheduler);
-					activeSquadId = squadId;
-
-					// Activate widget
-					widgetState.squadId = squadId;
-					widgetState.enabled = true;
-					widgetControls?.requestUpdate();
-
-					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);
+				const done = tasks.filter((task) => task.status === "done").length;
+				return { content: [{ type: "text" as const, text: `Squad "${squad.id}" resumed (${done}/${tasks.length} done). Agents restarting in background.` }], details: undefined };
 			}
 
-			const activeScheduler = getActiveScheduler();
-			if (!activeScheduler || !activeSquadId) {
-				return { content: [{ type: "text" as const, text: "No active squad. Use squad_modify with action 'resume' to resume a paused squad, or start a new one with the squad tool." }], details: undefined };
+			const squadId = params.squadId || activeSquadId;
+			if (!squadId || !store.loadSquad(squadId)) {
+				return { content: [{ type: "text" as const, text: params.squadId ? `Squad '${params.squadId}' not found.` : "No active squad. Provide squadId, select the squad, or start a new one." }], details: undefined };
+			}
+			let activeScheduler = schedulers.get(squadId) || null;
+			if (!activeScheduler && (params.action === "add_task" || params.action === "resume_task")) {
+				activeScheduler = ensureScheduler(pi, squadId, squadSkillPaths);
+			}
+			if (!activeScheduler) {
+				return { content: [{ type: "text" as const, text: `Squad '${squadId}' has no active scheduler. Use resume, add_task, or resume_task to reconstruct it.` }], details: undefined };
 			}
+			activeSquadId = squadId;
 
 			switch (params.action) {
 				case "add_task": {
@@ -645,17 +670,19 @@ export default function (pi: ExtensionAPI) {
 					if (badDeps.length > 0) {
 						return { content: [{ type: "text" as const, text: `Unknown dependency task(s): ${badDeps.join(", ")}. Existing tasks: ${[...existingIds].join(", ")}` }], details: undefined };
 					}
-					if (!store.loadAgentDef(params.task.agent, ctx.cwd)) {
-						const available = store.loadAllAgentDefs(ctx.cwd).filter((a) => !a.disabled).map((a) => a.name).join(", ");
+					const targetCwd = store.loadSquad(squadId)!.cwd;
+					if (!store.loadAgentDef(params.task.agent, targetCwd)) {
+						const available = store.loadAllAgentDefs(targetCwd).filter((a) => !a.disabled).map((a) => a.name).join(", ");
 						return { content: [{ type: "text" as const, text: `Unknown agent '${params.task.agent}'. Available: ${available}` }], details: undefined };
 					}
+					const dependencies = params.task.depends || [];
 					const task: Task = {
 						id: params.task.id,
 						title: params.task.title,
 						description: params.task.description || "",
 						agent: params.task.agent,
-						status: "pending",
-						depends: params.task.depends || [],
+						status: dependencies.every((dependency) => existing.find((candidate) => candidate.id === dependency)?.status === "done") ? "pending" : "blocked",
+						depends: dependencies,
 						...(params.task.inheritContext ? { inheritContext: true } : {}),
 						created: store.now(),
 						started: null,
@@ -664,9 +691,12 @@ export default function (pi: ExtensionAPI) {
 						error: null,
 						usage: { inputTokens: 0, outputTokens: 0, cost: 0, turns: 0 },
 					};
-					store.createTask(activeSquadId, task);
-					activeScheduler.updateContext();
-					return { content: [{ type: "text" as const, text: `Task '${task.id}' added.` }], details: undefined };
+					try {
+						await activeScheduler.addTask(task);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `add_task failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${task.id}' added to squad '${squadId}'.` }], details: undefined };
 				}
 
 				case "cancel_task": {
@@ -683,10 +713,12 @@ export default function (pi: ExtensionAPI) {
 
 				case "resume_task": {
 					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
-					activeScheduler.resumeTask(params.taskId).catch((err) => {
-						logError("squad", `Resume task error: ${(err as Error).message}`);
-					});
-					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed.` }], details: undefined };
+					try {
+						await activeScheduler.resumeTask(params.taskId);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `resume_task failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed in squad '${squadId}'.` }], details: undefined };
 				}
 
 				case "complete_task": {
@@ -866,12 +898,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 +974,25 @@ export default function (pi: ExtensionAPI) {
 					return;
 				}
 
+				case "resume": {
+					const squad = resolveResumeSquad(ctx.cwd, parts[1]);
+					if (!squad) {
+						ctx.ui.notify(parts[1] ? `Squad '${parts[1]}' not found` : "No paused, failed, or failed-review squad found", "warning");
+						return;
+					}
+					const scheduler = ensureScheduler(pi, squad.id, squadSkillPaths);
+					try {
+						await scheduler.resume();
+					} catch (error) {
+						ctx.ui.notify(`Resume failed: ${(error as Error).message}`, "error");
+						return;
+					}
+					const tasks = store.loadAllTasks(squad.id);
+					const done = tasks.filter((task) => task.status === "done").length;
+					ctx.ui.notify(`Resumed: ${squad.id} (${done}/${tasks.length} done)`, "info");
+					return;
+				}
+
 				case "widget": {
 					widgetState.enabled = !widgetState.enabled;
 					if (widgetState.enabled) {
@@ -1398,7 +1450,7 @@ export default function (pi: ExtensionAPI) {
 						activateSquadView(direct.id, ctx);
 						return;
 					}
-					ctx.ui.notify(`Unknown: /squad ${sub}. Try: list, all, select, agents, defaults, msg, widget, panel, cancel, clear, cleanup`, "warning");
+					ctx.ui.notify(`Unknown: /squad ${sub}. Try: list, all, select, resume, agents, defaults, msg, widget, panel, cancel, clear, cleanup`, "warning");
 			}
 		},
 	});

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();
@@ -262,8 +274,7 @@ export class Scheduler {
 			recoveredMailbox = true;
 		}
 		if (recoveredMailbox && squad.status !== "running") {
-			squad.status = "running";
-			delete squad.review;
+			beginOrchestratorRework(squad);
 			store.saveSquad(squad);
 		}
 
@@ -1301,6 +1312,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 +1335,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. */
@@ -1381,10 +1396,32 @@ 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();
+	}
+
+	/** 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();
 	}
 
 	/**

package/src/types.ts

@@ -112,8 +112,10 @@ 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[];
 }
 
 // ============================================================================