pi-squad 0.6.3 → 0.6.5

package/package.json

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

package/src/agent-pool.ts

@@ -217,6 +217,8 @@ export class AgentPool {
 			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)"}`);
 			}
+			// Capture activity stats BEFORE deleting the agent
+			const finalActivity = agentProc.activity;
 			// Clean up agents map so getRunningAgents() doesn't count dead processes
 			this.agents.delete(taskId);
 			// Only emit if we haven't already emitted via RPC agent_end event
@@ -226,7 +228,13 @@ export class AgentPool {
 					type: "agent_end",
 					taskId,
 					agentName: agentDef.name,
-					data: { exitCode: code, stderr: stderr.slice(-2000) },
+					data: {
+						exitCode: code,
+						stderr: stderr.slice(-2000),
+						turnCount: finalActivity.turnCount,
+						toolCallCount: finalActivity.recentToolCalls.length,
+						filesModified: finalActivity.modifiedFiles.size,
+					},
 				});
 			}
 			// Cleanup temp files — delay to avoid race with last stdout reads
@@ -382,13 +390,21 @@ export class AgentPool {
 			// Mark the guard to prevent double-emit from proc.on("exit")
 			const guardFn = (agent as any)._agentEndEmitted;
 			if (guardFn) guardFn();
+			// Capture activity stats BEFORE deleting
+			const endActivity = agent.activity;
 			// Remove from agents map BEFORE emitting so getRunningAgents() doesn't count it
 			this.agents.delete(agent.taskId);
 			this.emit({
 				type: "agent_end",
 				taskId: agent.taskId,
 				agentName: agent.agentName,
-				data: { exitCode: 0, stderr: "" },
+				data: {
+					exitCode: 0,
+					stderr: "",
+					turnCount: endActivity.turnCount,
+					toolCallCount: endActivity.recentToolCalls.length,
+					filesModified: endActivity.modifiedFiles.size,
+				},
 			});
 			// Kill the RPC process since the agent's work is done
 			agent.process.kill("SIGTERM");

package/src/index.ts

@@ -69,7 +69,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 
 	// Inject squad awareness before each LLM call
-	pi.on("before_agent_start", async (event, _ctx) => {
+	pi.on("before_agent_start", async (event, ctx) => {
 		if (!squadEnabled) return;
 
 		// When a squad is active, inject its status

package/src/scheduler.ts

@@ -378,29 +378,35 @@ export class Scheduler {
 				break;
 			}
 
-			case "agent_end": {
+				case "agent_end": {
 				const exitCode = event.data?.exitCode ?? 1;
-				const activity = this.pool.getActivity(event.taskId);
-				// Treat as success if agent did meaningful work (had turns),
-				// even if exit code is non-zero (common with EPIPE on parent exit)
-				const hadMeaningfulWork = activity && activity.turnCount > 0;
-				if (exitCode === 0 || hadMeaningfulWork) {
+				const turnCount = event.data?.turnCount ?? 0;
+				const toolCallCount = event.data?.toolCallCount ?? 0;
+
+				// Agent must have done real work: at least 1 turn AND at least 1 tool call.
+				// An agent that exits cleanly but with 0 turns/tools did nothing —
+				// likely hit a rate limit or API error. Treat as crash, not success.
+				const hadMeaningfulWork = turnCount > 0 && toolCallCount > 0;
+				if (hadMeaningfulWork) {
 					this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
 				} else {
-					// Agent died with no work done — retry once before failing.
-					// Transient failures (resource pressure, startup race) are common
-					// when multiple agents spawn simultaneously.
+					// Agent exited without doing real work (0 turns or 0 tool calls).
+					// Common causes: rate limit, API error, resource pressure, crash.
+					// Retry once before failing.
 					const retryKey = `spawn-retry:${event.taskId}`;
 					if (!this.spawnRetries.has(retryKey)) {
 						this.spawnRetries.add(retryKey);
 						const stderr = event.data?.stderr || "";
-						logError("squad-scheduler", `Agent ${event.agentName} died instantly (code ${exitCode}). Retrying in 2s... stderr: ${stderr.slice(0, 200)}`);
+						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)}`);
 						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...`,
+							text: `Agent ${reason}. Retrying...`,
 						});
 						// Delay retry to let resources settle
 						setTimeout(() => {