pi-squad 0.7.2 → 0.15.0

package/src/scheduler.ts

@@ -9,6 +9,8 @@
  * - Detects squad completion
  */
 
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { AgentDef, Squad, SquadConfig, Task, TaskMessage, TaskStatus } from "./types.js";
 import { AgentPool, type AgentEvent } from "./agent-pool.js";
 import { Monitor } from "./monitor.js";
@@ -16,6 +18,7 @@ import { Router } from "./router.js";
 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";
 
 // ============================================================================
 // Types
@@ -44,6 +47,16 @@ export interface SchedulerEvent {
 
 export type SchedulerEventListener = (event: SchedulerEvent) => void;
 
+/** Host-session capabilities passed in by the extension (index.ts) */
+export interface SchedulerSpawnContext {
+	/** Resolve a model string (or null = default model) to its context window in tokens */
+	resolveContextWindow?: (model: string | null) => number | undefined;
+	/** Resolve the squad default model/thinking policy (settings.json + main session state) */
+	getDefaultModelThinking?: () => { model?: string; thinking?: string };
+	/** Consult the advisor model with a curated digest. Returns advice text, or null when disabled/unavailable. */
+	consultAdvisor?: (input: AdvisorConsultInput) => Promise<string | null>;
+}
+
 // ============================================================================
 // Scheduler
 // ============================================================================
@@ -55,18 +68,22 @@ export class Scheduler {
 	private router: Router;
 	private listeners: SchedulerEventListener[] = [];
 	private skillPaths: string[] = [];
+	private spawnContext?: SchedulerSpawnContext;
 	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 {
 		return store.loadSquad(this.squadId)?.cwd;
 	}
 
-	constructor(squadId: string, skillPaths: string[]) {
+	constructor(squadId: string, skillPaths: string[], spawnContext?: SchedulerSpawnContext) {
 		this.squadId = squadId;
 		this.skillPaths = skillPaths;
+		this.spawnContext = spawnContext;
 		this.pool = new AgentPool();
 		this.monitor = new Monitor(this.pool, squadId);
 		this.router = new Router(this.pool, squadId);
@@ -78,15 +95,28 @@ 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 === "escalate") {
+			} 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) => {
+					if (rescued) return;
+					this.emit({
+						type: "escalation",
+						squadId: this.squadId,
+						taskId: action.taskId,
+						agentName: action.agentName,
+						message: action.reason,
+					});
+				});
 			}
 		});
 
@@ -140,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);
@@ -159,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);
 		}
@@ -177,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
 	// =========================================================================
@@ -248,11 +342,25 @@ export class Scheduler {
 			return;
 		}
 
-		// Apply squad-level model override
+		// Apply squad-level model/thinking overrides
 		const squadAgentEntry = squad.agents[task.agent];
 		if (squadAgentEntry?.model) {
 			agentDef.model = squadAgentEntry.model;
 		}
+		if (squadAgentEntry?.thinking) {
+			agentDef.thinking = squadAgentEntry.thinking;
+		}
+
+		// Apply squad defaults for anything still unset (policy resolved by the
+		// extension host: "main" = main session's model/thinking, "pi-default" =
+		// leave unset, or an explicit value from ~/.pi/squad/settings.json)
+		const defaults = this.spawnContext?.getDefaultModelThinking?.();
+		if (!agentDef.model && defaults?.model) {
+			agentDef.model = defaults.model;
+		}
+		if (!agentDef.thinking && defaults?.thinking) {
+			agentDef.thinking = defaults.thinking;
+		}
 
 		// Build modified files map from all running agents
 		const modifiedFiles: Record<string, string[]> = {};
@@ -285,6 +393,9 @@ export class Scheduler {
 			agentName: task.agent,
 		});
 
