pi-messenger 0.13.1 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.14.0] - 2026-04-03
+
+### Added
+- **`leave` action** — `pi_messenger({ action: "leave" })` now lets the current session leave the mesh without restarting pi. It releases reservations, auto-unclaims the session's active swarm claim, closes the messenger overlay, and allows later rejoin from the same session.
+
+### Fixed
+- **Leave guardrails for Crew state** — `leave` now refuses while project planning, autonomous work, or session-owned in-progress Crew tasks are still active, preventing stranded coordination state.
+- **Immutable-session cwd handling** — Registration, folder scoping, auto-register path matching, and messenger context now follow the live session cwd after pi runtime/session replacement instead of relying on `process.cwd()`.
+
+## [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

@@ -47,6 +47,7 @@ pi_messenger({ action: "join" })
 pi_messenger({ action: "reserve", paths: ["src/auth/"], reason: "Refactoring" })
 pi_messenger({ action: "send", to: "GoldFalcon", message: "auth is done" })
 pi_messenger({ action: "release" })
+pi_messenger({ action: "leave" })
 ```
 
 For multi-agent task orchestration from a PRD:
@@ -67,7 +68,7 @@ pi_messenger({ action: "review", target: "task-1" })    // Reviewer checks imple
 
 **Messaging** - Send messages between agents. Recipients wake up immediately and see the message as a steering prompt.
 
-**File Reservations** - Claim files or directories. Other agents get blocked with a clear message telling them who to coordinate with. Auto-releases on exit.
+**File Reservations** - Claim files or directories. Other agents get blocked with a clear message telling them who to coordinate with. Auto-releases on `leave` or exit.
 
 **Stuck Detection** - Agents idle too long with an open task or reservation are flagged as stuck. Peers get a notification.
 
@@ -251,6 +252,7 @@ Agent definitions live in `crew/agents/` within the extension. To customize one
 | Action | Description |
 |--------|-------------|
 | `join` | Join the agent mesh |
+| `leave` | Leave the mesh for the current session |
 | `list` | List agents with presence info |
 | `status` | Show your status or crew progress |
 | `whois` | Detailed info about an agent (`name` required) |
@@ -268,6 +270,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;
@@ -77,6 +77,9 @@ export async function executeCrewAction(
     case 'status':
       return handlers.executeStatus(state, dirs, ctx.cwd ?? process.cwd());
 
+    case 'leave':
+      return handlers.executeLeave(state, dirs, ctx);
+
     case 'list':
       return handlers.executeList(state, dirs, ctx.cwd ?? process.cwd(), { stuckThreshold: config?.stuckThreshold });
 
@@ -180,6 +183,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/handlers.ts

@@ -26,6 +26,7 @@ import * as store from "./store.js";
 import * as crewStore from "./crew/store.js";
 import { getAutoRegisterPaths, saveAutoRegisterPaths, matchesAutoRegisterPath } from "./config.js";
 import { readFeedEvents, logFeedEvent, pruneFeed, formatFeedLine, isCrewEvent, type FeedEvent } from "./feed.js";
+import { isAutonomousForCwd, isPlanningForCwd } from "./crew/state.js";
 import { loadCrewConfig } from "./crew/utils/config.js";
 
 let messagesSentThisSession = 0;
@@ -127,6 +128,118 @@ export function executeJoin(
   });
 }
 
+export async function executeLeave(
+  state: MessengerState,
+  dirs: Dirs,
+  ctx: ExtensionContext,
+) {
+  if (!state.registered) {
+    return notRegisteredError();
+  }
+
+  const cwd = ctx.cwd ?? process.cwd();
+
+  if (isPlanningForCwd(cwd)) {
+    return result(
+      "Cannot leave while Crew planning is active for this project. Cancel it first with pi_messenger({ action: \"plan.cancel\" }).",
+      { mode: "leave", error: "planning_active" }
+    );
+  }
+
+  if (isAutonomousForCwd(cwd)) {
+    return result(
+      "Cannot leave while autonomous Crew work is active for this project. Stop it first with pi_messenger({ action: \"work.stop\" }).",
+      { mode: "leave", error: "autonomous_active" }
+    );
+  }
+
+  const inProgressTasks = crewStore
+    .getTasks(cwd)
+    .filter(task => task.status === "in_progress" && task.assigned_to === state.agentName)
+    .map(task => task.id);
+
+  if (inProgressTasks.length > 0) {
+    return result(
+      `Cannot leave while Crew task${inProgressTasks.length === 1 ? "" : "s"} assigned to you ${inProgressTasks.length === 1 ? "is" : "are"} still in progress: ${inProgressTasks.join(", ")}. Finish, block, or reset ${inProgressTasks.length === 1 ? "it" : "them"} first.`,
+      { mode: "leave", error: "crew_tasks_in_progress", taskIds: inProgressTasks }
+    );
+  }
+
+  const activeClaim = store.getAgentCurrentClaim(dirs, state.agentName);
+  let releasedClaim: { spec: string; taskId: string; reason?: string } | undefined;
+  if (activeClaim) {
+    const claimDisplay = displaySpecPath(activeClaim.spec, cwd);
+    try {
+      const unclaimResult = await store.unclaimTask(dirs, activeClaim.spec, activeClaim.taskId, state.agentName);
+      if (!store.isUnclaimSuccess(unclaimResult)) {
+        return result(
+          `Cannot leave because the active swarm claim ${activeClaim.taskId} in ${claimDisplay} could not be released. Resolve it first and retry.`,
+          {
+            mode: "leave",
+            error: unclaimResult.error,
+            activeClaim: { ...activeClaim, spec: claimDisplay },
+            ...(store.isUnclaimNotYours(unclaimResult) ? { claimedBy: unclaimResult.claimedBy } : {}),
+          }
+        );
+      }
+      releasedClaim = activeClaim;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return result(
+        `Cannot leave because the active swarm claim ${activeClaim.taskId} in ${claimDisplay} could not be released: ${message}`,
+        {
+          mode: "leave",
+          error: "unclaim_failed",
+          message,
+          activeClaim: { ...activeClaim, spec: claimDisplay },
+        }
+      );
+    }
+  }
+
+  const releasedReservations = state.reservations.map(r => r.pattern);
+  state.reservations = [];
+  store.updateRegistration(state, dirs, ctx);
+  for (const pattern of releasedReservations) {
+    logFeedEvent(cwd, state.agentName, "release", pattern);
+  }
+
+  try {
+    store.unregister(state, dirs);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return result(
+      `Could not leave pi-messenger: ${message}`,
+      { mode: "leave", error: "unregister_failed", message }
+    );
+  }
+
+  logFeedEvent(cwd, state.agentName, "leave");
+  store.stopWatcher(state);
+
+  if (ctx.hasUI) {
+    ctx.ui.setStatus("messenger", undefined);
+  }
+
+  const claimText = releasedClaim
+    ? `\nReleased claim: ${releasedClaim.taskId} in ${displaySpecPath(releasedClaim.spec, cwd)}`
+    : "";
+
+  return result(
+    `Left pi-messenger.${releasedReservations.length > 0 ? `\nReleased reservations: ${releasedReservations.join(", ")}` : ""}${claimText}`,
+    {
+      mode: "leave",
+      releasedReservations,
+      releasedClaim: releasedClaim
+        ? {
+            ...releasedClaim,
+            spec: displaySpecPath(releasedClaim.spec, cwd),
+          }
+        : undefined,
+    }
+  );
+}
+
 export function executeStatus(state: MessengerState, dirs: Dirs, cwd: string = process.cwd()) {
   if (!state.registered) {
     return notRegisteredError();

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";
@@ -79,7 +80,7 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
   // State & Configuration
   // ===========================================================================
 
-  const config: MessengerConfig = loadConfig(process.cwd());
+  let config: MessengerConfig = loadConfig(process.cwd());
 
   const state: MessengerState = {
     agentName: process.env.PI_AGENT_NAME || "",
@@ -94,6 +95,7 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
     broadcastHistory: [],
     seenSenders: new Map(),
     model: "",
+    cwd: process.cwd(),
     gitBranch: undefined,
     spec: undefined,
     scopeToFolder: config.scopeToFolder,
@@ -295,6 +297,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;
@@ -318,7 +338,7 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
   // ===========================================================================
 
   function sendRegistrationContext(ctx: ExtensionContext): void {
-    const folder = extractFolder(process.cwd());
+    const folder = extractFolder(ctx.cwd ?? state.cwd);
     const locationPart = state.gitBranch
       ? `${folder} on ${state.gitBranch}`
       : folder;
@@ -341,6 +361,7 @@ export default function piMessengerExtension(pi: ExtensionAPI) {
 Usage (action-based API - preferred):
   // Coordination
   pi_messenger({ action: "join" })                              → Join mesh
+  pi_messenger({ action: "leave" })                             → Leave mesh for this session
   pi_messenger({ action: "status" })                            → Get status
   pi_messenger({ action: "list" })                              → List agents with presence
   pi_messenger({ action: "feed", limit: 20 })                   → Activity feed
@@ -358,6 +379,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
@@ -448,6 +470,13 @@ Usage (action-based API - preferred):
         sendRegistrationContext(ctx);
       }
 
+      if (action === "leave" && !state.registered) {
+        overlayHandle?.hide();
+        overlayHandle = null;
+        overlayTui = null;
+        overlayOpening = false;
+      }
+
       return result;
     }
   });
@@ -749,13 +778,19 @@ Usage (action-based API - preferred):
 
   pi.on("session_start", async (_event, ctx) => {
     latestCtx = ctx;
+    state.cwd = ctx.cwd ?? process.cwd();
+    config = loadConfig(state.cwd);
+    state.scopeToFolder = config.scopeToFolder;
+    nameTheme.theme = config.nameTheme;
+    nameTheme.customWords = config.nameWords;
+    resetAutonomousContinueGuard();
     startStatusHeartbeat();
     for (const entry of ctx.sessionManager.getEntries()) {
       if (entry.type === "custom" && entry.customType === "crew-state") {
         restoreAutonomousState(entry.data as Parameters<typeof restoreAutonomousState>[0]);
       }
     }
-    const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
+    const { staleCleared } = restorePlanningState(state.cwd);
     if (staleCleared && ctx.hasUI) {
       ctx.ui.notify("Stale planning state cleared (planner process exited)", "warning");
     }
@@ -764,7 +799,7 @@ Usage (action-based API - preferred):
     try { fs.rmSync(join(homedir(), ".pi/agent/messenger/feed.jsonl"), { force: true }); } catch {}
 
     const shouldAutoRegister = config.autoRegister || 
-      matchesAutoRegisterPath(process.cwd(), config.autoRegisterPaths);
+      matchesAutoRegisterPath(state.cwd, config.autoRegisterPaths);
 
     if (!shouldAutoRegister) {
       maybeAutoOpenCrewOverlay(ctx);
@@ -772,7 +807,7 @@ Usage (action-based API - preferred):
     }
 
     if (store.register(state, dirs, ctx, nameTheme)) {
-      const cwd = ctx.cwd ?? process.cwd();
+      const cwd = state.cwd;
       store.startWatcher(state, dirs, deliverMessage);
       updateStatus(ctx);
       pruneFeed(cwd, config.feedRetention);
@@ -868,26 +903,6 @@ Usage (action-based API - preferred):
     });
   }
 
-  pi.on("session_switch", async (_event, ctx) => {
-    latestCtx = ctx;
-    const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
-    if (staleCleared && ctx.hasUI) {
-      ctx.ui.notify("Stale planning state cleared (planner process exited)", "warning");
-    }
-    recoverWatcherIfNeeded();
-    updateStatus(ctx);
-    maybeAutoOpenCrewOverlay(ctx);
-  });
-  pi.on("session_fork", async (_event, ctx) => {
-    latestCtx = ctx;
-    const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
-    if (staleCleared && ctx.hasUI) {
-      ctx.ui.notify("Stale planning state cleared (planner process exited)", "warning");
-    }
-    recoverWatcherIfNeeded();
-    updateStatus(ctx);
-    maybeAutoOpenCrewOverlay(ctx);
-  });
   pi.on("session_tree", async (_event, ctx) => {
     latestCtx = ctx;
     const { staleCleared } = restorePlanningState(ctx.cwd ?? process.cwd());
@@ -936,6 +951,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 +986,26 @@ Usage (action-based API - preferred):
     }
 
     // --- Existing autonomous continuation ---
-    if (!autonomousState.active) return;
+    if (!autonomousState.active) {
+      resetAutonomousContinueGuard();
+      return;
+    }
+
+    const currentCwd = ctx.cwd ?? process.cwd();
+    if (!isAutonomousForCwd(currentCwd)) {
+      resetAutonomousContinueGuard();
+      return;
+    }
 
-    const cwd = autonomousState.cwd ?? ctx.cwd ?? process.cwd();
+    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 +1014,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 +1036,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);
@@ -1029,7 +1093,12 @@ Usage (action-based API - preferred):
     if (recentTestTimer) { clearTimeout(recentTestTimer); recentTestTimer = null; }
     if (recentEditTimer) { clearTimeout(recentEditTimer); recentEditTimer = null; }
     store.stopWatcher(state);
-    store.unregister(state, dirs);
+    try {
+      store.unregister(state, dirs);
+    } catch {
+      // Safe to ignore during shutdown: the process is exiting, so any leftover
+      // registration will be cleaned up as stale on the next registry read.
+    }
   });
 
   // ===========================================================================

package/lib.ts

@@ -73,6 +73,7 @@ export interface MessengerState {
   broadcastHistory: AgentMailMessage[];
   seenSenders: Map<string, string>;
   model: string;
+  cwd: string;
   gitBranch?: string;
   spec?: string;
   scopeToFolder: boolean;
@@ -388,8 +389,8 @@ export function buildSelfRegistration(state: MessengerState): AgentRegistration
     name: state.agentName,
     pid: process.pid,
     sessionId: "",
-    cwd: process.cwd(),
     model: state.model,
+    cwd: state.cwd,
     startedAt: state.sessionStartedAt,
     gitBranch: state.gitBranch,
     spec: state.spec,

package/package.json

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

package/skills/pi-messenger-crew/SKILL.md

@@ -9,9 +9,10 @@ Use pi-messenger for multi-agent coordination and Crew task orchestration.
 
 ## Quick Reference
 
-### Join the Mesh (Required First)
+### Join or Leave the Mesh
 ```typescript
 pi_messenger({ action: "join" })
