pi-messenger 0.13.1 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.13.2] - 2026-03-19
+
+### Added
+- **`work.stop` action** — `pi_messenger({ action: "work.stop" })` now stops autonomous Crew work for the current project and persists the stop state.
+- **Autonomous guard coverage tests** — Added targeted tests for `work.stop` routing and `agent_end` autonomous continuation guard behavior.
+
+### Fixed
+- **Autonomous continuation retry loop guard** — Autonomous Crew mode now stops itself after repeated identical `crew_continue` retries without wave progress (for example when steer turns keep aborting). The extension persists the stopped state and emits a warning instead of looping indefinitely.
+- **Persisted autonomous stop state from index-level stop paths** — `max waves` and `no ready tasks` stop paths now append `crew-state` so restored sessions do not revive stale active autonomous state.
+- **Autonomous continuation no longer runs in unregistered sessions** — If Crew autonomous state is restored but the current session is not joined to pi-messenger, the extension now stops autonomous mode and persists that stop instead of emitting repeated continuation steer messages that cannot execute.
+- **Autonomous continuation now runs only in orchestrator sessions** — Worker and lobby processes (`PI_CREW_WORKER`/`PI_LOBBY_ID`) now skip `agent_end` continuation emission to prevent repeated duplicate `crew_continue` steer loops from non-orchestrator agents.
+- **Autonomous continuation is now cwd-scoped** — `agent_end` continuation now requires the session cwd to match the active autonomous cwd (`isAutonomousForCwd`), preventing stale autonomous state from unrelated projects from triggering unexpected `crew_continue` messages.
+- **Autonomous state restore now validates owner process** — Restored active autonomous state now requires a live owner PID matching the current process; missing/dead/foreign ownership is treated as stale and auto-stopped to avoid unexpected continuation after session restore.
+- **Runtime artifact commit noise** — Added `.pi/` to `.gitignore` to avoid accidentally committing runtime files like feed artifacts.
+
 ## [0.13.1] - 2026-03-14
 
 ### Added

package/README.md

@@ -268,6 +268,7 @@ Agent definitions live in `crew/agents/` within the extension. To customize one
 |--------|-------------|
 | `plan` | Create plan from PRD or inline prompt (`prd`, `prompt` optional — auto-discovers PRD if omitted, auto-starts workers unless `autoWork: false`) |
 | `work` | Run ready tasks (`autonomous`, `concurrency` optional) |
+| `work.stop` | Stop autonomous work for the current project |
 | `review` | Review implementation (`target` task ID required) |
 | `task.list` | List all tasks |
 | `task.show` | Show task details (`id` required) |

package/crew/index.ts

@@ -10,7 +10,7 @@ import type { MessengerState, Dirs, AgentMailMessage, NameThemeConfig } from "..
 import * as handlers from "../handlers.js";
 import type { CrewParams, AppendEntryFn } from "./types.js";
 import { result } from "./utils/result.js";
-import { isPlanningForCwd, cancelPlanningRun } from "./state.js";
+import { isPlanningForCwd, cancelPlanningRun, autonomousState, isAutonomousForCwd, stopAutonomous } from "./state.js";
 import { logFeedEvent } from "../feed.js";
 
 type DeliverFn = (msg: AgentMailMessage) => void;
