pi-squad 0.1.0 → 0.5.0

package/src/panel/task-list.ts

@@ -3,6 +3,7 @@
  */
 
 import type { Theme } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth } from "@mariozechner/pi-tui";
 import type { Task, TaskStatus } from "../types.js";
 import type { Scheduler } from "../scheduler.js";
 import * as store from "../store.js";
@@ -80,29 +81,33 @@ export class TaskListView {
 			return this.padToHeight(lines, maxLines);
 		}
 
-		// Render task list
-		const taskLines = this.renderTaskTree(tasks, selectedIndex, width);
-
-		// Scroll window
-		const scrollStart = Math.max(0, Math.min(selectedIndex - Math.floor(maxLines / 2), taskLines.length - maxLines + 4));
-		const visibleTasks = taskLines.slice(scrollStart, scrollStart + maxLines - 4);
-		lines.push(...visibleTasks);
+		// Build bottom sections first so we know how much space they need
+		const bottomLines: string[] = [];
+		bottomLines.push("");
+		bottomLines.push(truncateToWidth(th.fg("border", " " + "─".repeat(width - 2)), width, ""));
 
-		// Separator
-		lines.push("");
-		lines.push(th.fg("border", " " + "─".repeat(width - 2)));
-
-		// Live activity for selected or first running task
 		const runningTask = tasks.find((t) => t.status === "in_progress");
 		if (runningTask) {
-			lines.push(...this.renderLiveActivity(runningTask, width, scheduler));
+			bottomLines.push(...this.renderLiveActivity(runningTask, width, scheduler));
 		}
 
-		// Summary line
-		lines.push("");
-		lines.push(this.renderSummary(tasks, width));
+		bottomLines.push("");
+		bottomLines.push(this.renderSummary(tasks, width));
+
+		// Task list gets remaining space
+		const taskLines = this.renderTaskTree(tasks, selectedIndex, width);
+		const taskSpace = Math.max(3, maxLines - bottomLines.length);
+		const scrollStart = Math.max(0, Math.min(selectedIndex - Math.floor(taskSpace / 2), taskLines.length - taskSpace));
+		const visibleTasks = taskLines.slice(scrollStart, scrollStart + taskSpace);
+
+		// Pad task area to exact size so bottom sticks
+		while (visibleTasks.length < taskSpace) visibleTasks.push("");
+		lines.push(...visibleTasks);
 
-		return this.padToHeight(lines, maxLines);
+		// Append bottom (always at the same position)
+		lines.push(...bottomLines);
+
+		return lines.slice(0, maxLines);
 	}
 
 	// =========================================================================
@@ -150,7 +155,7 @@ export class TaskListView {
 			}
 
 			const line = ` ${cursor} ${icon} ${taskName} ${agentTag}${labelStr}${timeStr}`;
-			lines.push(line);
+			lines.push(truncateToWidth(line, width, "…"));
 
 			// Show blocked-by info
 			if (task.status === "blocked" && task.depends.length > 0) {
@@ -160,16 +165,17 @@ export class TaskListView {
 						return dep && dep.status !== "done";
 					});
 				if (blockers.length > 0) {
-					lines.push(
-						`     ${th.fg("dim", "└ waiting on: " + blockers.join(", "))}`,
-					);
+					lines.push(truncateToWidth(
+						`     ${th.fg("dim", "└ waiting on: " + blockers.join(", "))}`, width, "…",
+					));
 				}
 			}
 
 			// Show error for failed tasks
 			if (task.status === "failed" && task.error) {
-				const errorPreview = task.error.slice(0, width - 10);
-				lines.push(`     ${th.fg("error", "└ " + errorPreview)}`);
+				lines.push(truncateToWidth(
+					`     ${th.fg("error", "└ " + task.error)}`, width, "…",
+				));
 			}
 		}
 
