pi-squad 0.19.3 → 0.19.5

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.19.5] - 2026-07-24
+
+### Fixed
+
+- Terminal task failures are now reported to the main session immediately when the rest of the squad keeps running (new `squad-task-failed` notification with the exact task, agent, error, and repair guidance). Previously an individual agent death — e.g. `Agent devops exited before RPC response` — was invisible in chat until the whole squad stalled or finished. When no runnable work remains, the existing `squad-failed` summary is sent instead, never both.
+- A task that completes after an interim failure (spawn retry, RPC race during reopen) no longer displays the stale error annotation forever; successful completion clears `task.error`.
+
+## [0.19.4] - 2026-07-24
+
+### Fixed
+
+- The mandatory review-required report can no longer be silently lost or invisibly stalled. Successful delivery is durably recorded as `review.notifiedAt`; the 60s reconcile loop re-raises an unrecorded pending gate (covers delivery exceptions and disabled-mode drops), and an immediate TUI notification surfaces the pending review even while a long or stalled main-session run delays the queued follow-up report. Delivered gates are never re-notified while a human review is in progress.
+- `squad_failed` stall notifications now fire only on the actual transition to `failed`. Repeated reconciles over an already-failed squad no longer queue duplicate notifications, each of which previously triggered its own main-session turn.
+- Review-required delivery failures are now logged to `~/.pi/squad/debug.log` instead of being swallowed.
+
 ## [0.19.3] - 2026-07-19
 
 ### Fixed

package/package.json

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

package/src/scheduler-runtime.ts

@@ -22,14 +22,32 @@ export function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squa
 				const totalCost = tasks.reduce((sum, task) => sum + task.usage.cost, 0);
 				scheduler.updateContext();
 				if (!squad) break;
-				pi.sendMessage({
-					customType: "squad-review-required",
-					content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
-						`Squad claims (review inputs only):\n${summary}\n\n` +
-						`Total cost: $${totalCost.toFixed(4)}\n\n` +
-						buildOrchestratorReviewGate(squad, tasks),
-					display: true,
-				}, { triggerTurn: true, deliverAs: "followUp" });
+				try {
+					pi.sendMessage({
+						customType: "squad-review-required",
+						content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
+							`Squad claims (review inputs only):\n${summary}\n\n` +
+							`Total cost: $${totalCost.toFixed(4)}\n\n` +
+							buildOrchestratorReviewGate(squad, tasks),
+						display: true,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+					// Record durable delivery so reconcile stops re-raising the gate.
+					// An unrecorded emission (throw here, or the disabled-mode drop
+					// above) is re-emitted by the next reconcile pass.
+					const fresh = store.loadSquad(squadId);
+					if (fresh?.review?.status === "pending" && !fresh.review.notifiedAt) {
+						fresh.review.notifiedAt = store.now();
+						store.saveSquad(fresh);
+					}
+				} catch (error) {
+					logError("squad-scheduler", `review-required delivery failed for ${squadId}: ${(error as Error).message}`);
+				}
+				// The followUp above waits for the current main run to settle. Surface
+				// the pending gate immediately in the TUI so a long/stalled run cannot
+				// hide it for hours.
+				try {
+					if (runtime.uiCtx?.hasUI) runtime.uiCtx.ui.notify(`[squad] "${squadId}" finished — awaiting your independent review (report queued for end of current turn)`, "info");
+				} catch { /* toast is best-effort */ }
 				// Keep the settled scheduler addressable. A later exact-task message
 				// can reopen the task immediately on its bound durable Pi session.
 				break;
@@ -48,6 +66,29 @@ export function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squa
 				}
 				break;
 			}
+			case "task_failed": {
+				// A task died terminally while the squad continues. Without this the
+				// main session learns about individual failures only when the whole
+				// squad later stalls or finishes. When no runnable work remains the
+				// imminent squad_failed event carries the failure summary instead, so
+				// skip the task-level message to avoid duplicate notifications.
+				try {
+					const tasks = store.loadAllTasks(squadId);
+					const squadContinues = tasks.some((task) => task.status === "in_progress" || task.status === "pending");
+					if (!squadContinues) break;
+					const failed = tasks.find((task) => task.id === event.taskId);
+					pi.sendMessage({
+						customType: "squad-task-failed",
+						content: `[squad] Task '${event.taskId}'${failed ? ` (${failed.agent})` : ""} FAILED in '${squadId}' while other tasks continue.\n` +
+							`Error: ${event.message ?? failed?.error ?? "unknown"}\n` +
+							`Dependents of this task stay blocked. Repair now with squad_modify — resume_task to retry it, set_dependencies to reroute, or cancel_task if obsolete — or the squad will stall after the remaining tasks finish.`,
+						display: true,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+				} catch (error) {
+					logError("squad-scheduler", `task-failed delivery failed for ${squadId}/${event.taskId}: ${(error as Error).message}`);
+				}
+				break;
+			}
 			case "squad_failed": {
 				const tasks = store.loadAllTasks(squadId);
 				const failed = tasks.filter((task) => task.status === "failed");

package/src/scheduler.ts

@@ -403,6 +403,15 @@ export class Scheduler {
 		if (freshSquad && (freshSquad.status === "running" || freshSquad.status === "failed")) {
 			this.checkSquadCompletion(store.loadAllTasks(this.squadId), freshSquad);
 		}
+
+		// A pending review whose notification never reached the main session
+		// (delivery threw, or disabled mode dropped the event) is re-raised until
+		// the delivery handler durably records review.notifiedAt. Successful
+		// delivery stops the re-raise, so a slow human review never re-notifies.
+		const reviewSquad = freshSquad?.status === "review" ? freshSquad : store.loadSquad(this.squadId);
+		if (reviewSquad?.status === "review" && reviewSquad.review?.status === "pending" && !reviewSquad.review.notifiedAt) {
+			this.emit({ type: "squad_review_required", squadId: this.squadId });
+		}
 	}
 
 	// =========================================================================
@@ -985,8 +994,11 @@ export class Scheduler {
 			.filter((m) => m.from === task.agent && (m.type === "text" || m.type === "done"));
 		const output = agentMessages.map((m) => m.text).join("\n");
 
+		// Clear any interim failure annotation (spawn retry, RPC race): a task
+		// that ultimately completed must not display a stale error forever.
 		store.updateTaskStatus(this.squadId, taskId, "done", {
 			output: output || "Task completed",
+			error: null,
 			completed: store.now(),
 		});
 
@@ -1328,7 +1340,11 @@ export class Scheduler {
 			store.saveSquad(squad);
 			this.emit({ type: "squad_review_required", squadId: this.squadId });
 		} else if (anyFailed && !anyInProgress) {
-			// All remaining tasks are blocked/failed with no way forward
+			// All remaining tasks are blocked/failed with no way forward.
+			// Emit only on the transition: repeated reconciles over an already-failed
+			// squad must not queue duplicate stall notifications (each would trigger
+			// its own main-session turn).
+			if (squad.status === "failed") return;
 			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) {

package/src/types.ts

@@ -78,6 +78,9 @@ export type SquadStatus = "planning" | "running" | "paused" | "review" | "done"
 export interface SquadReview {
 	status: "pending" | "passed" | "failed";
 	requestedAt: string;
+	/** When the review-required notification was handed to the main session.
+	 * Absent/null = not yet delivered; reconcile re-raises the gate. */
+	notifiedAt?: string | null;
 	completedAt: string | null;
 	verdict: "pass" | "pass_with_issues" | "fail" | null;
 	contractChecks: string[];