+		// Decide whether to fork the main session for context inheritance
+		const forkSessionFile = this.resolveForkSession(task, squad, agentDef);
+
 		try {
 			await this.pool.spawn({
 				taskId: task.id,
@@ -299,6 +410,14 @@ export class Scheduler {
 				},
 				cwd: squad.cwd,
 				skillPaths: this.skillPaths,
+				...(forkSessionFile
+					? {
+							forkSession: {
+								file: forkSessionFile,
+								sessionDir: path.join(store.getSquadDir(this.squadId), "sessions"),
+							},
+						}
+					: {}),
 			});
 		} catch (error) {
 			this.handleTaskFailed(task.id, (error as Error).message);
@@ -307,6 +426,123 @@ export class Scheduler {
 		this.updateContext();
 	}
 
+	/** Advisor consultations per task (advisor-first escalation) */
+	private advisorAttempts = new Map<string, number>();
+
+	/**
+	 * Consult the advisor for a stuck agent and steer it with the advice.
+	 * Returns true when the agent was steered (escalation suppressed).
+	 * Returns false when the advisor is disabled, exhausted, unavailable,
+	 * failed, or explicitly said the problem needs human input.
+	 */
+	private async tryAdvisorRescue(taskId: string, agentName: string | undefined, reason: string): Promise<boolean> {
+		try {
+			const consult = this.spawnContext?.consultAdvisor;
+			if (!consult) return false;
+
+			const settings = store.loadSquadSettings();
+			if (!settings.advisor.enabled) return false;
+
+			const attempts = this.advisorAttempts.get(taskId) || 0;
+			if (attempts >= settings.advisor.maxCallsPerTask) {
+				debug("squad-advisor", `${taskId}: advisor exhausted (${attempts}/${settings.advisor.maxCallsPerTask}), escalating`);
+				return false;
+			}
+			if (!this.pool.isRunning(taskId)) return false;
+
+			const task = store.loadTask(this.squadId, taskId);
+			const squad = store.loadSquad(this.squadId);
+			if (!task || !squad) return false;
+			const agentDef = store.loadAgentDef(task.agent, squad.cwd);
+			const activity = this.pool.getActivity(taskId);
+
+			this.advisorAttempts.set(taskId, attempts + 1);
+
+			const input: AdvisorConsultInput = {
+				taskId,
+				taskTitle: task.title,
+				taskDescription: task.description,
+				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 })),
+				recentToolCalls: activity ? [...activity.recentToolCalls] : [],
+				turnCount: activity?.turnCount || 0,
+				elapsedMinutes: activity ? (Date.now() - activity.startedAt) / 60000 : 0,
+			};
+
+			const advice = await consult(input);
+			if (!advice) return false;
+
+			store.appendMessage(this.squadId, taskId, {
+				ts: store.now(),
+				from: "advisor",
+				type: "message",
+				text: advice,
+			});
+
+			// Advisor says a human decision is required — escalate with the advice attached
+			if (adviceNeedsHuman(advice)) {
+				this.emit({
+					type: "escalation",
+					squadId: this.squadId,
+					taskId,
+					agentName,
+					message: `${reason}\n\nAdvisor assessment:\n${advice.slice(0, 800)}`,
+				});
+				return true; // escalation already emitted with richer context
+			}
+
+			const delivered = await this.pool.steer(taskId, formatAdvisorSteerMessage(advice, reason));
+			debug("squad-advisor", `${taskId}: advisor steered agent (attempt ${attempts + 1}, delivered=${delivered})`);
+			return delivered;
+		} catch (error) {
+			logError("squad-advisor", `rescue failed for ${taskId}: ${(error as Error).message}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Decide whether this task's agent should be spawned as a fork of the main
+	 * pi session (context inheritance). Guards against blowing the child model's
+	 * context window: forks only when the estimated session tokens fit within
+	 * 50% of the agent model's context window.
+	 */
+	private resolveForkSession(task: Task, squad: Squad, agentDef: AgentDef): string | undefined {
+		if (!task.inheritContext) return undefined;
+
+		const skip = (reason: string): undefined => {
+			logError("squad-scheduler", `inheritContext skipped for ${task.id}: ${reason}`);
+			store.appendMessage(this.squadId, task.id, {
+				ts: store.now(),
+				from: "system",
+				type: "status",
+				text: `Context inheritance skipped: ${reason}. Agent starts with standard squad context only.`,
+			});
+			return undefined;
+		};
+
+		const sessionFile = squad.sessionFile;
+		if (!sessionFile) return skip("main session has no session file (ephemeral --no-session run)");
+		if (!fs.existsSync(sessionFile)) return skip(`session file not found: ${sessionFile}`);
+
+		// Rough token estimate: JSONL bytes / 4. Overestimates (JSON overhead), which is safe.
+		const estTokens = Math.ceil(fs.statSync(sessionFile).size / 4);
+
+		const window = this.spawnContext?.resolveContextWindow?.(agentDef.model ?? null);
+		if (!window) {
+			return skip(`cannot determine context window for model "${agentDef.model || "(default)"}"`);
+		}
+		if (estTokens > window * 0.5) {
+			return skip(
+				`estimated session context (~${Math.round(estTokens / 1000)}k tokens) exceeds 50% of ${agentDef.model || "default model"}'s ${Math.round(window / 1000)}k window — restate key context in the task description instead`,
+			);
+		}
+
+		debug("squad-scheduler", `inheritContext: forking ${sessionFile} for ${task.id} (~${Math.round(estTokens / 1000)}k tokens, window ${Math.round(window / 1000)}k)`);
+		return sessionFile;
+	}
+
 	// =========================================================================
 	// Event Handlers
 	// =========================================================================
