pi-messenger 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.11.0] - 2026-02-08
+
+### Added
+- **Test suite** — 53 tests across 7 Vitest suites covering store CRUD, state machine, config merging, agent discovery, model resolution, graceful shutdown, and live progress (including cwd isolation). Includes test helpers for temp directories and mock contexts.
+- **Per-agent runtime config** — Model override with 4-level priority: per-task > per-wave `model` param > config `crew.models.worker` > agent `.md` frontmatter. Environment variable override via `crew.work.env` config (not exposed as tool param to prevent API keys in logs).
+- **Graceful shutdown** — `AbortSignal` threaded from tool execute through to spawned workers. On abort: discovers worker name via PID-based registry scan, writes shutdown message to worker inbox, waits 30s grace period, SIGTERM, waits 5s, SIGKILL. Tasks reset to `todo` for retry. Workers instructed to release reservations and exit without committing.
+- **Live crew progress** — In-memory pub/sub store fed by worker JSONL events. Overlay Crew tab shows Active Workers section with tool name, call count, tokens, and elapsed time updating every second. Status bar shows active worker count during autonomous mode (`🔨N`).
+- **`shutdownGracePeriodMs` config** — Configurable grace period before SIGTERM (default: 30000).
+
+### Changed
+- **Dynamic overlay height** — Content area scales with terminal size (8-25 lines) instead of hardcoded 10. On a standard 24-row terminal, visible content goes from 10 to 15 lines.
+- **Handler signatures simplified** — Removed unused `state` and `dirs` parameters from plan and review handlers.
+
+### Fixed
+- **`deepMerge` crash** — Merging config with `models` key crashed when the target didn't have the key. Hardened for undefined target keys.
+- **Result/task association** — Worker results now matched by `taskId` field instead of array index, since `spawnAgents` returns in completion order not submission order.
+
+### Removed
+- `attemptsPerTask` field from `AutonomousState` — declared but never populated by any code.
+- `ARCHITECTURE.md` from repo (moved to external docs).
+
 ## [0.10.0] - 2026-02-05
 
 ### Fixed

package/README.md

@@ -122,13 +122,31 @@ Add to `~/.pi/agent/pi-messenger.json`:
 {
   "crew": {
     "concurrency": { "workers": 2 },
+    "models": { "worker": "claude-sonnet-4-20250514" },
     "review": { "enabled": true, "maxIterations": 3 },
     "planning": { "maxPasses": 3 },
-    "work": { "maxAttemptsPerTask": 5, "maxWaves": 50 }
+    "work": {
+      "maxAttemptsPerTask": 5,
+      "maxWaves": 50,
+      "shutdownGracePeriodMs": 30000,
+      "env": { "NODE_ENV": "test" }
+    }
   }
 }
 ```
 
+| Setting | Description | Default |
+|---------|-------------|---------|
+| `concurrency.workers` | Max parallel workers per wave | `2` |
+| `models.worker` | Model for spawned workers (overridden by per-task or per-wave `model` param) | agent `.md` frontmatter |
+| `review.enabled` | Auto-review after task completion | `true` |
+| `review.maxIterations` | Max review/fix cycles per task | `3` |
+| `planning.maxPasses` | Max planner/reviewer refinement passes | `3` |
+| `work.maxAttemptsPerTask` | Auto-block after N failures | `5` |
+| `work.maxWaves` | Max autonomous waves | `50` |
+| `work.shutdownGracePeriodMs` | Grace period before SIGTERM on abort | `30000` |
+| `work.env` | Environment variables passed to spawned workers | `{}` |
+
 Crew agents (planner, worker, reviewer, interview-generator, plan-sync) are **auto-installed** on first use. Run `npx pi-messenger --crew-install` to manually install or update.
 
 ## API Reference
@@ -216,7 +234,7 @@ Pi-messenger is a [pi extension](https://github.com/badlogic/pi-mono) that hooks
 
 Incoming messages wake the receiving agent via `pi.sendMessage()` with `triggerTurn: true` and `deliverAs: "steer"`, which injects the message as a steering prompt that resumes the agent. File reservations are enforced by returning `{ block: true }` from a `tool_call` hook on write/edit operations. The `/messenger` overlay uses `ctx.ui.custom()` for the chat TUI, and `ctx.ui.setStatus()` keeps the status bar updated with peer count and unread messages.
 
-Crew workers are spawned as `pi --mode json` subprocesses with the agent's system prompt, model, and tool restrictions from their `.md` definitions. Progress is tracked via JSONL streaming. The planner and reviewer work the same way — just pi instances with different agent configs.
+Crew workers are spawned as `pi --mode json` subprocesses with the agent's system prompt, model, and tool restrictions from their `.md` definitions. Progress is tracked via JSONL streaming — the overlay subscribes to a live progress store that shows each worker's current tool, call count, and token usage in real time. Aborting a work run triggers graceful shutdown: each worker receives an inbox message asking it to stop, followed by a grace period before SIGTERM. The planner and reviewer work the same way — just pi instances with different agent configs.
 
 All coordination is file-based, no daemon required. Global state (registry, inboxes, activity feed) lives in `~/.pi/agent/messenger/`. Per-project crew data (plan, tasks, artifacts) lives in `.pi/messenger/crew/` inside your project. Dead agents are detected via PID checks and cleaned up automatically.
 

package/crew/agents/crew-worker.md

@@ -85,6 +85,15 @@ pi_messenger({
 })
 ```
 
