pi-squad 0.14.0 → 0.15.1

package/README.md

@@ -41,9 +41,13 @@ The planner agent reads your codebase and creates a task breakdown automatically
 2. A **live widget** appears above the editor showing task progress
 3. **Specialist agents** spawn as separate pi processes, working in parallel where dependencies allow
 4. QA agents can trigger **automatic rework loops** when they find bugs
-5. On completion, pi receives a summary with each task's output
+5. On completion, pi receives a summary with each task's **complete, untruncated output**
 6. Multiple squads can run concurrently across different projects
 
+### No-Truncation Contract
+
+Task messages, task outputs, dependency/rework handoffs, QA feedback, advisor handoffs, completion reports, failure diagnostics, and planner errors are persisted and forwarded in full. There is no character or task-count limit on report data. TUI widgets may show width/height-limited **views** to fit the terminal, but the underlying data and agent/main-session handoffs remain complete.
+
 ## Features
 
 ### Dependency-Aware Scheduling
@@ -183,7 +187,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` | Send message to a running agent |
-| `squad_modify` | Add/cancel/pause/resume tasks or squads |
+| `squad_modify` | Add/cancel/complete/pause/resume tasks or squads |
 
 The main agent sees available agents in its system prompt and squad state when a squad is active.
 
@@ -280,18 +284,21 @@ Agents must complete at least 1 LLM turn AND make at least 1 tool call to be mar
 ### Session Resilience
 
 - In-progress tasks are **suspended** on session crash, **resumed** on next startup
+- Failure is never terminal: `resume` recovers failed squads (failed tasks reset to pending), `complete_task` marks recovered work done and schedules dependents, and a 60s reconcile loop re-derives scheduling from persisted state so out-of-band store edits can't strand ready tasks
 - Squads are fully reconstructable from JSON files on disk
 - Spawn failures are retried once with a 2-second delay
 - All errors logged to `~/.pi/squad/debug.log` (always for errors, `PI_SQUAD_DEBUG=1` for verbose)
 
 ### Health Monitoring
 
+The monitor never kills or blocks work on its own — its strongest action is notifying the main Pi session so you (or the main agent) can decide.
+
 | Check | Threshold | Action |
 |---|---|---|
 | Idle warning | 3 minutes no output | Steer agent with nudge |
-| Stuck detection | 5 minutes no output | Abort and fail task |
+| Stuck detection | 5 minutes no output | Steer, then escalate to main session |
 | Loop detection | Same tool call 5x | Steer with warning |
-| Hard ceiling | 30 minutes total | Abort task |
+| Long-running check-in | Every 30 minutes total (`PI_SQUAD_CEILING_MS`) | Notify main session — work continues |
 
 ## Data Layout
 
@@ -320,7 +327,7 @@ src/
 ├── agent-pool.ts     — pi RPC process management, activity tracking
 ├── protocol.ts       — system prompt builder (chain context, sibling awareness, knowledge)
 ├── router.ts         — @mention parsing, cross-agent messaging
-├── monitor.ts        — health checks (idle, stuck, loop, ceiling)
+├── monitor.ts        — health checks (idle, stuck, loop, long-run notify)
 ├── planner.ts        — one-shot goal decomposition via LLM
 ├── logger.ts         — file-based logging (never writes to stderr)
 ├── panel/            — TUI overlay panel and widget

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-squad",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Multi-agent collaboration extension for pi — task decomposition, dependency management, parallel execution, TUI panel",
   "type": "module",
   "scripts": {
@@ -48,5 +48,8 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1"
   }
 }

package/src/advisor.ts

@@ -78,18 +78,10 @@ Output format:
 
 Keep it short. The agent reads your advice and immediately acts on it.`;
 