@@ -599,7 +835,7 @@ export class Scheduler {
 	 */
 	private checkForRework(task: Task, output: string): boolean {
 		// Only trigger rework for QA/test agent tasks
-		const qaAgents = ["qa", "tester", "security"];
+		const qaAgents = ["qa", "tester", "security", "reviewer"];
 		if (!qaAgents.includes(task.agent)) return false;
 
 		// Parse verdict from output
@@ -610,7 +846,7 @@ export class Scheduler {
 		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));
+			.filter((t): t is Task => t !== undefined && !qaAgents.includes(t.agent));
 
 		if (implDeps.length === 0) return false;
 
@@ -649,6 +885,7 @@ export class Scheduler {
 				agent: implTask.agent,
 				status: "pending",
 				depends: [],
+				...(implTask.inheritContext ? { inheritContext: true } : {}),
 				created: store.now(),
 				started: null,
 				completed: null,
@@ -910,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/skills/squad-code-review/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: squad-code-review
+description: >
+  Code review methodology — two-pass review (correctness/scope, then
+  over-engineering), surgical-change discipline, complexity findings with
+  delete/stdlib/native/yagni/shrink tags, machine-parsed verdicts. Use when
+  reviewing diffs, implementations, or pull requests.
+version: 1.0.0
+---
+
+# Code Review
+
+Two passes, in order. Findings from pass 1 gate the verdict; pass 2 findings
+are usually non-blocking. Derived from the karpathy-guidelines and ponytail
+review disciplines.
+
+## Pass 1 — Correctness & Scope
+
+**Every changed line must trace to the task.**
+- Flag unrequested refactors, drive-by "improvements", formatting churn in
+  untouched code, and deleted code the task didn't ask to remove
+- Orphan check: did the change leave now-unused imports/variables/functions
+  it created? (Pre-existing dead code is a mention, not a finding)
+
+**Verify with evidence, not by reading.**
+- Run the task's Verify criterion yourself (tests, build, curl). Your review
+  is only as strong as the commands you ran
+- Reproduce at least one happy path and one failure path where practical
+- If you can't run something, say so explicitly — don't imply you did
+
+**Assumptions and interpretations.**
+- If the implementation silently picked one of several readings of the task,
+  name the choice and whether it matches the task's Goal/Boundaries
+- Check the task's Boundaries were respected (unchanged APIs, schemas, configs)
+
+**Error handling in the right places.**
+- Trust boundaries (user input, network, file I/O) must handle failure
+- Impossible-scenario handling is noise — flag it in pass 2 as yagni
+
+## Pass 2 — Complexity Hunt
+
+Climb the ladder for each addition; stop at the first rung that holds:
+need to exist? → already in codebase? → stdlib? → native platform? →
+installed dep? → one line? → minimum that works.
+
+One line per finding — location, what to cut, what replaces it:
+
+- `delete:` dead code, unused flexibility, speculative feature → nothing
+- `stdlib:` hand-rolled thing the standard library ships → name the function
+- `native:` dep/code doing what the platform does → name the feature
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller
+- `shrink:` same logic, fewer lines → show the shorter form
+
+Example: `api.ts:L88: yagni: RepositoryFactory with one product. Inline it until a second exists.`
+
+**Never flag as bloat**: trust-boundary validation, data-loss handling,
+security, accessibility, or a minimal test. Lean is not careless.
+
+If nothing to cut: `Lean already.` — don't invent findings to look thorough.
+
+## Verdict (machine-parsed — REQUIRED)
+
+End your final message with exactly:
+
+```
+## Verdict: PASS | FAIL | PASS WITH ISSUES
+
+## Issues
+1. **[file:line]** (Critical/High/Medium/Low) description
+   - Expected: X
+   - Got: Y
+   - Fix: specific change
+
+## Evidence
+[commands run + output]
+```
+
+- **FAIL**: pass-1 problems (correctness, scope violations, broken Verify).
+  Creates a rework task — the fixer only sees your Issues section
+- **PASS WITH ISSUES**: works and in-scope, but pass-2 cuts are worth making
+- **PASS**: correct, in scope, lean. Say what you verified
+- Severity: correctness/security → Critical/High; complexity → Medium/Low
+- Do not rename the sections — `## Issues` is extracted verbatim as fix feedback
+
+## You Don't Fix
+
+You report; the squad routes fixes to the original agent. Applying fixes
+yourself would bypass the rework loop and confuse file ownership. If a fix
+is truly one character, still report it — with the exact edit in the Fix line.

package/src/skills/squad-collaboration/SKILL.md

@@ -22,10 +22,14 @@ Bad: "@backend FYI I'm working on the frontend" (no question, wastes their time)
 Don't just post conclusions. Explain why you made a choice, so others can course-correct early.
 "I chose RS256 over HS256 because the frontend needs to verify tokens without the signing secret"
 
-## Admit uncertainty
+## Admit uncertainty — flag gaps, never guess
 If you're not sure about something, say so and ask.
 "I'm not sure if this migration is backwards-compatible — @backend can you verify?"
 
+When required information is missing from your task or dependency outputs, flag the gap
+and ask — don't invent values, endpoints, or formats to fill it. A wrong guess propagates
+to every dependent task; a question costs one message.
+
 Better to ask than to silently introduce a breaking change.
 
 ## Respond when asked

package/src/skills/squad-debugging/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: squad-debugging
+description: >
+  Debugging and rework discipline — reproduce-first workflow, hypothesis testing,
+  minimal fixes, regression tests. Use when fixing bugs, handling QA feedback,
+  working on rework/fix tasks, or investigating failures.
+version: 1.0.0
+---
+
+# Debugging & Rework
+
+## The Iron Rule: Reproduce First
+
+Never change code before you've seen the failure with your own eyes.
+
+1. **REPRODUCE**: Run the failing test, repro steps, or command from the QA
+   feedback. Confirm you see the same failure. If you can't reproduce it,
+   say so explicitly — don't "fix" what you can't observe.
+2. **LOCALIZE**: Read the error, stack trace, or diff. Form ONE hypothesis
+   about the cause. State it before changing anything.
+3. **FIX**: Make the smallest change that addresses the hypothesized cause.
+4. **VERIFY**: Re-run the exact reproduction from step 1 — it must now pass.
+   Then run the surrounding test suite to catch regressions.
+5. **PROTECT**: Add a regression test if none exists for this failure mode.
+
+## Hypothesis Discipline
+
+- One hypothesis at a time. If the fix doesn't work, REVERT it before trying
+  the next hypothesis — never stack speculative changes
+- If two hypotheses fail, stop and gather more evidence (add logging, isolate
+  with a minimal test case) instead of guessing a third time
+- Distinguish "the symptom moved" from "the cause is fixed" — re-run the
+  ORIGINAL repro, not just your new test
+
+## Rework Tasks (QA sent your work back)
+
+- Fix ONLY the issues listed in the QA feedback — no rewrites, no opportunistic
+  refactoring, no unrelated improvements
+- Reproduce each reported issue before touching code (the feedback includes
+  Expected/Got/Repro for each — use them)
+- If a reported issue looks wrong or is not reproducible, say so explicitly
+  with evidence instead of silently skipping it
+- Your completion message must show each issue → what changed → re-run evidence
+
+## Common Traps
+
+- **Fixing the test instead of the code** — only adjust a test when you can
+  argue the test itself was wrong, and say so
+- **Shotgun debugging** — many small changes at once; you won't know which
+  one mattered and you'll introduce new breakage
+- **Environment blame** — "works on my machine" requires evidence: show the
+  environment difference, don't assume it
+- **Silent scope creep** — noticing other bugs is good; fixing them inside a
+  rework task is not. Mention them so the squad can create tasks
+
+## Output Checklist
+
+Your completion message must include:
+1. Each issue: root cause (one sentence) + the fix (file:line)
+2. Evidence: the original failing command now passing (actual output)
+3. Regression scope: which suites you ran and their results

package/src/skills/squad-protocol/SKILL.md

@@ -23,6 +23,17 @@ Messages from other agents and the human arrive as interruptions in your convers
 They are prefixed with `[squad]`. Read them carefully, incorporate the information,
 and continue your work. Don't ignore incoming messages.
 
+### Advisor messages
+If you appear stuck, a senior advisor model may review your situation. Its guidance
+arrives as `[squad advisor]` with a verdict and numbered action items.
+Execute the action items unless your evidence contradicts them — in that case,
+state the conflict explicitly instead of silently ignoring the advice.
+
+### Reading your task
+Task descriptions are structured as: Goal (the outcome), Context (where to look),
+Output (deliverable), Boundaries (what must NOT change), Verify (the command that
+proves you're done). Honor the Boundaries; run the Verify command before claiming done.
+
 ### Completion
 When you finish your task, clearly state your output in your last message.
 Be specific about what you built, what files you changed, and how to verify it works.
@@ -63,3 +74,11 @@ The squad system monitors your activity and will intervene, but being explicit i
 ### Read before writing
 Before modifying any file, read it first. Another agent may have changed it
 since the last time you saw it.
+
+### Boundaries
+- If required information is missing or ambiguous, ask (@mention or escalate) —
+  flag gaps instead of guessing or inventing
+- Keep changes minimal and within your task's scope — no unrequested refactors or polish
+- Keep public APIs, schemas, and configs unchanged unless your task says otherwise
+- Never take externally visible actions (git push, deploy, publish, send messages)
+  unless your task explicitly instructs it — prepare, don't ship

package/src/skills/squad-qa-testing/SKILL.md

@@ -40,19 +40,30 @@ Every claim must have evidence. Don't just say "it works" — show it:
 - **UI tests**: Describe what you see, or use screenshots
 - **Error tests**: Show the error response for invalid input
 
-## Verdict Format
+## Verdict Format (machine-parsed — use EXACTLY this structure)
+
+Your final message MUST end with this structure. The squad system parses the
+`## Verdict:` line to decide pass/fail, and extracts the `## Issues` section
+(exactly `## Issues`, two hashes) as feedback for the fixing agent:
+
 ```
-## Verdict: PASS | FAIL
+## Verdict: PASS | FAIL | PASS WITH ISSUES
 
-### Issues Found
-| # | Issue | Severity | Details |
-|---|-------|----------|---------|
-| 1 | ...   | Critical/High/Medium/Low | ... |
+## Issues
+1. **[file:line or endpoint]** (Critical/High/Medium/Low) Description
+   - Expected: X
+   - Got: Y
+   - Repro: exact command or steps
 
-### Evidence
-[test output, curl commands, screenshots]
+## Evidence
+[test output, curl commands and responses, build output]
 ```
 
+- `FAIL` automatically creates a rework task for the original agent — it only
+  sees your `## Issues` section, so make every issue specific and reproducible
+- `PASS WITH ISSUES` = working but with non-blocking concerns (listed under `## Issues`)
+- Do NOT rename the sections (`### Issues Found` etc. breaks feedback extraction)
+
 ## Rework Flow
 If issues are found:
 1. Document each issue with severity, location, and reproduction steps