+pi_messenger({ action: "leave" })
 ```
 
 ### Check Status

package/store.ts

@@ -167,7 +167,7 @@ export function getRegistrationPath(state: MessengerState, dirs: Dirs): string {
 export function getActiveAgents(state: MessengerState, dirs: Dirs): AgentRegistration[] {
   const now = Date.now();
   const excludeName = state.agentName;
-  const myCwd = normalizeCwd(process.cwd());
+  const myCwd = normalizeCwd(state.cwd);
   const scopeToFolder = state.scopeToFolder;
 
   // Cache key includes scopeToFolder and cwd for proper cache invalidation
@@ -339,7 +339,7 @@ export function register(state: MessengerState, dirs: Dirs, ctx: ExtensionContex
 
     ensureDirSync(getMyInbox(state, dirs));
 
-    const cwd = normalizeCwd(process.cwd());
+    const cwd = normalizeCwd(ctx.cwd ?? process.cwd());
     const gitBranch = getGitBranch(cwd);
     const now = new Date().toISOString();
     const registration: AgentRegistration = {
@@ -378,6 +378,7 @@ export function register(state: MessengerState, dirs: Dirs, ctx: ExtensionContex
     if (verified) {
       state.registered = true;
       state.model = ctx.model?.id ?? "unknown";
+      state.cwd = cwd;
       state.gitBranch = gitBranch;
       state.activity.lastActivityAt = now;
       invalidateAgentsCache();
@@ -426,6 +427,7 @@ export function updateRegistration(state: MessengerState, dirs: Dirs, ctx: Exten
     const currentModel = ctx.model?.id ?? reg.model;
     reg.model = currentModel;
     state.model = currentModel;
+    reg.cwd = state.cwd;
     reg.reservations = state.reservations.length > 0 ? state.reservations : undefined;
     if (state.spec) {
       reg.spec = state.spec;
@@ -452,6 +454,7 @@ export function flushActivityToRegistry(state: MessengerState, dirs: Dirs, ctx:
     const currentModel = ctx.model?.id ?? reg.model;
     reg.model = currentModel;
     state.model = currentModel;
+    reg.cwd = state.cwd;
     reg.session = { ...state.session };
     reg.activity = { ...state.activity };
     reg.statusMessage = state.statusMessage;
@@ -464,11 +467,15 @@ export function flushActivityToRegistry(state: MessengerState, dirs: Dirs, ctx:
 export function unregister(state: MessengerState, dirs: Dirs): void {
   if (!state.registered) return;
 
+  const regPath = getRegistrationPath(state, dirs);
   try {
-    fs.unlinkSync(getRegistrationPath(state, dirs));
-  } catch {
-    // Ignore errors
+    fs.unlinkSync(regPath);
+  } catch (error) {
+    if (fs.existsSync(regPath)) {
+      throw error;
+    }
   }
+
   state.registered = false;
   invalidateAgentsCache();
 }
@@ -515,7 +522,7 @@ export function renameAgent(
 
   processAllPendingMessages(state, dirs, deliverFn);
 
-  const cwd = normalizeCwd(process.cwd());
+  const cwd = normalizeCwd(ctx.cwd ?? process.cwd());
   const gitBranch = getGitBranch(cwd);
   const now = new Date().toISOString();
   const registration: AgentRegistration = {
@@ -598,6 +605,7 @@ export function renameAgent(
   }
 
   state.model = ctx.model?.id ?? "unknown";
+  state.cwd = cwd;
   state.gitBranch = gitBranch;
   state.sessionStartedAt = now;
   state.activity.lastActivityAt = now;