@@ -180,6 +180,16 @@ export async function executeCrewAction(
     }
 
     case 'work': {
+      if (op === 'stop') {
+        const cwd = ctx.cwd ?? process.cwd();
+        if (!isAutonomousForCwd(cwd)) {
+          return result("No autonomous work running for this project.", { mode: "work.stop" });
+        }
+        stopAutonomous("manual");
+        appendEntry("crew-state", autonomousState);
+        return result("Autonomous work stopped.", { mode: "work.stop", autonomous: false });
+      }
+
       try {
         const workHandler = await import("./handlers/work.js");
         return workHandler.execute(params, dirs, ctx, appendEntry, signal);

package/crew/state-autonomous.ts

@@ -25,6 +25,7 @@ export interface AutonomousState {
   stopReason: "completed" | "blocked" | "manual" | null;
   concurrency: number;
   autoOverlayPending: boolean;
+  pid: number | null;
 }
 
 export const autonomousState: AutonomousState = {
@@ -37,11 +38,21 @@ export const autonomousState: AutonomousState = {
   stopReason: null,
   concurrency: 2,
   autoOverlayPending: false,
+  pid: null,
 };
 
 export const MIN_CONCURRENCY = 1;
 export const MAX_CONCURRENCY = 10;
 
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function clampConcurrency(value: number, configMax?: number): number {
   if (!Number.isFinite(value)) return MIN_CONCURRENCY;
   const whole = Math.trunc(value);
@@ -79,6 +90,7 @@ export function startAutonomous(cwd: string, concurrency: number): void {
   autonomousState.stopReason = null;
   autonomousState.concurrency = clampConcurrency(concurrency);
   autonomousState.autoOverlayPending = true;
+  autonomousState.pid = process.pid;
 }
 
 export function stopAutonomous(reason: "completed" | "blocked" | "manual"): void {
@@ -86,6 +98,7 @@ export function stopAutonomous(reason: "completed" | "blocked" | "manual"): void
   autonomousState.autoOverlayPending = false;
   autonomousState.stoppedAt = new Date().toISOString();
   autonomousState.stopReason = reason;
+  autonomousState.pid = null;
 }
 
 export function addWaveResult(result: WaveResult): void {
@@ -106,6 +119,23 @@ export function restoreAutonomousState(data: Partial<AutonomousState>): void {
   if (data.concurrency !== undefined) {
     autonomousState.concurrency = clampConcurrency(Number(data.concurrency));
   }
+  if (data.pid !== undefined) {
+    autonomousState.pid = typeof data.pid === "number" ? data.pid : null;
+  }
+
+  if (!autonomousState.active) return;
+
+  const ownerPid = autonomousState.pid;
+  const sameProcess = ownerPid === process.pid;
+  const ownerAlive = typeof ownerPid === "number" && isProcessAlive(ownerPid);
+
+  if (!sameProcess || !ownerAlive) {
+    autonomousState.active = false;
+    autonomousState.autoOverlayPending = false;
+    autonomousState.stopReason = autonomousState.stopReason ?? "manual";
+    autonomousState.stoppedAt = autonomousState.stoppedAt ?? new Date().toISOString();
+    autonomousState.pid = null;
+  }
 }
 
 export function isAutonomousForCwd(cwd: string): boolean {

package/index.ts

@@ -58,6 +58,7 @@ import {
   restoreAutonomousState,
   restorePlanningState,
   stopAutonomous,
+  isAutonomousForCwd,
 } from "./crew/state.js";
 import { loadCrewConfig } from "./crew/utils/config.js";
 import * as crewStore from "./crew/store.js";
@@ -295,6 +296,24 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
   const STATUS_HEARTBEAT_MS = 15_000;
   let latestCtx: ExtensionContext | null = null;
   let statusHeartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  const AUTONOMOUS_CONTINUE_REPEAT_LIMIT = 3;
+  let autonomousContinueSignature: string | null = null;
+  let autonomousContinueRepeats = 0;
+
+  function resetAutonomousContinueGuard(): void {
+    autonomousContinueSignature = null;
+    autonomousContinueRepeats = 0;
+  }
+
+  function trackAutonomousContinue(signature: string): number {
+    if (autonomousContinueSignature === signature) {
+      autonomousContinueRepeats += 1;
+    } else {
+      autonomousContinueSignature = signature;
+      autonomousContinueRepeats = 1;
+    }
+    return autonomousContinueRepeats;
+  }
 
   function startStatusHeartbeat(): void {
     if (statusHeartbeatTimer) return;
@@ -358,6 +377,7 @@ Usage (action-based API - preferred):
   // Crew: Work through tasks
   pi_messenger({ action: "work" })                              → Run ready tasks
   pi_messenger({ action: "work", autonomous: true })            → Run until done/blocked
+  pi_messenger({ action: "work.stop" })                         → Stop autonomous work for this project
   
   // Crew: Tasks
   pi_messenger({ action: "task.show", id: "task-1" })           → Show task
@@ -749,6 +769,7 @@ Usage (action-based API - preferred):
 
   pi.on("session_start", async (_event, ctx) => {
     latestCtx = ctx;
+    resetAutonomousContinueGuard();
     startStatusHeartbeat();
     for (const entry of ctx.sessionManager.getEntries()) {
       if (entry.type === "custom" && entry.customType === "crew-state") {
@@ -870,6 +891,7 @@ Usage (action-based API - preferred):
 
   pi.on("session_switch", async (_event, ctx) => {
     latestCtx = ctx;
+    resetAutonomousContinueGuard();
     const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
     if (staleCleared && ctx.hasUI) {
       ctx.ui.notify("Stale planning state cleared (planner process exited)", "warning");
@@ -880,6 +902,7 @@ Usage (action-based API - preferred):
   });
   pi.on("session_fork", async (_event, ctx) => {
     latestCtx = ctx;
+    resetAutonomousContinueGuard();
     const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
     if (staleCleared && ctx.hasUI) {
       ctx.ui.notify("Stale planning state cleared (planner process exited)", "warning");
@@ -936,6 +959,22 @@ Usage (action-based API - preferred):
   // ===========================================================================
 
   pi.on("agent_end", async (_event, ctx) => {
+    if (process.env.PI_CREW_WORKER === "1" || process.env.PI_LOBBY_ID) {
+      return;
+    }
+
+    if (!state.registered) {
+      if (autonomousState.active) {
+        stopAutonomous("manual");
+        pi.appendEntry("crew-state", autonomousState);
+        resetAutonomousContinueGuard();
+        if (ctx.hasUI) {
+          ctx.ui.notify("Autonomous stopped: this session is not registered in pi-messenger.", "warning");
+        }
+      }
+      return;
+    }
+
     // --- Auto-work after plan completion ---
     const autoWork = consumePendingAutoWork();
     if (autoWork && !overlayTui) {
@@ -955,15 +994,26 @@ Usage (action-based API - preferred):
     }
 
     // --- Existing autonomous continuation ---
-    if (!autonomousState.active) return;
+    if (!autonomousState.active) {
+      resetAutonomousContinueGuard();
+      return;
+    }
 
-    const cwd = autonomousState.cwd ?? ctx.cwd ?? process.cwd();
+    const currentCwd = ctx.cwd ?? process.cwd();
+    if (!isAutonomousForCwd(currentCwd)) {
+      resetAutonomousContinueGuard();
+      return;
+    }
+
+    const cwd = autonomousState.cwd ?? currentCwd;
     const crewDir = join(cwd, ".pi", "messenger", "crew");
     const crewConfig = loadCrewConfig(crewDir);
 
     // Check max waves limit
     if (autonomousState.waveNumber >= crewConfig.work.maxWaves) {
       stopAutonomous("manual");
+      pi.appendEntry("crew-state", autonomousState);
+      resetAutonomousContinueGuard();
       if (ctx.hasUI) {
         ctx.ui.notify(`Autonomous stopped: max waves (${crewConfig.work.maxWaves}) reached`, "warning");
       }
@@ -972,14 +1022,16 @@ Usage (action-based API - preferred):
 
     // Check for ready tasks
     const readyTasks = crewStore.getReadyTasks(cwd, { advisory: crewConfig.dependencies === "advisory" });
-    
+
     if (readyTasks.length === 0) {
       // No ready tasks - check if all done or blocked
       const allTasks = crewStore.getTasks(cwd);
       const allDone = allTasks.every(t => t.status === "done");
-      
+
       stopAutonomous(allDone ? "completed" : "blocked");
-      
+      pi.appendEntry("crew-state", autonomousState);
+      resetAutonomousContinueGuard();
+
       const plan = crewStore.getPlan(cwd);
       if (ctx.hasUI) {
         if (allDone) {
@@ -992,6 +1044,26 @@ Usage (action-based API - preferred):
       return;
     }
 
+    const continueSignature = `${cwd}:${autonomousState.waveNumber}:${readyTasks.map(task => task.id).sort().join(",")}`;
+    const continueRepeatCount = trackAutonomousContinue(continueSignature);
+    if (continueRepeatCount >= AUTONOMOUS_CONTINUE_REPEAT_LIMIT) {
+      stopAutonomous("manual");
+      pi.appendEntry("crew-state", autonomousState);
+      resetAutonomousContinueGuard();
+
+      const plan = crewStore.getPlan(cwd);
+      const message = `Autonomous work on ${plan?.prd ?? "plan"} stopped after ${continueRepeatCount} repeated continuation retries without wave progress. Resolve the abort condition, then run pi_messenger({ action: "work", autonomous: true }).`;
+      if (ctx.hasUI) {
+        ctx.ui.notify(message, "warning");
+      }
+      pi.sendMessage({
+        customType: "crew_continue_stopped",
+        content: message,
+        display: true,
+      });
+      return;
+    }
+
     // Continue to next wave
     // Note: waveNumber was already incremented by addWaveResult() in work.ts
     const plan = crewStore.getPlan(cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-messenger",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Inter-agent messaging and file reservation system for pi coding agent",
   "type": "module",
   "author": "Nico Bailon",