@@ -184,7 +190,10 @@ export class TaskListView {
 		const th = this.theme;
 		const lines: string[] = [];
 
-		lines.push(th.fg("border", ` ── ${task.id} (live) `) + th.fg("border", "─".repeat(Math.max(0, width - task.id.length - 12))));
+		lines.push(truncateToWidth(
+			th.fg("border", ` ── ${task.id} (live) `) + th.fg("border", "─".repeat(Math.max(0, width - task.id.length - 12))),
+			width, "",
+		));
 
 		// Get recent messages for this task
 		const messages = store.loadMessages(this.squadId, task.id);
@@ -193,12 +202,13 @@ export class TaskListView {
 		for (const msg of recent) {
 			if (msg.type === "tool") {
 				const toolStr = `→ ${msg.name || msg.text}`;
-				const argsStr = msg.args?.path || msg.args?.command || "";
+				const rawArgs = (msg.args?.path || msg.args?.command || "").toString();
+				const argsStr = rawArgs.split("\n")[0]; // first line only
 				const preview = argsStr ? `${toolStr} ${argsStr}` : toolStr;
-				lines.push(` ${th.fg("muted", preview.slice(0, width - 2))}`);
+				lines.push(truncateToWidth(` ${th.fg("muted", preview)}`, width, "…"));
 			} else if (msg.type === "text" && msg.from !== "system") {
-				const preview = msg.text.split("\n")[0].slice(0, width - 4);
-				lines.push(` ${th.fg("dim", `"${preview}"`)}`);
+				const preview = msg.text.split("\n")[0];
+				lines.push(truncateToWidth(` ${th.fg("dim", `"${preview}"`)}`, width, "…"));
 			}
 		}
 

package/src/planner.ts

@@ -31,7 +31,7 @@ export async function runPlanner(options: PlannerOptions): Promise<PlannerOutput
 	const { goal, cwd, model } = options;
 
 	const plannerDef = loadAgentDef("planner", cwd);
-	const allAgents = loadAllAgentDefs(cwd).filter((a) => a.name !== "planner");
+	const allAgents = loadAllAgentDefs(cwd).filter((a) => a.name !== "planner" && !a.disabled);
 
 	const agentList = allAgents
 		.map((a) => `- **${a.name}** (${a.role}): ${a.description} [tags: ${a.tags.join(", ")}]`)

package/src/protocol.ts

@@ -234,6 +234,42 @@ ${task.description || "(no additional description)"}
 `;
 }
 
+// ============================================================================
+// Rework Context
+// ============================================================================
+
+function buildReworkContext(task: Task, squadId: string): string {
+	if (!task.retryOf) return "";
+
+	const originalTask = loadAllTasks(squadId).find((t) => t.id === task.retryOf);
+
+	const lines: string[] = [
+		"# ⚠️ REWORK — Fix Issues From Previous Attempt\n",
+		`This is attempt #${task.retryCount || 1} to fix issues in **${task.retryOf}**.\n`,
+	];
+
+	if (originalTask?.output) {
+		lines.push("## What Was Built (Previous Attempt)");
+		lines.push(originalTask.output.slice(0, 2000));
+		lines.push("");
+	}
+
+	if (task.qaFeedback) {
+		lines.push("## QA Feedback — What Needs Fixing");
+		lines.push(task.qaFeedback);
+		lines.push("");
+	}
+
+	lines.push("## Instructions");
+	lines.push("- Read the QA feedback carefully — fix ONLY the reported issues");
+	lines.push("- Do NOT rewrite everything from scratch");
+	lines.push("- Make targeted, minimal fixes");
+	lines.push("- Re-run the failing tests to verify your fixes");
+	lines.push("- Include test output as evidence in your completion message\n");
+
+	return lines.join("\n");
+}
+
 // ============================================================================
 // Full Prompt Assembly
 // ============================================================================
