pi-squad 0.19.3 → 0.19.4

package/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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.4",
   "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;

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 });
+		}
 	}
 
 	// =========================================================================
@@ -1328,7 +1337,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[];