-const MAX_MSG_CHARS = 400;
-const MAX_MESSAGES = 12;
-const MAX_TOOL_CALLS = 10;
-
-function clamp(text: string, max: number): string {
-	const t = text.trim();
-	return t.length > max ? `${t.slice(0, max).trimEnd()}…` : t;
-}
-
 /**
  * Build the user-message digest sent to the advisor model.
- * Curated and bounded — summaries, not full transcripts.
+ * Preserve complete descriptions, messages, and tool history: advisor handoffs
+ * follow the same no-truncation contract as task and completion reports.
  */
 export function buildAdvisorConsultText(input: AdvisorConsultInput): string {
 	const lines: string[] = [];
@@ -102,22 +94,21 @@ export function buildAdvisorConsultText(input: AdvisorConsultInput): string {
 	lines.push(`Progress: ${input.turnCount} turns, ~${Math.round(input.elapsedMinutes)} min elapsed`);
 	lines.push("");
 	lines.push(`## Task Description`);
-	lines.push(clamp(input.taskDescription || "(no description)", 1500));
+	lines.push((input.taskDescription || "(no description)").trim());
 
 	if (input.recentToolCalls.length > 0) {
 		lines.push("");
 		lines.push(`## Recent Tool Activity (newest last)`);
-		for (const call of input.recentToolCalls.slice(-MAX_TOOL_CALLS)) {
-			lines.push(`- ${clamp(call, 160)}`);
+		for (const call of input.recentToolCalls) {
+			lines.push(`- ${call.trim()}`);
 		}
 	}
 
-	const messages = input.recentMessages.slice(-MAX_MESSAGES);
-	if (messages.length > 0) {
+	if (input.recentMessages.length > 0) {
 		lines.push("");
 		lines.push(`## Recent Messages (newest last)`);
-		for (const msg of messages) {
-			lines.push(`[${msg.from}/${msg.type}] ${clamp(msg.text, MAX_MSG_CHARS)}`);
+		for (const msg of input.recentMessages) {
+			lines.push(`[${msg.from}/${msg.type}] ${msg.text.trim()}`);
 		}
 	}
 
@@ -141,5 +132,5 @@ export function formatAdvisorSteerMessage(advice: string, reason: string): strin
 
 /** True when the advisor's verdict says a human decision is required. */
 export function adviceNeedsHuman(advice: string): boolean {
-	return /needs human input/i.test(advice.slice(0, 200));
+	return /needs human input/i.test(advice);
 }

package/src/agent-pool.ts

@@ -217,7 +217,7 @@ export class AgentPool {
 		proc.on("exit", (code, signal) => {
 			// Log diagnostic info for debugging spawn failures
 			if (code !== 0 && code !== null) {
-				logError("squad-pool", `${agentDef.name} exited: code=${code} signal=${signal} pid=${proc.pid} stdoutLines=${stdoutLines} stderr=${stderr.slice(0, 300) || "(empty)"}`);
+				logError("squad-pool", `${agentDef.name} exited: code=${code} signal=${signal} pid=${proc.pid} stdoutLines=${stdoutLines} stderr=${stderr || "(empty)"}`);
 			}
 			// Capture activity stats BEFORE deleting the agent
 			const finalActivity = agentProc.activity;
@@ -232,7 +232,8 @@ export class AgentPool {
 					agentName: agentDef.name,
 					data: {
 						exitCode: code,
-						stderr: stderr.slice(-2000),
+						// Preserve complete diagnostics for task failure reports and recovery.
+						stderr,
 						turnCount: finalActivity.turnCount,
 						toolCallCount: finalActivity.recentToolCalls.length,
 						filesModified: finalActivity.modifiedFiles.size,

package/src/index.ts

@@ -25,6 +25,7 @@ import { SquadPanel, type SquadPanelResult } from "./panel/squad-panel.js";
 import { setupSquadWidget, type SquadWidgetState } from "./panel/squad-widget.js";
 import * as store from "./store.js";
 import { debug, logError } from "./logger.js";
+import { buildCompletionSummary, buildFailureSummary } from "./report.js";
 
 // ============================================================================
 // State
@@ -229,8 +230,8 @@ export default function (pi: ExtensionAPI) {
 			const taskLines = tasks.map((t) => {
 				const icon = t.status === "done" ? "✓" : t.status === "in_progress" ? "⏳" : t.status === "failed" ? "✗" : t.status === "blocked" ? "◻" : "·";
 				let line = `  ${icon} ${t.id} (${t.agent}) [${t.status}]`;
-				if (t.output) line += ` — ${t.output.split("\n")[0].slice(0, 80)}`;
-				if (t.error) line += ` ERROR: ${t.error.slice(0, 60)}`;
+				if (t.output) line += ` — ${t.output}`;
+				if (t.error) line += ` ERROR: ${t.error}`;
 				return line;
 			}).join("\n");
 
@@ -461,7 +462,7 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "squad_modify",
 		label: "Squad Modify",
-		description: "Modify the running squad: add_task, cancel_task, pause, resume, cancel (entire squad).",
+		description: "Modify the running squad: add_task, cancel_task, complete_task (mark done + schedule dependents), pause, resume (also recovers failed squads), cancel (entire squad).",
 		parameters: Type.Object({
 			action: Type.Union(
 				[
@@ -469,6 +470,7 @@ export default function (pi: ExtensionAPI) {
 					Type.Literal("cancel_task"),
 					Type.Literal("pause_task"),
 					Type.Literal("resume_task"),
+					Type.Literal("complete_task"),
 					Type.Literal("pause"),
 					Type.Literal("resume"),
 					Type.Literal("cancel"),
@@ -476,6 +478,7 @@ export default function (pi: ExtensionAPI) {
 				{ description: "Action to perform" },
 			),
 			taskId: Type.Optional(Type.String({ description: "Task ID for task-specific actions" })),
+			output: Type.Optional(Type.String({ description: "Result summary for complete_task (what was accomplished)" })),
 			task: Type.Optional(
 				Type.Object({
 					id: Type.String(),
@@ -493,11 +496,11 @@ export default function (pi: ExtensionAPI) {
 			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")
+					.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 squad found to resume." }], details: undefined };
+					return { content: [{ type: "text" as const, text: "No paused or failed squad found to resume." }], details: undefined };
 				}
 
 				// Create a fresh scheduler if needed
@@ -517,10 +520,7 @@ export default function (pi: ExtensionAPI) {
 						switch (event.type) {
 							case "squad_completed": {
 								const tasks = store.loadAllTasks(squadId);
-								const summary = tasks
-									.filter((t) => t.status === "done")
-									.map((t) => `- ${t.id} (${t.agent}): ${t.output?.slice(0, 150) || "done"}`)
-									.join("\n");
+								const summary = buildCompletionSummary(tasks);
 								const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 								const s = schedulers.get(squadId); if (s) s.updateContext();
 								// followUp + triggerTurn: wake an idle main agent to review;
@@ -540,7 +540,7 @@ export default function (pi: ExtensionAPI) {
 								const done = tasks.filter((t) => t.status === "done");
 								pi.sendMessage({
 									customType: "squad-failed",
-									content: `[squad] Squad "${squadId}" has stalled. ${done.length}/${tasks.length} done, ${failed.length} failed.\nFailed: ${failed.map((t) => `${t.id}: ${t.error?.slice(0, 100)}`).join("; ")}`,
+									content: `[squad] Squad "${squadId}" has stalled. ${done.length}/${tasks.length} done, ${failed.length} failed.\nFailed: ${buildFailureSummary(tasks)}`,
 									display: true,
 								}, { triggerTurn: true, deliverAs: "followUp" });
 								forceWidgetUpdate();
@@ -632,6 +632,16 @@ export default function (pi: ExtensionAPI) {
 					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' resumed.` }], details: undefined };
 				}
 
+				case "complete_task": {
+					if (!params.taskId) return { content: [{ type: "text" as const, text: "Provide taskId." }], details: undefined };
+					try {
+						await activeScheduler.completeTask(params.taskId, params.output);
+					} catch (err) {
+						return { content: [{ type: "text" as const, text: `complete_task failed: ${(err as Error).message}` }], details: undefined };
+					}
+					return { content: [{ type: "text" as const, text: `Task '${params.taskId}' marked done — dependents unblocked and scheduled.` }], details: undefined };
+				}
+
 				case "pause": {
 					const squad = store.loadSquad(activeSquadId);
 					if (squad) {
@@ -920,7 +930,7 @@ export default function (pi: ExtensionAPI) {
 					const msgSched = getActiveScheduler();
 					if (msgSched) {
 						await msgSched.sendHumanMessage(targetTaskId, msgText);
-						ctx.ui.notify(`Sent to ${targetAgent}: "${msgText.slice(0, 50)}"`, "info");
+						ctx.ui.notify(`Sent to ${targetAgent}: "${msgText}"`, "info");
 					} else {
 						store.appendMessage(activeSquadId, targetTaskId, {
 							ts: store.now(),
@@ -1198,7 +1208,7 @@ export default function (pi: ExtensionAPI) {
 								`Tags: ${agent.tags.join(", ")}`,
 								``,
 								`Prompt:`,
-								`${agent.prompt.slice(0, 300)}${agent.prompt.length > 300 ? "..." : ""}`,
+								agent.prompt,
 								``,
 								`File: ${store.getGlobalAgentsDir()}/${agent.name}.json`,
 							].join("\n");
@@ -1387,7 +1397,7 @@ function openPanel(
 				const panelSched = schedulers.get(squadId);
 				if (input && panelSched) {
 					await panelSched.sendHumanMessage(taskId, input);
-					ctx.ui.notify(`Sent to ${agentName}: "${input.slice(0, 50)}"`, "info");
+					ctx.ui.notify(`Sent to ${agentName}: "${input}"`, "info");
 				} else if (input) {
 					store.appendMessage(squadId, taskId, {
 						ts: store.now(),
@@ -1555,10 +1565,7 @@ async function startSquad(
 		switch (event.type) {
 				case "squad_completed": {
 				const tasks = store.loadAllTasks(squadId);
-				const summary = tasks
-					.filter((t) => t.status === "done")
-					.map((t) => `- ${t.id} (${t.agent}): ${t.output?.slice(0, 150) || "done"}`)
-					.join("\n");
+				const summary = buildCompletionSummary(tasks);
 				const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 
 				// Final context update before clearing scheduler
@@ -1593,7 +1600,7 @@ async function startSquad(
 					customType: "squad-failed",
 					content: `[squad] Squad "${squadId}" has stalled. ` +
 						`${done.length}/${tasks.length} tasks done, ${failed.length} failed.\n` +
-						`Failed: ${failed.map((t) => `${t.id}: ${t.error?.slice(0, 100)}`).join("; ")}\n` +
+						`Failed: ${buildFailureSummary(tasks)}\n` +
 						`Use squad_status for details or squad_modify to adjust.`,
 					display: true,
 				}, { triggerTurn: true, deliverAs: "followUp" });

package/src/monitor.ts

@@ -5,8 +5,11 @@
  * - Idle timeout (no output for N minutes)
  * - Stuck detection (no output for longer)
  * - Loop detection (same tool call repeated)
- * - Hard ceiling (max total runtime)
+ * - Long-running check-in (notify the main session; never aborts)
  * - File conflict warnings
+ *
+ * The monitor NEVER kills or blocks work on its own. Its strongest action is
+ * `notify`: tell the main Pi session so a human/main agent can check in.
  */
 
 import type { AgentPool } from "./agent-pool.js";
@@ -25,7 +28,7 @@ function envMs(name: string, fallback: number): number {
 
 const IDLE_WARNING_MS = envMs("PI_SQUAD_IDLE_MS", 3 * 60 * 1000); // no output → warn
 const STUCK_TIMEOUT_MS = envMs("PI_SQUAD_STUCK_MS", 5 * 60 * 1000); // no output → intervene
-const HARD_CEILING_MS = envMs("PI_SQUAD_CEILING_MS", 30 * 60 * 1000); // total → force stop
+const LONG_RUN_NOTIFY_MS = envMs("PI_SQUAD_CEILING_MS", 30 * 60 * 1000); // total → notify main session (no abort)
 const LOOP_THRESHOLD = 5; // same tool call 5x → looping
 const POLL_INTERVAL_MS = envMs("PI_SQUAD_POLL_MS", 30 * 1000); // check interval
 
@@ -33,7 +36,7 @@ const POLL_INTERVAL_MS = envMs("PI_SQUAD_POLL_MS", 30 * 1000); // check interval
 // Types
 // ============================================================================
 
-export type MonitorActionType = "steer" | "abort" | "escalate";
+export type MonitorActionType = "steer" | "escalate" | "notify";
 
 export interface MonitorAction {
 	type: MonitorActionType;
@@ -60,6 +63,8 @@ export class Monitor {
 	private stuckSteered = new Set<string>();
 	/** Track which tasks have been escalated (one escalation per stuck episode) */
 	private escalated = new Set<string>();
+	/** Last long-run threshold multiple notified per task (notify once per multiple) */
+	private longRunNotified = new Map<string, number>();
 
 	constructor(pool: AgentPool, squadId: string) {
 		this.pool = pool;
@@ -100,6 +105,7 @@ export class Monitor {
 		this.warned.clear();
 		this.stuckSteered.clear();
 		this.escalated.clear();
+		this.longRunNotified.clear();
 	}
 
 	/** Check all running agents */
@@ -112,7 +118,7 @@ export class Monitor {
 			if (!activity) continue;
 
 			const health = this.checkHealth(activity);
-			this.handleHealth(taskId, agentName, health);
+			this.handleHealth(taskId, agentName, health, activity);
 		}
 	}
 
@@ -133,7 +139,7 @@ export class Monitor {
 			if (unique.size === 1) return "looping";
 		}
 
-		if (totalMs >= HARD_CEILING_MS) return "exceeded_ceiling";
+		if (totalMs >= LONG_RUN_NOTIFY_MS) return "long_running";
 		if (idleMs >= STUCK_TIMEOUT_MS) return "stuck";
 		if (idleMs >= IDLE_WARNING_MS) return "idle_warning";
 
@@ -141,7 +147,12 @@ export class Monitor {
 	}
 
 	/** Take action based on health status */
-	private handleHealth(taskId: string, agentName: string, status: HealthStatus): void {
+	private handleHealth(
+		taskId: string,
+		agentName: string,
+		status: HealthStatus,
+		activity?: { startedAt: number },
+	): void {
 		if (status !== "healthy") debug("squad-monitor", `${taskId} (${agentName}): ${status}`);
 		switch (status) {
 			case "healthy":
@@ -203,15 +214,25 @@ export class Monitor {
 				});
 				break;
 
-			case "exceeded_ceiling":
-				this.emit({
-					type: "abort",
-					taskId,
-					agentName,
-					reason: `Agent ${agentName} exceeded time ceiling on ${taskId}`,
-					message: "",
-				});
+			case "long_running": {
+				// Never abort. Notify the main Pi session once per threshold multiple
+				// (30m, 60m, 90m, …) so it can check in if needed — work continues.
+				const totalMs = Date.now() - (activity?.startedAt ?? Date.now());
+				const multiple = Math.floor(totalMs / LONG_RUN_NOTIFY_MS);
+				const lastNotified = this.longRunNotified.get(taskId) ?? 0;
+				if (multiple > lastNotified) {
+					this.longRunNotified.set(taskId, multiple);
+					const minutes = Math.round(totalMs / 60_000);
+					this.emit({
+						type: "notify",
+						taskId,
+						agentName,
+						reason: `Agent ${agentName} has been working on ${taskId} for ${minutes}m. Still running — check on it if needed (steer, pause, or let it continue).`,
+						message: "",
+					});
+				}
 				break;
+			}
 		}
 	}
 }

package/src/planner.ts

@@ -152,7 +152,7 @@ async function runPiJson(options: PiJsonOptions): Promise<string> {
 			}
 
 			if (code !== 0 && messages.length === 0) {
-				reject(new Error(`Planner failed (code ${code}): ${stderr.slice(0, 500)}`));
+				reject(new Error(`Planner failed (code ${code}): ${stderr}`));
 				return;
 			}
 
@@ -217,7 +217,7 @@ function parsePlannerOutput(text: string, validAgents?: Set<string>): PlannerOut
 		return parsed as PlannerOutput;
 	} catch (error) {
 		if (error instanceof SyntaxError) {
-			throw new Error(`Planner output is not valid JSON: ${text.slice(0, 200)}`);
+			throw new Error(`Planner output is not valid JSON: ${text}`);
 		}
 		throw error;
 	}

package/src/protocol.ts

@@ -102,7 +102,6 @@ function buildChainContext(task: Task, allTasks: Task[], squadId: string): strin
 			const messages = loadMessages(squadId, dep.id);
 			const lastText = messages
 				.filter((m) => m.from === dep.agent && (m.type === "text" || m.type === "done"))
-				.slice(-3)
 				.map((m) => m.text)
 				.join("\n");
 			if (lastText) {
@@ -155,12 +154,9 @@ function buildSiblingAwareness(
 		for (const [agent, files] of fileEntries) {
 			if (files.length > 0) {
 				lines.push(`**${agent}:**`);
-				for (const f of files.slice(0, 10)) {
+				for (const f of files) {
 					lines.push(`  - ${f}`);
 				}
-				if (files.length > 10) {
-					lines.push(`  - ...and ${files.length - 10} more`);
-				}
 			}
 		}
 		lines.push(
@@ -187,7 +183,7 @@ function buildKnowledgeSection(squadId: string): string {
 
 	if (decisions.length > 0) {
 		lines.push("## Decisions");
-		for (const d of decisions.slice(-10)) {
+		for (const d of decisions) {
 			lines.push(`- ${d.text} (${d.from})`);
 		}
 		lines.push("");
@@ -195,7 +191,7 @@ function buildKnowledgeSection(squadId: string): string {
 
 	if (conventions.length > 0) {
 		lines.push("## Project Conventions");
-		for (const c of conventions.slice(-10)) {
+		for (const c of conventions) {
 			lines.push(`- ${c.text} (${c.from})`);
 		}
 		lines.push("");
@@ -203,7 +199,7 @@ function buildKnowledgeSection(squadId: string): string {
 
 	if (findings.length > 0) {
 		lines.push("## Findings");
-		for (const f of findings.slice(-10)) {
+		for (const f of findings) {
 			lines.push(`- ${f.text} (${f.from})`);
 		}
 		lines.push("");
@@ -256,7 +252,8 @@ function buildReworkContext(task: Task, squadId: string): string {
 
 	if (originalTask?.output) {
 		lines.push("## What Was Built (Previous Attempt)");
-		lines.push(originalTask.output.slice(0, 2000));
+		// Rework agents need the complete prior handoff, not an arbitrary prefix.
+		lines.push(originalTask.output);
 		lines.push("");
 	}
 

package/src/report.ts

@@ -0,0 +1,20 @@
+import type { Task } from "./types.js";
+
+/**
+ * Build the full task handoff included in squad completion notifications.
+ * This is durable report data, not a UI preview: never shorten task output.
+ */
+export function buildCompletionSummary(tasks: Task[]): string {
+	return tasks
+		.filter((task) => task.status === "done")
+		.map((task) => `- ${task.id} (${task.agent}): ${task.output || "done"}`)
+		.join("\n");
+}
+
+/** Build the full failure handoff without shortening diagnostics. */
+export function buildFailureSummary(tasks: Task[]): string {
+	return tasks
+		.filter((task) => task.status === "failed")
+		.map((task) => `${task.id}: ${task.error || "unknown error"}`)
+		.join("; ");
+}

package/src/router.ts

@@ -202,6 +202,6 @@ export class Router {
 				return line.trim();
 			}
 		}
-		return text.slice(0, 200);
+		return text;
 	}
 }

package/src/scheduler.ts

@@ -72,6 +72,8 @@ export class Scheduler {
 	private running = false;
 	/** Track spawn retries to allow one retry per task */
 	private spawnRetries = new Set<string>();
+	/** Periodic level-triggered reconcile (heals missed events / out-of-band store edits) */
+	private reconcileTimer: ReturnType<typeof setInterval> | null = null;
 
 	/** Get the project cwd for this squad (from squad.json) */
 	getProjectCwd(): string | undefined {
@@ -93,8 +95,16 @@ export class Scheduler {
 		this.monitor.onAction((action) => {
 			if (action.type === "steer") {
 				this.pool.steer(action.taskId, action.message);
-			} else if (action.type === "abort") {
-				this.handleTaskFailed(action.taskId, action.reason);
+			} else if (action.type === "notify") {
+				// Informational only — tell the main Pi session directly (no advisor
+				// detour, no kill). The agent keeps working.
+				this.emit({
+					type: "escalation",
+					squadId: this.squadId,
+					taskId: action.taskId,
+					agentName: action.agentName,
+					message: action.reason,
+				});
 			} else if (action.type === "escalate") {
 				// Advisor-first: try a strong-model rescue before interrupting the human
 				void this.tryAdvisorRescue(action.taskId, action.agentName, action.reason).then((rescued) => {
@@ -160,13 +170,22 @@ export class Scheduler {
 	async start(): Promise<void> {
 		this.running = true;
 		this.monitor.start();
-		await this.scheduleReadyTasks();
+		await this.reconcile();
+		// Level-triggered safety net: periodically re-derive scheduling decisions
+		// from persisted state so missed in-memory events (crashes, out-of-band
+		// store edits, external recovery) cannot strand ready tasks.
+		this.reconcileTimer = setInterval(() => void this.reconcile(), 60_000);
+		(this.reconcileTimer as { unref?: () => void }).unref?.();
 	}
 
 	/** Stop the scheduler — kills all agents, saves state */
 	async stop(): Promise<void> {
 		this.running = false;
 		this.monitor.stop();
+		if (this.reconcileTimer) {
+			clearInterval(this.reconcileTimer);
+			this.reconcileTimer = null;
+		}
 
 		// Suspend in-progress tasks
 		const tasks = store.loadAllTasks(this.squadId);
@@ -179,17 +198,26 @@ export class Scheduler {
 		await this.pool.killAll();
 	}
 
-	/** Resume from suspended state */
+	/** Resume from suspended OR failed state. Failure is never terminal:
+	 * failed tasks are reset to pending and a failed squad becomes running. */
 	async resume(): Promise<void> {
 		const tasks = store.loadAllTasks(this.squadId);
 		for (const task of tasks) {
 			if (task.status === "suspended") {
 				store.updateTaskStatus(this.squadId, task.id, "pending");
+			} else if (task.status === "failed") {
+				store.updateTaskStatus(this.squadId, task.id, "pending", { error: null });
+				store.appendMessage(this.squadId, task.id, {
+					ts: store.now(),
+					from: "system",
+					type: "status",
+					text: "Reset failed → pending on squad resume",
+				});
 			}
 		}
 
 		const squad = store.loadSquad(this.squadId);
-		if (squad && squad.status === "paused") {
+		if (squad && (squad.status === "paused" || squad.status === "failed")) {
 			squad.status = "running";
 			store.saveSquad(squad);
 		}
@@ -197,6 +225,52 @@ export class Scheduler {
 		await this.start();
 	}
 
+	/**
+	 * Level-triggered reconciliation — derive scheduling from persisted state:
+	 * 1. Unblock blocked tasks whose deps are all done (missed autoUnblock events)
+	 * 2. Self-heal a "failed" squad when runnable work exists (out-of-band recovery)
+	 * 3. Schedule ready tasks
+	 * Safe to call any time; no-ops when nothing changed.
+	 */
+	async reconcile(): Promise<void> {
+		if (!this.running) return;
+		const squad = store.loadSquad(this.squadId);
+		if (!squad) return;
+
+		const tasks = store.loadAllTasks(this.squadId);
+
+		// 1. Blocked → pending when all deps are done (respects autoUnblock config)
+		if (squad.config.autoUnblock) {
+			for (const task of tasks) {
+				if (task.status !== "blocked") continue;
+				const allDepsDone = task.depends.every((depId) => {
+					const dep = tasks.find((t) => t.id === depId);
+					return dep?.status === "done";
+				});
+				if (allDepsDone) {
+					task.status = "pending";
+					store.updateTaskStatus(this.squadId, task.id, "pending");
+					this.emit({ type: "task_unblocked", squadId: this.squadId, taskId: task.id });
+				}
+			}
+		}
+
+		// 2. A "failed" squad with runnable work self-heals to running. This makes
+		// the terminal status derivable from task state instead of a one-way latch.
+		const hasRunnable = tasks.some((t) => {
+			if (t.status === "in_progress") return true;
+			if (t.status !== "pending") return false;
+			return t.depends.every((depId) => tasks.find((x) => x.id === depId)?.status === "done");
+		});
+		if (squad.status === "failed" && hasRunnable) {
+			squad.status = "running";
+			store.saveSquad(squad);
+			debug("squad-scheduler", "reconcile: failed squad has runnable work — healing to running");
+		}
+
+		await this.scheduleReadyTasks();
+	}
+
 	// =========================================================================
 	// Task Scheduling
 	// =========================================================================
@@ -391,7 +465,7 @@ export class Scheduler {
 				agentName: task.agent,
 				agentRole: agentDef?.role || task.agent,
 				reason,
-				recentMessages: store.loadMessages(this.squadId, taskId).slice(-12).map((m) => ({ from: m.from, type: m.type, text: m.text })),
+				recentMessages: store.loadMessages(this.squadId, taskId).map((m) => ({ from: m.from, type: m.type, text: m.text })),
 				recentToolCalls: activity ? [...activity.recentToolCalls] : [],
 				turnCount: activity?.turnCount || 0,
 				elapsedMinutes: activity ? (Date.now() - activity.startedAt) / 60000 : 0,
@@ -414,7 +488,7 @@ export class Scheduler {
 					squadId: this.squadId,
 					taskId,
 					agentName,
-					message: `${reason}\n\nAdvisor assessment:\n${advice.slice(0, 800)}`,
+					message: `${reason}\n\nAdvisor assessment:\n${advice}`,
 				});
 				return true; // escalation already emitted with richer context
 			}
@@ -489,7 +563,9 @@ export class Scheduler {
 							ts: store.now(),
 							from: event.agentName,
 							type: "text",
-							text: text.slice(0, 2000),
+							// Persist the complete handoff. Reports can be arbitrarily long;
+							// presentation layers may viewport them, but source data must never truncate.
+							text,
 						});
 					}
 
@@ -562,7 +638,7 @@ export class Scheduler {
 						const reason = turnCount === 0
 							? `exited with 0 turns (likely rate limit or API error)`
 							: `exited with ${turnCount} turns but 0 tool calls (no work done)`;
-						logError("squad-scheduler", `Agent ${event.agentName} ${reason}, code=${exitCode}. Retrying in 2s... stderr: ${stderr.slice(0, 200)}`);
+						logError("squad-scheduler", `Agent ${event.agentName} ${reason}, code=${exitCode}. Retrying in 2s... stderr: ${stderr}`);
 						store.updateTaskStatus(this.squadId, event.taskId, "pending");
 						store.appendMessage(this.squadId, event.taskId, {
 							ts: store.now(),
@@ -576,7 +652,7 @@ export class Scheduler {
 						}, 2000);
 					} else {
 						const stderr = event.data?.stderr || "";
-						this.handleTaskFailed(event.taskId, `Agent exited with code ${exitCode} (retry exhausted). ${stderr.slice(0, 500)}`);
+						this.handleTaskFailed(event.taskId, `Agent exited with code ${exitCode} (retry exhausted). ${stderr}`);
 					}
 					this.updateContext();
 				}
@@ -608,10 +684,9 @@ export class Scheduler {
 
 		// Extract output from last messages
 		const messages = store.loadMessages(this.squadId, taskId);
-		const lastAgentMessages = messages
-			.filter((m) => m.from === task.agent && (m.type === "text" || m.type === "done"))
-			.slice(-3);
-		const output = lastAgentMessages.map((m) => m.text).join("\n");
+		const agentMessages = messages
+			.filter((m) => m.from === task.agent && (m.type === "text" || m.type === "done"));
+		const output = agentMessages.map((m) => m.text).join("\n");
 
 		store.updateTaskStatus(this.squadId, taskId, "done", {
 			output: output || "Task completed",
@@ -795,7 +870,7 @@ export class Scheduler {
 					squadId: this.squadId,
 					taskId: task.id,
 					agentName: task.agent,
-					message: `QA failed ${originalId} ${retryCount} times. Retry limit reached.\nLatest feedback:\n${feedback.slice(0, 500)}`,
+					message: `QA failed ${originalId} ${retryCount} times. Retry limit reached.\nLatest feedback:\n${feedback}`,
 				});
 				continue;
 			}
@@ -900,12 +975,11 @@ export class Scheduler {
 
 		// Try to extract lines containing "FAIL", "Error", "✗"
 		const failLines = output.split("\n")
-			.filter((line) => /fail|error|✗|✘|broken|bug/i.test(line))
-			.slice(0, 20);
+			.filter((line) => /fail|error|✗|✘|broken|bug/i.test(line));
 		if (failLines.length > 0) return failLines.join("\n");
 
-		// Fallback: last 500 chars
-		return output.slice(-500);
+		// Preserve the complete QA handoff when no structured failure section exists.
+		return output;
 	}
 
 	// =========================================================================
@@ -973,7 +1047,7 @@ export class Scheduler {
 				status: task.status,
 				agent: task.agent,
 				title: task.title,
-				...(task.output ? { output: task.output.slice(0, 500) } : {}),
+				...(task.output ? { output: task.output } : {}),
 				...(task.status === "blocked"
 					? {
 							blockedBy: task.depends.filter((d) => {
@@ -1015,7 +1089,7 @@ export class Scheduler {
 					action:
 						msg.type === "tool"
 							? `→ ${msg.name} ${msg.args?.path || msg.args?.command || ""}`.trim()
-							: msg.text.slice(0, 80),
+							: msg.text,
 				});
 			}
 		}
@@ -1073,10 +1147,53 @@ export class Scheduler {
 		this.updateContext();
 	}
 
-	/** Resume a suspended task */
+	/** Resume a suspended/failed task. Reconciles so a failed squad heals too. */
 	async resumeTask(taskId: string): Promise<void> {
-		store.updateTaskStatus(this.squadId, taskId, "pending");
-		await this.scheduleReadyTasks();
+		store.updateTaskStatus(this.squadId, taskId, "pending", { error: null });
+		await this.reconcile();
+	}
+
+	/**
+	 * Mark a task done through the normal completion flow (admin/recovery path).
+	 * Unlike editing the store directly, this fires auto-unblock and scheduling,
+	 * so dependents transition pending → running. Skips the QA rework check —
+	 * a human/main agent marking a task done is an explicit override.
+	 */
+	async completeTask(taskId: string, output?: string): Promise<void> {
+		const task = store.loadTask(this.squadId, taskId);
+		if (!task) throw new Error(`Task not found: ${taskId}`);
+		if (task.status === "done") return;
+
+		if (this.pool.isRunning(taskId)) {
+			await this.pool.kill(taskId);
+		}
+
+		store.updateTaskStatus(this.squadId, taskId, "done", {
+			output: output ?? task.output ?? "Marked done (recovered/admin)",
+			error: null,
+			completed: store.now(),
+		});
+		store.appendMessage(this.squadId, taskId, {
+			ts: store.now(),
+			from: "system",
+			type: "done",
+			text: "Task marked done (recovered/admin)",
+		});
+		this.emit({
+			type: "task_completed",
+			squadId: this.squadId,
+			taskId,
+			agentName: task.agent,
+			message: output ?? "",
+		});
+
+		this.autoUnblock(taskId);
+		await this.reconcile();
+
+		const freshTasks = store.loadAllTasks(this.squadId);
+		const freshSquad = store.loadSquad(this.squadId);
+		if (freshSquad) this.checkSquadCompletion(freshTasks, freshSquad);
+		this.updateContext();
 	}
 
 	/** Cancel a task */

package/src/store.ts

@@ -269,9 +269,11 @@ export function listSquads(): string[] {
 }
 
 export function findActiveSquads(): Squad[] {
+	// Includes "failed": failure is recoverable (resume resets failed tasks), so
+	// failed squads must stay discoverable. All callers filter by status.
 	return listSquads()
 		.map((id) => loadSquad(id))
-		.filter((s): s is Squad => s !== null && (s.status === "running" || s.status === "paused"));
+		.filter((s): s is Squad => s !== null && (s.status === "running" || s.status === "paused" || s.status === "failed"));
 }
 
 /** List squads filtered by project cwd. If no cwd, returns all. */

package/src/supervisor.ts

@@ -70,10 +70,9 @@ export async function analyzeStuckAgent(
 ): Promise<{ action: "retry" | "reassign" | "escalate"; reason: string; suggestion?: string }> {
 	const task = store.loadTask(squadId, taskId);
 	const messages = store.loadMessages(squadId, taskId);
-	const recentMessages = messages.slice(-10);
 
-	// Simple heuristic for now
-	const errorMessages = recentMessages.filter((m) => m.type === "error");
+	// Simple heuristic for now — inspect the complete task history.
+	const errorMessages = messages.filter((m) => m.type === "error");
 	if (errorMessages.length >= 3) {
 		return {
 			action: "escalate",
@@ -128,7 +127,7 @@ export async function analyzeBlockRequest(
 		return {
 			action: "create_subtask",
 			subtask: {
-				title: `Support: ${blockReason.slice(0, 60)}`,
+				title: `Support: ${blockReason}`,
 				agent: "fullstack",
 				description: `Created from block request by ${agentName} on task ${taskId}: ${blockReason}`,
 			},

package/src/types.ts

@@ -223,7 +223,7 @@ export interface AgentActivity {
 	modifiedFiles: Set<string>;
 }
 
-export type HealthStatus = "healthy" | "idle_warning" | "stuck" | "looping" | "exceeded_ceiling";
+export type HealthStatus = "healthy" | "idle_warning" | "stuck" | "looping" | "long_running";
 
 // ============================================================================
 // Supervisor