@@ -255,6 +291,7 @@ export function buildAgentSystemPrompt(options: ProtocolBuildOptions): string {
 		buildSquadProtocol(task.agent, agentDef, squad),
 		buildAgentIdentity(agentDef),
 		buildTaskSection(task),
+		buildReworkContext(task, squadId),
 		buildChainContext(task, allTasks, squadId),
 		buildSiblingAwareness(task, allTasks, modifiedFiles),
 		buildKnowledgeSection(squadId),

package/src/scheduler.ts

@@ -26,6 +26,7 @@ export type SchedulerEventType =
 	| "task_failed"
 	| "task_blocked"
 	| "task_unblocked"
+	| "task_rework"
 	| "squad_completed"
 	| "squad_failed"
 	| "escalation"
@@ -54,6 +55,8 @@ export class Scheduler {
 	private listeners: SchedulerEventListener[] = [];
 	private skillPaths: string[] = [];
 	private running = false;
+	/** Track spawn retries to allow one retry per task */
+	private spawnRetries = new Set<string>();
 
 	/** Get the project cwd for this squad (from squad.json) */
 	getProjectCwd(): string | undefined {
@@ -210,6 +213,9 @@ export class Scheduler {
 				await this.spawnAgentForTask(task, squad);
 			} catch (error) {
 				console.error(`[squad-scheduler] Failed to spawn ${task.id}: ${(error as Error).message}`);
+				// MUST fail the task — otherwise it stays in_progress forever
+				// with no process (zombie state)
+				this.handleTaskFailed(task.id, `Spawn failed: ${(error as Error).message}`);
 			}
 		}
 
@@ -236,6 +242,11 @@ export class Scheduler {
 			return;
 		}
 
+		if (agentDef.disabled) {
+			this.handleTaskFailed(task.id, `Agent '${task.agent}' is disabled. Enable it with /squad agents or edit ${task.agent}.json`);
+			return;
+		}
+
 		// Apply squad-level model override
 		const squadAgentEntry = squad.agents[task.agent];
 		if (squadAgentEntry?.model) {
@@ -375,8 +386,29 @@ export class Scheduler {
 				if (exitCode === 0 || hadMeaningfulWork) {
 					this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
 				} else {
-					const stderr = event.data?.stderr || "";
-					this.handleTaskFailed(event.taskId, `Agent exited with code ${exitCode}. ${stderr.slice(0, 500)}`);
+					// Agent died with no work done — retry once before failing.
+					// Transient failures (resource pressure, startup race) are common
+					// when multiple agents spawn simultaneously.
+					const retryKey = `spawn-retry:${event.taskId}`;
+					if (!this.spawnRetries.has(retryKey)) {
+						this.spawnRetries.add(retryKey);
+						const stderr = event.data?.stderr || "";
+						console.error(`[squad-scheduler] Agent ${event.agentName} died instantly (code ${exitCode}). Retrying in 2s... stderr: ${stderr.slice(0, 200)}`);
+						store.updateTaskStatus(this.squadId, event.taskId, "pending");
+						store.appendMessage(this.squadId, event.taskId, {
+							ts: store.now(),
+							from: "system",
+							type: "status",
+							text: `Agent crashed on startup (code ${exitCode}). Retrying...`,
+						});
+						// Delay retry to let resources settle
+						setTimeout(() => {
+							if (this.running) this.scheduleReadyTasks();
+						}, 2000);
+					} else {
+						const stderr = event.data?.stderr || "";
+						this.handleTaskFailed(event.taskId, `Agent exited with code ${exitCode} (retry exhausted). ${stderr.slice(0, 500)}`);
+					}
 					this.updateContext();
 				}
 				// Skip the updateContext() below — handled in the branches above
@@ -432,9 +464,31 @@ export class Scheduler {
 			message: output,
 		});
 
-		// Auto-unblock dependents
-		console.error(`[squad-scheduler] handleTaskCompleted: ${taskId} done, auto-unblocking dependents`);
-		this.autoUnblock(taskId);
+		// Check for QA rework: if this is a QA/test task and it found failures,
+		// create a rework task for the original agent instead of proceeding
+		const reworkCreated = this.checkForRework(task, output);
+
+		if (!reworkCreated) {
+			// Normal flow: auto-unblock dependents
+			console.error(`[squad-scheduler] handleTaskCompleted: ${taskId} done, auto-unblocking dependents`);
+			this.autoUnblock(taskId);
+
+			// If this is a passing retest, also unblock dependents of the ORIGINAL
+			// QA task. When qa-auth failed, its dependents weren't unblocked.
+			// Now that the retest passes, those dependents should proceed.
+			if (task.retryOf) {
+				// Walk up the retry chain to find the root task
+				let rootId = task.retryOf;
+				const allTasks = store.loadAllTasks(this.squadId);
+				let root = allTasks.find((t) => t.id === rootId);
+				while (root?.retryOf) {
+					rootId = root.retryOf;
+					root = allTasks.find((t) => t.id === rootId);
+				}
+				console.error(`[squad-scheduler] Retest passed — also unblocking dependents of original: ${rootId}`);
+				this.autoUnblock(rootId);
+			}
+		}
 
 		// Schedule next ready tasks (may spawn new agents)
 		console.error(`[squad-scheduler] handleTaskCompleted: scheduling next ready tasks`);
@@ -527,6 +581,163 @@ export class Scheduler {
 		}
 	}
 
+	// =========================================================================
+	// QA Rework Loop
+	// =========================================================================
+
+	/**
+	 * Check if a completed task is a QA task that found failures.
+	 * If so, create a rework task for the original agent and a retest task for QA.
+	 * Returns true if rework was created (caller should NOT auto-unblock dependents).
+	 */
+	private checkForRework(task: Task, output: string): boolean {
+		// Only trigger rework for QA/test agent tasks
+		const qaAgents = ["qa", "tester", "security"];
+		if (!qaAgents.includes(task.agent)) return false;
+
+		// Parse verdict from output
+		const verdict = this.parseQaVerdict(output);
+		if (verdict === "pass") return false;
+
+		// Find the implementation task(s) this QA task was testing
+		const allTasks = store.loadAllTasks(this.squadId);
+		const implDeps = task.depends
+			.map((depId) => allTasks.find((t) => t.id === depId))
+			.filter((t): t is Task => t !== null && !qaAgents.includes(t.agent));
+
+		if (implDeps.length === 0) return false;
+
+		const squad = store.loadSquad(this.squadId);
+		if (!squad) return false;
+
+		// Extract the failure details for feedback
+		const feedback = this.extractQaFeedback(output);
+
+		let createdAny = false;
+		for (const implTask of implDeps) {
+			// Check retry limit
+			const retryCount = store.getRetryCount(this.squadId, implTask.retryOf || implTask.id);
+			const originalId = implTask.retryOf || implTask.id;
+
+			if (retryCount >= squad.config.maxRetries) {
+				console.error(`[squad-scheduler] Retry limit reached for ${originalId} (${retryCount}/${squad.config.maxRetries})`);
+				this.emit({
+					type: "escalation",
+					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)}`,
+				});
+				continue;
+			}
+
+			const fixN = retryCount + 1;
+
+			// Create rework task for the original agent
+			const reworkId = `${originalId}-fix-${fixN}`;
+			const reworkTask: Task = {
+				id: reworkId,
+				title: `Fix: ${implTask.title} (attempt ${fixN})`,
+				description: `QA found issues in ${implTask.id}. Fix the problems described below.\n\n## QA Feedback\n${feedback}`,
+				agent: implTask.agent,
+				status: "pending",
+				depends: [],
+				created: store.now(),
+				started: null,
+				completed: null,
+				output: null,
+				error: null,
+				usage: { inputTokens: 0, outputTokens: 0, cost: 0, turns: 0 },
+				retryOf: originalId,
+				retryCount: fixN,
+				qaFeedback: feedback,
+			};
+			store.createTask(this.squadId, reworkTask);
+
+			// Create retest task for QA
+			const retestId = `${task.id}-retest-${fixN}`;
+			const retestTask: Task = {
+				id: retestId,
+				title: `Re-test: ${implTask.title} (after fix ${fixN})`,
+				description: `Re-test ${implTask.id} after rework. Verify the issues from the previous QA round are fixed.\n\nPrevious issues:\n${feedback}`,
+				agent: task.agent,
+				status: "blocked",
+				depends: [reworkId],
+				created: store.now(),
+				started: null,
+				completed: null,
+				output: null,
+				error: null,
+				usage: { inputTokens: 0, outputTokens: 0, cost: 0, turns: 0 },
+				retryOf: task.id,
+				retryCount: fixN,
+			};
+			store.createTask(this.squadId, retestTask);
+
+			store.appendMessage(this.squadId, task.id, {
+				ts: store.now(),
+				from: "system",
+				type: "status",
+				text: `QA failed — creating rework task ${reworkId} for ${implTask.agent} and retest ${retestId}`,
+			});
+
+			this.emit({
+				type: "task_rework",
+				squadId: this.squadId,
+				taskId: reworkId,
+				agentName: implTask.agent,
+				message: `QA found issues in ${implTask.id}. Rework attempt ${fixN}.`,
+			});
+
+			console.error(`[squad-scheduler] Rework: ${reworkId} (${implTask.agent}) + retest ${retestId} (${task.agent})`);
+			createdAny = true;
+		}
+
+		return createdAny;
+	}
+
+	/** Parse QA verdict from task output */
+	private parseQaVerdict(output: string): "pass" | "fail" | "pass_with_issues" {
+		const lower = output.toLowerCase();
+
+		// Look for structured verdict line: "## Verdict: FAIL" or "Verdict: PASS"
+		const verdictMatch = output.match(/##?\s*Verdict:\s*(PASS WITH ISSUES|PASS|FAIL)/i);
+		if (verdictMatch) {
+			const v = verdictMatch[1].toUpperCase();
+			if (v === "FAIL") return "fail";
+			if (v === "PASS WITH ISSUES") return "pass_with_issues";
+			return "pass";
+		}
+
+		// Fallback: look for common failure patterns
+		if (
+			lower.includes("verdict: fail") ||
+			lower.includes("status: fail") ||
+			/\d+\s+(?:tests?\s+)?fail(?:ed|ing|ure)/i.test(output) ||
+			(lower.includes("fail") && lower.includes("test") && !lower.includes("0 fail"))
+		) {
+			return "fail";
+		}
+
+		return "pass";
+	}
+
+	/** Extract actionable feedback from QA output */
+	private extractQaFeedback(output: string): string {
+		// Try to extract "## Issues" or "## Failures" section
+		const issuesMatch = output.match(/##\s*(?:Issues|Failures|Bugs|Problems|Failed Tests)[\s\S]*?(?=\n##\s|$)/i);
+		if (issuesMatch) return issuesMatch[0].trim();
+
+		// Try to extract lines containing "FAIL", "Error", "✗"
+		const failLines = output.split("\n")
+			.filter((line) => /fail|error|✗|✘|broken|bug/i.test(line))
+			.slice(0, 20);
+		if (failLines.length > 0) return failLines.join("\n");
+
+		// Fallback: last 500 chars
+		return output.slice(-500);
+	}
+
 	// =========================================================================
 	// Squad Completion
 	// =========================================================================

package/src/skills/supervisor/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: squad-supervisor
+description: Manage multi-agent squads — monitor progress, respond to escalations, relay human instructions, and summarize results. Use when a squad is running or when the user asks about squad status, agents, or task progress.
+---
+
+# Squad Supervisor
+
+You are the supervisor of multi-agent squads. Agents work on decomposed tasks in the background while you coordinate with the user.
+
+## Your Role
+
+You are the bridge between the human and the squad. You:
+- Start squads for complex tasks (use the `squad` tool)
+- Monitor progress and relay status to the user
+- Handle escalations when agents get stuck
+- Send instructions to agents on behalf of the user
+- Summarize results when the squad completes
+
+## When to Use Squad
+
+**Use squad** when the user's request involves:
+- 2+ concerns (backend + frontend, code + tests, implementation + docs)
+- Work that benefits from parallel execution
+- Tasks that would overflow a single agent's context
+- Projects needing specialist knowledge (security audit + implementation)
+
+**Don't use squad** for:
+- Quick single-file edits
+- Simple questions or explanations
+- Tasks a single agent can finish in a few minutes
+
+## Monitoring a Running Squad
+
+### Passive monitoring (automatic)
+The squad status is injected into your context via `<squad_status>` before each response.
+Read it to stay aware of progress without needing to call tools.
+
+### Active monitoring (on-demand)
+Use `squad_status` when:
+- The user asks "how's the squad doing?"
+- You need detailed info not in the status block
+- You want to check a specific squad by ID
+
+### What to tell the user
+- Summarize in plain language: "2 of 4 tasks done, tests are running, docs waiting on API"
+- Highlight blockers: "The QA agent is stuck — it needs the API endpoint list"
+- Report costs when relevant: "Squad is at $0.45 so far"
+
+## Handling Escalations
+
+When you receive `[squad] Agent needs attention`:
+1. **Read the message** — understand what the agent needs
+2. **Check if you can answer** — often it's a decision only the human can make
+3. **If you can answer**: use `squad_message` to reply directly
+4. **If you can't**: ask the user, then relay their answer via `squad_message`
+
+Common escalation patterns:
+- **"Which approach should I use?"** → Ask the user for preference, relay via `squad_message`
+- **"I need info from another agent"** → Check if that agent is done, relay their output
+- **"I'm blocked by a failing test"** → Check the error, suggest a fix via `squad_message`
+- **"The dependency output is unclear"** → Read the dep's messages, clarify for the agent
+
+## Sending Messages to Agents
+
+Use `squad_message` with:
+- `taskId` — target a specific task
+- `agent` — target whichever task an agent is working on
+- `message` — your instruction or answer
+
+Keep messages **specific and actionable**:
+- Good: "Use RS256 for JWT signing. The secret is in env var JWT_SECRET."
+- Bad: "Figure out the auth approach."
+
+## 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
+- **`pause`** / **`resume`**: Stop/restart the entire squad
+- **`cancel`**: Abort everything (user changed their mind)
+
+## After Squad Completes
+
+When you receive `[squad] Squad completed`:
+1. Read the summary of what each agent produced
+2. Summarize for the user in plain language
+3. Highlight any issues or partial results
+4. Suggest next steps if applicable
+
+Example:
+> Squad finished all 4 tasks:
+> - API endpoints created at `/api/auth` and `/api/users`
+> - JWT middleware with RS256 validation
+> - 12 tests passing
+> - README updated with API docs
+>
+> Total cost: $1.23. Want me to run the full test suite or deploy?
+
+## Decision Framework
+
+| Situation | Action |
+|---|---|
+| User asks complex task | Start squad with `squad` tool |
+| User asks "what's happening?" | Read `<squad_status>`, summarize |
+| Agent escalates | Triage → answer or ask user |
+| User says "tell the backend agent to..." | `squad_message` to that agent |
+| User says "add a task for..." | `squad_modify` with `add_task` |
+| User says "cancel/stop" | `squad_modify` with `cancel` |
+| Squad completes | Summarize results, suggest next steps |
+| Squad fails | Report what failed, offer options (retry, modify, cancel) |

package/src/skills/verification/SKILL.md

@@ -62,3 +62,35 @@ $ npm test -- test/auth.test.ts
 - Include relevant code snippets as evidence
 - State confidence level on uncertain findings
 - List what you checked AND what you didn't check
+
+## QA Verdict Format (REQUIRED for test/QA tasks)
+
+Your final message MUST end with a structured verdict that automation can parse:
+
+### If everything passes:
+```
+## Verdict: PASS
+All N tests passing. No issues found.
+```
+
+### If tests fail:
+```
+## Verdict: FAIL
+
+## Issues
+1. **[file:line]** Description of the failure
+   - Expected: X
+   - Got: Y
+2. **[file:line]** Another issue
+   - Steps to reproduce: ...
+```
+
+### If tests pass but with concerns:
+```
+## Verdict: PASS WITH ISSUES
+
+## Minor Issues
+1. Description of concern (non-blocking)
+```
+
+The verdict line (`## Verdict: PASS/FAIL/PASS WITH ISSUES`) is **machine-parsed** by the squad system. When you output `FAIL`, the squad automatically creates a rework task for the original agent with your feedback, then re-tests after the fix. Make your Issues section **specific and actionable** — the fixing agent only sees your feedback.

package/src/store.ts

@@ -136,7 +136,18 @@ function readJsonl<T>(filePath: string): T[] {
 	try {
 		const content = fs.readFileSync(filePath, "utf-8").trim();
 		if (!content) return [];
-		return content.split("\n").map((line) => JSON.parse(line) as T);
+		// Parse each line individually — skip partial/corrupt lines
+		// (can happen when reading while an agent is mid-write)
+		const results: T[] = [];
+		for (const line of content.split("\n")) {
+			if (!line.trim()) continue;
+			try {
+				results.push(JSON.parse(line) as T);
+			} catch {
+				// Skip corrupt/partial line — likely mid-write
+			}
+		}
+		return results;
 	} catch {
 		return [];
 	}
@@ -394,6 +405,23 @@ export function loadAllKnowledge(squadId: string): KnowledgeEntry[] {
 	].sort((a, b) => a.ts.localeCompare(b.ts));
 }
 
+// ============================================================================
+// Rework Helpers
+// ============================================================================
+
+/** Find all retry tasks for a given original task ID */
+export function findRetries(squadId: string, originalTaskId: string): Task[] {
+	return loadAllTasks(squadId).filter((t) => t.retryOf === originalTaskId);
+}
+
+/** Get the retry count for a task chain (original + all retries) */
+export function getRetryCount(squadId: string, taskId: string): number {
+	const task = loadTask(squadId, taskId);
+	if (!task) return 0;
+	if (task.retryCount !== undefined) return task.retryCount;
+	return findRetries(squadId, taskId).length;
+}
+
 // ============================================================================
 // Memory (cross-squad)
 // ============================================================================

package/src/types.ts

@@ -17,6 +17,8 @@ export interface AgentDef {
 	tags: string[];
 	/** System prompt injected via --append-system-prompt */
 	prompt: string;
+	/** When true, agent is hidden from the planner and cannot be assigned tasks */
+	disabled?: boolean;
 }
 
 /** Agent entry in squad.json — just overrides, references an AgentDef by key */
@@ -34,12 +36,15 @@ export interface SquadConfig {
 	maxConcurrency: number;
 	autoUnblock: boolean;
 	reviewOnComplete: boolean;
+	/** Max rework attempts when QA fails a task (0 = no rework, just fail) */
+	maxRetries: number;
 }
 
 export const DEFAULT_SQUAD_CONFIG: SquadConfig = {
 	maxConcurrency: 2,
 	autoUnblock: true,
 	reviewOnComplete: false,
+	maxRetries: 2,
 };
 
 export interface Squad {
@@ -79,6 +84,12 @@ export interface Task {
 	output: string | null;
 	error: string | null;
 	usage: TaskUsage;
+	/** If this is a rework task, the original task ID it's fixing */
+	retryOf?: string;
+	/** How many times this task chain has been retried */
+	retryCount?: number;
+	/** QA feedback that triggered this rework */
+	qaFeedback?: string;
 }
 
 // ============================================================================