+## Shutdown Handling
+
+If you receive a message saying "SHUTDOWN REQUESTED":
+1. Stop what you're doing
+2. Release reservations: `pi_messenger({ action: "release" })`
+3. Do NOT mark the task as done — leave it as in_progress for retry
+4. Do NOT commit anything
+5. Exit immediately
+
 ## Important Rules
 
 - ALWAYS join first, before any other pi_messenger calls

package/crew/agents.ts

@@ -11,13 +11,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { discoverCrewAgents, type CrewAgentConfig } from "./utils/discover.js";
-import { truncateOutput, type MaxOutputConfig } from "./utils/truncate.js";
+import { truncateOutput } from "./utils/truncate.js";
 import {
   createProgress,
   parseJsonlLine,
   updateProgress,
   getFinalOutput,
-  type AgentProgress
+  type AgentProgress,
+  type PiEvent,
 } from "./utils/progress.js";
 import {
   getArtifactPaths,
@@ -27,6 +28,7 @@ import {
   appendJsonl
 } from "./utils/artifacts.js";
 import { loadCrewConfig, getTruncationForRole, type CrewConfig } from "./utils/config.js";
+import { removeLiveWorker, updateLiveWorker } from "./live-progress.js";
 import type { AgentTask, AgentResult } from "./types.js";
 
 // Extension directory (parent of crew/) - passed to subagents so they can use pi_messenger
@@ -39,8 +41,55 @@ export interface SpawnOptions {
   onProgress?: (results: AgentResult[]) => void;
   crewDir?: string;
   signal?: AbortSignal;
+  messengerDirs?: { registry: string; inbox: string };
 }
 
+export function resolveModel(
+  taskModel?: string,
+  paramModel?: string,
+  configModel?: string,
+  agentModel?: string,
+): string | undefined {
+  return taskModel ?? paramModel ?? configModel ?? agentModel;
+}
+
+export function raceTimeout(promise: Promise<void>, ms: number): Promise<boolean> {
+  return new Promise<boolean>(resolve => {
+    const timer = setTimeout(() => resolve(false), ms);
+    promise.then(
+      () => {
+        clearTimeout(timer);
+        resolve(true);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(false);
+      },
+    );
+  });
+}
+
+function discoverWorkerName(
+  pid: number | undefined,
+  registryDir: string | undefined
+): string | null {
+  if (!pid || !registryDir || !fs.existsSync(registryDir)) return null;
+  try {
+    for (const file of fs.readdirSync(registryDir)) {
+      if (!file.endsWith(".json")) continue;
+      const reg = JSON.parse(fs.readFileSync(path.join(registryDir, file), "utf-8"));
+      if (reg.pid === pid) return reg.name;
+    }
+  } catch {}
+  return null;
+}
+
+const SHUTDOWN_MESSAGE = `⚠️ SHUTDOWN REQUESTED: Please wrap up your current work.
+1. Release any file reservations
+2. If the task is not complete, leave it as in_progress (do NOT mark done)
+3. Do NOT commit anything
+4. Exit`;
+
 /**
  * Spawn multiple agents in parallel with concurrency limit.
  */
@@ -66,7 +115,10 @@ export async function spawnAgents(
   const running: Promise<void>[] = [];
 
   while (queue.length > 0 || running.length > 0) {
+    if (options.signal?.aborted && running.length === 0) break;
+
     while (running.length < concurrency && queue.length > 0) {
+      if (options.signal?.aborted) break;
       const { task, index } = queue.shift()!;
       const promise = runAgent(task, index, cwd, agents, config, runId, artifactsDir, options)
         .then(result => {
@@ -78,6 +130,7 @@ export async function spawnAgents(
     }
     if (running.length > 0) {
       await Promise.race(running);
+      if (options.signal?.aborted) continue;
     }
   }
 
@@ -117,7 +170,8 @@ async function runAgent(
   return new Promise((resolve) => {
     // Build args for pi command
     const args = ["--mode", "json", "--no-session", "-p"];
-    if (agentConfig?.model) args.push("--model", agentConfig.model);
+    const model = task.modelOverride ?? agentConfig?.model;
+    if (model) args.push("--model", model);
 
     if (agentConfig?.tools?.length) {
       const builtinTools: string[] = [];
@@ -151,10 +205,21 @@ async function runAgent(
 
     args.push(task.task);
 
-    const proc = spawn("pi", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const envOverrides = config.work.env ?? {};
+    const env = Object.keys(envOverrides).length > 0
+      ? { ...process.env, ...envOverrides }
+      : undefined;
+
+    const proc = spawn("pi", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...(env ? { env } : {}),
+    });
+    let gracefulShutdownRequested = false;
+    let discoveredWorkerName: string | null = null;
 
     let jsonlBuffer = "";
-    const events: unknown[] = [];
+    const events: PiEvent[] = [];
 
     proc.stdout?.on("data", (data) => {
       jsonlBuffer += data.toString();
@@ -167,6 +232,17 @@ async function runAgent(
           events.push(event);
           updateProgress(progress, event, startTime);
           if (artifactPaths) appendJsonl(artifactPaths.jsonlPath, line);
+          if (task.taskId) {
+            updateLiveWorker(cwd, task.taskId, {
+              taskId: task.taskId,
+              agent: task.agent,
+              progress: {
+                ...progress,
+                recentTools: progress.recentTools.map(tool => ({ ...tool })),
+              },
+              startedAt: startTime,
+            });
+          }
         }
       }
     });
@@ -175,12 +251,13 @@ async function runAgent(
     proc.stderr?.on("data", (data) => { stderr += data.toString(); });
 
     proc.on("close", (code) => {
+      if (task.taskId) removeLiveWorker(cwd, task.taskId);
       progress.status = code === 0 ? "completed" : "failed";
       progress.durationMs = Date.now() - startTime;
       if (stderr && code !== 0) progress.error = stderr;
 
       // Get final output from events
-      const fullOutput = getFinalOutput(events as any[]);
+      const fullOutput = getFinalOutput(events);
       const truncation = truncateOutput(fullOutput, maxOutput, artifactPaths?.outputPath);
 
       // Write output artifact (untruncated)
@@ -209,6 +286,8 @@ async function runAgent(
         truncated: truncation.truncated,
         progress,
         config: agentConfig,
+        taskId: task.taskId,
+        wasGracefullyShutdown: gracefulShutdownRequested,
         error: progress.error,
         artifactPaths: artifactPaths ? {
           input: artifactPaths.inputPath,
@@ -217,16 +296,66 @@ async function runAgent(
           metadata: artifactPaths.metadataPath,
         } : undefined,
       });
+
+      if (gracefulShutdownRequested && discoveredWorkerName && options.messengerDirs?.registry) {
+        try {
+          fs.unlinkSync(path.join(options.messengerDirs.registry, `${discoveredWorkerName}.json`));
+        } catch {}
+      }
     });
 
     // Handle abort signal
     if (options.signal) {
-      const kill = () => {
-        proc.kill("SIGTERM");
-        setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
+      const gracefulShutdown = async () => {
+        gracefulShutdownRequested = true;
+
+        let messageSent = false;
+        discoveredWorkerName = discoverWorkerName(proc.pid, options.messengerDirs?.registry);
+        if (discoveredWorkerName && options.messengerDirs) {
+          try {
+            const inboxDir = path.join(options.messengerDirs.inbox, discoveredWorkerName);
+            if (fs.existsSync(inboxDir)) {
+              const msgFile = path.join(inboxDir, `${Date.now()}-shutdown.json`);
+              fs.writeFileSync(msgFile, JSON.stringify({
+                id: randomUUID(),
+                from: "crew-orchestrator",
+                to: discoveredWorkerName,
+                text: SHUTDOWN_MESSAGE,
+                timestamp: new Date().toISOString(),
+                replyTo: null,
+              }));
+              messageSent = true;
+            }
+          } catch {}
+        }
+
+        if (messageSent) {
+          const graceMs = config.work.shutdownGracePeriodMs ?? 30000;
+          const exitPromise = new Promise<void>(r => proc.once("exit", () => r()));
+          const exited = await raceTimeout(exitPromise, graceMs);
+          if (exited) return;
+        }
+
+        if (!proc.killed && proc.exitCode === null) {
+          proc.kill("SIGTERM");
+          const termPromise = new Promise<void>(r => proc.once("exit", () => r()));
+          const killed = await raceTimeout(termPromise, 5000);
+          if (killed) return;
+        } else {
+          return;
+        }
+
+        if (!proc.killed && proc.exitCode === null) {
+          proc.kill("SIGKILL");
+        }
       };
-      if (options.signal.aborted) kill();
-      else options.signal.addEventListener("abort", kill, { once: true });
+      if (options.signal.aborted) {
+        gracefulShutdown().catch(() => {});
+      } else {
+        options.signal.addEventListener("abort", () => {
+          gracefulShutdown().catch(() => {});
+        }, { once: true });
+      }
     }
   });
 }

package/crew/handlers/plan.ts

@@ -8,7 +8,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { MessengerState, Dirs } from "../../lib.js";
 import type { CrewParams } from "../types.js";
 import { result } from "../utils/result.js";
 import { spawnAgents } from "../agents.js";
@@ -108,8 +107,6 @@ function appendReviewToProgress(
 
 export async function execute(
   params: CrewParams,
-  _state: MessengerState,
-  _dirs: Dirs,
   ctx: ExtensionContext
 ) {
   const cwd = ctx.cwd ?? process.cwd();
@@ -185,7 +182,8 @@ export async function execute(
 
     const [plannerResult] = await spawnAgents([{
       agent: PLANNER_AGENT,
-      task: plannerPrompt
+      task: plannerPrompt,
+      modelOverride: config.models?.planner,
     }], 1, cwd);
 
     if (plannerResult.exitCode !== 0) {
@@ -219,7 +217,8 @@ export async function execute(
 
     const [reviewResult] = await spawnAgents([{
       agent: "crew-reviewer",
-      task: reviewPrompt
+      task: reviewPrompt,
+      modelOverride: config.models?.reviewer,
     }], 1, cwd);
 
     if (reviewResult.exitCode !== 0) {

package/crew/handlers/review.ts

@@ -7,22 +7,22 @@
 
 import { execSync } from "node:child_process";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { MessengerState, Dirs } from "../../lib.js";
 import type { CrewParams } from "../types.js";
 import { result } from "../utils/result.js";
 import { spawnAgents } from "../agents.js";
 import { discoverCrewAgents } from "../utils/discover.js";
+import { loadCrewConfig } from "../utils/config.js";
 import { parseVerdict, type ParsedReview } from "../utils/verdict.js";
 import * as store from "../store.js";
 
 export async function execute(
   params: CrewParams,
-  _state: MessengerState,
-  _dirs: Dirs,
   ctx: ExtensionContext
 ) {
   const cwd = ctx.cwd ?? process.cwd();
   const { target, type } = params;
+  const config = loadCrewConfig(store.getCrewDir(cwd));
+  const reviewerModel = config.models?.reviewer;
 
   if (!target) {
     return result("Error: target (task ID) required for review action.\n\nUsage: pi_messenger({ action: \"review\", target: \"task-1\" })", {
@@ -45,9 +45,9 @@ export async function execute(
   const reviewType = type ?? (target.startsWith("task-") ? "impl" : "plan");
 
   if (reviewType === "impl") {
-    return reviewImplementation(cwd, target);
+    return reviewImplementation(cwd, target, reviewerModel);
   } else {
-    return reviewPlan(cwd);
+    return reviewPlan(cwd, reviewerModel);
   }
 }
 
@@ -55,7 +55,7 @@ export async function execute(
 // Implementation Review
 // =============================================================================
 
-async function reviewImplementation(cwd: string, taskId: string) {
+async function reviewImplementation(cwd: string, taskId: string, modelOverride?: string) {
   const task = store.getTask(cwd, taskId);
   if (!task) {
     return result(`Error: Task ${taskId} not found.`, {
@@ -120,7 +120,8 @@ Output your verdict as SHIP, NEEDS_WORK, or MAJOR_RETHINK with detailed feedback
   // Spawn reviewer
   const [reviewResult] = await spawnAgents([{
     agent: "crew-reviewer",
-    task: prompt
+    task: prompt,
+    modelOverride,
   }], 1, cwd);
 
   if (reviewResult.exitCode !== 0) {
@@ -170,7 +171,7 @@ ${verdict.verdict === "SHIP" ? "✅ Ready to merge!" : verdict.verdict === "NEED
 // Plan Review
 // =============================================================================
 
-async function reviewPlan(cwd: string) {
+async function reviewPlan(cwd: string, modelOverride?: string) {
   const plan = store.getPlan(cwd);
   if (!plan) {
     return result("Error: No plan found.", {
@@ -224,7 +225,8 @@ Output your verdict as SHIP (plan is solid), NEEDS_WORK (minor adjustments), or
   // Spawn reviewer
   const [reviewResult] = await spawnAgents([{
     agent: "crew-reviewer",
-    task: prompt
+    task: prompt,
+    modelOverride,
   }], 1, cwd);
 
   if (reviewResult.exitCode !== 0) {

package/crew/handlers/work.ts

@@ -6,10 +6,10 @@
  */
 
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { MessengerState, Dirs } from "../../lib.js";
+import type { Dirs } from "../../lib.js";
 import type { CrewParams, AppendEntryFn, Task } from "../types.js";
 import { result } from "../utils/result.js";
-import { spawnAgents } from "../agents.js";
+import { resolveModel, spawnAgents } from "../agents.js";
 import { loadCrewConfig } from "../utils/config.js";
 import { discoverCrewAgents } from "../utils/discover.js";
 import * as store from "../store.js";
@@ -18,10 +18,10 @@ import { autonomousState, startAutonomous, stopAutonomous, addWaveResult } from
 
 export async function execute(
   params: CrewParams,
-  _state: MessengerState,
-  _dirs: Dirs,
+  dirs: Dirs,
   ctx: ExtensionContext,
-  appendEntry: AppendEntryFn
+  appendEntry: AppendEntryFn,
+  signal?: AbortSignal
 ) {
   const cwd = ctx.cwd ?? process.cwd();
   const config = loadCrewConfig(getCrewDir(cwd));
@@ -87,15 +87,30 @@ export async function execute(
   }
 
   // Spawn workers
-  const workerTasks = tasksToRun.map(task => ({
-    agent: "crew-worker",
-    task: buildWorkerPrompt(task, plan.prd, cwd)
-  }));
+  const workerTasks = tasksToRun.map(task => {
+    const taskModel = resolveModel(
+      task.model,
+      params.model,
+      config.models?.worker,
+      undefined,
+    );
+
+    return {
+      agent: "crew-worker",
+      task: buildWorkerPrompt(task, plan.prd, cwd),
+      taskId: task.id,
+      modelOverride: taskModel,
+    };
+  });
 
   const workerResults = await spawnAgents(
     workerTasks,
     concurrency,
-    cwd
+    cwd,
+    {
+      signal,
+      messengerDirs: { registry: dirs.registry, inbox: dirs.inbox },
+    }
   );
 
   // Process results
@@ -105,22 +120,33 @@ export async function execute(
 
   for (let i = 0; i < workerResults.length; i++) {
     const r = workerResults[i];
-    const taskId = tasksToRun[i].id;
+    const taskId = r.taskId;
+    if (!taskId) {
+      failed.push(`unknown-result-${i}`);
+      continue;
+    }
     const task = store.getTask(cwd, taskId);
 
     if (r.exitCode === 0) {
-      // Check if task was completed (worker should call task.done)
       if (task?.status === "done") {
         succeeded.push(taskId);
       } else if (task?.status === "blocked") {
         blocked.push(taskId);
+      } else if (r.wasGracefullyShutdown && task?.status === "in_progress") {
+        store.updateTask(cwd, taskId, { status: "todo", assigned_to: undefined });
       } else {
-        // Worker finished but didn't complete - treat as failure
         failed.push(taskId);
       }
     } else {
-      // Auto-block on failure if in autonomous mode
-      if (autonomous && task?.status === "in_progress") {
+      if (r.wasGracefullyShutdown) {
+        if (task?.status === "done") {
+          succeeded.push(taskId);
+        } else if (task?.status === "blocked") {
+          blocked.push(taskId);
+        } else if (task?.status === "in_progress") {
+          store.updateTask(cwd, taskId, { status: "todo", assigned_to: undefined });
+        }
+      } else if (autonomous && task?.status === "in_progress") {
         store.blockTask(cwd, taskId, `Worker failed: ${r.error ?? "Unknown error"}`);
         blocked.push(taskId);
       } else {
@@ -142,37 +168,40 @@ export async function execute(
       timestamp: new Date().toISOString()
     });
 
-    // Check if we should continue
-    const nextReady = store.getReadyTasks(cwd);
-    const allTasks = store.getTasks(cwd);
-    const allDone = allTasks.every(t => t.status === "done");
-    const allBlockedOrDone = allTasks.every(t => t.status === "done" || t.status === "blocked");
-
-    if (allDone) {
-      stopAutonomous("completed");
+    if (signal?.aborted) {
+      stopAutonomous("manual");
       appendEntry("crew-state", autonomousState);
-      appendEntry("crew_wave_complete", {
-        prd: plan.prd,
-        status: "completed",
-        totalWaves: currentWave,
-        totalTasks: allTasks.length
-      });
-    } else if (allBlockedOrDone || nextReady.length === 0) {
-      stopAutonomous("blocked");
-      appendEntry("crew-state", autonomousState);
-      appendEntry("crew_wave_blocked", {
-        prd: plan.prd,
-        status: "blocked",
-        blockedTasks: allTasks.filter(t => t.status === "blocked").map(t => t.id)
-      });
     } else {
-      // Persist state for session recovery and signal continuation
-      appendEntry("crew-state", autonomousState);
-      appendEntry("crew_wave_continue", {
-        prd: plan.prd,
-        nextWave: autonomousState.waveNumber,
-        readyTasks: nextReady.map(t => t.id)
-      });
+      const nextReady = store.getReadyTasks(cwd);
+      const allTasks = store.getTasks(cwd);
+      const allDone = allTasks.every(t => t.status === "done");
+      const allBlockedOrDone = allTasks.every(t => t.status === "done" || t.status === "blocked");
+
+      if (allDone) {
+        stopAutonomous("completed");
+        appendEntry("crew-state", autonomousState);
+        appendEntry("crew_wave_complete", {
+          prd: plan.prd,
+          status: "completed",
+          totalWaves: currentWave,
+          totalTasks: allTasks.length
+        });
+      } else if (allBlockedOrDone || nextReady.length === 0) {
+        stopAutonomous("blocked");
+        appendEntry("crew-state", autonomousState);
+        appendEntry("crew_wave_blocked", {
+          prd: plan.prd,
+          status: "blocked",
+          blockedTasks: allTasks.filter(t => t.status === "blocked").map(t => t.id)
+        });
+      } else {
+        appendEntry("crew-state", autonomousState);
+        appendEntry("crew_wave_continue", {
+          prd: plan.prd,
+          nextWave: autonomousState.waveNumber,
+          readyTasks: nextReady.map(t => t.id)
+        });
+      }
     }
   }
 
@@ -191,6 +220,11 @@ export async function execute(
   const nextText = nextReady.length > 0
     ? `\n\n**Ready for next wave:** ${nextReady.map(t => t.id).join(", ")}`
     : "";
+  const continueText = autonomous && !signal?.aborted && nextReady.length > 0
+    ? "Autonomous mode: Continuing to next wave..."
+    : signal?.aborted && autonomous
+      ? "Autonomous mode stopped (cancelled)."
+      : "";
 
   const text = `# Work Wave ${currentWave}
 
@@ -199,7 +233,7 @@ export async function execute(
 **Progress:** ${progress}
 ${statusText}${nextText}
 
-${autonomous && nextReady.length > 0 ? "Autonomous mode: Continuing to next wave..." : ""}`;
+${continueText}`;
 
   return result(text, {
     mode: "work",

package/crew/index.ts

@@ -42,7 +42,8 @@ export async function executeCrewAction(
   deliverMessage: DeliverFn,
   updateStatus: UpdateStatusFn,
   appendEntry: AppendEntryFn,
-  config?: CrewActionConfig
+  config?: CrewActionConfig,
+  signal?: AbortSignal
 ) {
   // Parse action: "task.show" → group="task", op="show"
   const dotIndex = action.indexOf('.');
@@ -177,7 +178,7 @@ export async function executeCrewAction(
       ensureCrewInstalled();
       try {
         const planHandler = await import("./handlers/plan.js");
-        return planHandler.execute(params, state, dirs, ctx);
+        return planHandler.execute(params, ctx);
       } catch (e) {
         return result(`Error: plan handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
           { mode: "plan", error: "handler_error" });
@@ -189,7 +190,7 @@ export async function executeCrewAction(
       ensureCrewInstalled();
       try {
         const workHandler = await import("./handlers/work.js");
-        return workHandler.execute(params, state, dirs, ctx, appendEntry);
+        return workHandler.execute(params, dirs, ctx, appendEntry, signal);
       } catch (e) {
         return result(`Error: work handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
           { mode: "work", error: "handler_error" });
@@ -201,7 +202,7 @@ export async function executeCrewAction(
       ensureCrewInstalled();
       try {
         const reviewHandler = await import("./handlers/review.js");
-        return reviewHandler.execute(params, state, dirs, ctx);
+        return reviewHandler.execute(params, ctx);
       } catch (e) {
         return result(`Error: review handler failed: ${e instanceof Error ? e.message : 'unknown'}`,
           { mode: "review", error: "handler_error" });