pi-messenger 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # 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
+- **Auto-review after task completion** — Workers' completed tasks now get an automatic reviewer pass before being counted as done. Controlled by existing `config.review.enabled` (default: true) and `config.review.maxIterations` (default: 3). SHIP keeps the task done, NEEDS_WORK resets it to todo for retry with review feedback injected into the next worker's prompt, MAJOR_RETHINK blocks the task. Reviews run sequentially between worker completion and wave result reporting, and respect the abort signal. Adds `review_count` to the Task interface and `task.review` to the activity feed.
+
 ## [0.13.0] - 2026-03-02
 
 ### Added

package/README.md

@@ -92,11 +92,13 @@ Chat input supports `@Name msg` for DMs and `@all msg` for broadcasts. Text with
 
 Crew turns a PRD into a dependency graph of tasks, then executes them in parallel waves.
 
+Crew logs are per project, under that project's working directory: `.pi/messenger/crew/`. For example, if you run Crew from `/path/to/my-app`, the planner log lives at `/path/to/my-app/.pi/messenger/crew/planning-progress.md`.
+
 ### Workflow
 
 1. **Plan** — Planner explores the codebase and PRD, drafts tasks with dependencies. A reviewer checks the plan; the planner refines until SHIP or `maxPasses` is reached. History is stored in `planning-progress.md`.
-2. **Work** — Workers implement ready tasks (all dependencies met) in parallel waves. A single `work` call runs one wave. `autonomous: true` runs waves back-to-back until everything is done or blocked.
-3. **Review** — Reviewer checks each implementation: SHIP, NEEDS_WORK, or MAJOR_RETHINK.
+2. **Work** — Workers implement ready tasks (all dependencies met) in parallel waves. A single `work` call runs one wave. `autonomous: true` runs waves back-to-back until everything is done or blocked. Each completed task gets an automatic reviewer pass — SHIP keeps it done, NEEDS_WORK resets it for retry with feedback, MAJOR_RETHINK blocks it. Controlled by `review.enabled` and `review.maxIterations`.
+3. **Review** — Manual review of a specific task or the plan: `pi_messenger({ action: "review", target: "task-1" })`. Returns SHIP, NEEDS_WORK, or MAJOR_RETHINK with detailed feedback.
 
 No special PRD format required — the planner auto-discovers `PRD.md`, `SPEC.md`, `DESIGN.md`, etc. in your project root and `docs/`. Or skip the file entirely:
 
@@ -266,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) |
@@ -332,7 +335,7 @@ Incoming messages wake the receiving agent via `pi.sendMessage()` with `triggerT
 
 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. Shared state (registry, inboxes, swarm claims/completions) lives in `~/.pi/agent/messenger/`. Activity feed and crew data are project-scoped under `.pi/messenger/` inside your project. Dead agents are detected via PID checks and cleaned up automatically.
+All coordination is file-based, no daemon required. Shared state (registry, inboxes, swarm claims/completions) lives in `~/.pi/agent/messenger/`. Activity feed and crew data are project-scoped under `.pi/messenger/` inside your project, so Crew logs live at `<project>/.pi/messenger/crew/` and the shared activity feed lives at `<project>/.pi/messenger/feed.jsonl`. Dead agents are detected via PID checks and cleaned up automatically.
 
 ## Credits
 

package/crew/handlers/review.ts

@@ -55,7 +55,7 @@ export async function execute(
 // Implementation Review
 // =============================================================================
 
-async function reviewImplementation(cwd: string, taskId: string, modelOverride?: string) {
+export async function reviewImplementation(cwd: string, taskId: string, modelOverride?: string) {
   const task = store.getTask(cwd, taskId);
   if (!task) {
     return result(`Error: Task ${taskId} not found.`, {

package/crew/handlers/work.ts

@@ -13,6 +13,7 @@ import { resolveModel, spawnAgents } from "../agents.js";
 import { loadCrewConfig } from "../utils/config.js";
 import { discoverCrewAgents, discoverCrewSkills } from "../utils/discover.js";
 import { buildWorkerPrompt } from "../prompt.js";
+import { reviewImplementation } from "./review.js";
 import * as store from "../store.js";
 import { getCrewDir } from "../store.js";
 import { autonomousState, isAutonomousForCwd, startAutonomous, stopAutonomous, addWaveResult, clampConcurrency } from "../state.js";
@@ -220,6 +221,48 @@ export async function execute(
     }
   }
 
+  // Auto-review succeeded tasks
+  if (config.review.enabled && succeeded.length > 0) {
+    const hasReviewer = availableAgents.some(a => a.name === "crew-reviewer");
+    if (hasReviewer) {
+      for (const taskId of [...succeeded]) {
+        if (signal?.aborted) break;
+        const task = store.getTask(cwd, taskId);
+        if (!task || !task.base_commit) continue;
+        if ((task.review_count ?? 0) >= config.review.maxIterations) continue;
+
+        const rr = await reviewImplementation(cwd, taskId, config.models?.reviewer);
+        const verdict = rr.details?.verdict as string | undefined;
+        if (!verdict) {
+          store.appendTaskProgress(cwd, taskId, "system",
+            `Auto-review skipped: ${rr.details?.error ?? "unknown"}`);
+          continue;
+        }
+
+        const reviewCount = (task.review_count ?? 0) + 1;
+        store.updateTask(cwd, taskId, { review_count: reviewCount });
+
+        if (verdict === "SHIP") {
+          logFeedEvent(cwd, "crew", "task.review", taskId, "SHIP");
+        } else if (verdict === "NEEDS_WORK") {
+          store.resetTask(cwd, taskId);
+          logFeedEvent(cwd, "crew", "task.review", taskId, "NEEDS_WORK — reset for retry");
+          succeeded.splice(succeeded.indexOf(taskId), 1);
+          failed.push(taskId);
+        } else {
+          const lastReview = store.getTask(cwd, taskId)?.last_review;
+          const summary = lastReview?.summary
+            ? lastReview.summary.split("\n")[0].slice(0, 120)
+            : "Major issues found";
+          store.blockTask(cwd, taskId, `Reviewer: ${summary}`);
+          logFeedEvent(cwd, "crew", "task.review", taskId, "MAJOR_RETHINK — blocked");
+          succeeded.splice(succeeded.indexOf(taskId), 1);
+          blocked.push(taskId);
+        }
+      }
+    }
+  }
+
   syncCompletedCount(cwd);
 
   // Save current wave number BEFORE addWaveResult increments it
@@ -327,4 +370,3 @@ function syncCompletedCount(cwd: string): void {
     store.updatePlan(cwd, { completed_count: doneCount });
   }
 }
-

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/crew/types.ts

@@ -51,6 +51,7 @@ export interface Task {
   evidence?: TaskEvidence;       // Evidence from task.done
   blocked_reason?: string;       // Reason from task.block
   attempt_count: number;         // How many times attempted (for auto-block)
+  review_count?: number;         // How many times reviewed
   last_review?: ReviewFeedback;  // Feedback from last review (for retry)
 }
 

package/feed.ts

@@ -18,6 +18,7 @@ export type FeedEventType =
   | "edit"
   | "task.start"
   | "task.done"
+  | "task.review"
   | "task.block"
   | "task.unblock"
   | "task.reset"
@@ -128,6 +129,7 @@ export function pruneFeed(cwd: string, maxEvents: number): void {
 const CREW_EVENT_TYPES = new Set<FeedEventType>([
   "task.start",
   "task.done",
+  "task.review",
   "task.block",
   "task.unblock",
   "task.reset",
@@ -182,6 +184,7 @@ export function formatFeedLine(event: FeedEvent): string {
     case "edit": line += ` editing ${target}`; break;
     case "task.start": line += withPreview(` started ${target}`); break;
     case "task.done": line += withPreview(` completed ${target}`); break;
+    case "task.review": line += withPreview(` reviewed ${target}`); break;
     case "task.block": line += withPreview(` blocked ${target}`); break;
     case "task.unblock": line += withPreview(` unblocked ${target}`); break;
     case "task.reset": line += withPreview(` reset ${target}`); break;

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/overlay-coordinator.ts

@@ -0,0 +1,150 @@
+import type { OverlayHandle, TUI } from "@mariozechner/pi-tui";
+
+const QUIET_PERIOD_MS = 80;
+const RENDER_THROTTLE_MS = 32;
+const STDOUT_GUARD_MS = 32;
+
+type StdoutWrite = typeof process.stdout.write;
+
+function hasRenderableOutput(chunk: unknown): boolean {
+  if (typeof chunk === "string") return chunk.length > 0;
+  if (chunk instanceof Uint8Array) return chunk.length > 0;
+  return false;
+}
+
+/**
+ * Coordinates overlay rendering with main agent stdout to prevent visual collision.
+ * 
+ * Strategy: Keep overlay visible, but schedule a "repair" render after foreign
+ * output settles. Brief visual corruption is acceptable if it self-heals quickly.
+ */
+export class OverlayRenderCoordinator {
+  private tui: TUI | null = null;
+  private handle: OverlayHandle | null = null;
+  private originalRequestRender: TUI["requestRender"] | null = null;
+  private originalStdoutWrite: StdoutWrite | null = null;
+  private repairTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastRenderAt = 0;
+  private stdoutGuardUntil = 0;
+  private foreignOutputDetected = false;
+
+  installStdoutInterceptor(): void {
+    if (this.originalStdoutWrite) return;
+
+    const original = process.stdout.write.bind(process.stdout) as StdoutWrite;
+    this.originalStdoutWrite = original;
+
+    const coordinator = this;
+    (process.stdout.write as StdoutWrite) = function writeIntercept(
+      chunk: Parameters<StdoutWrite>[0],
+      ...args: Parameters<StdoutWrite> extends [unknown, ...infer Rest] ? Rest : never
+    ) {
+      const result = original(chunk, ...args);
+      coordinator.handleStdoutWrite(chunk);
+      return result;
+    } as StdoutWrite;
+  }
+
+  uninstallStdoutInterceptor(): void {
+    if (!this.originalStdoutWrite) return;
+    (process.stdout.write as StdoutWrite) = this.originalStdoutWrite;
+    this.originalStdoutWrite = null;
+  }
+
+  attach(tui: TUI): void {
+    if (this.tui === tui && this.originalRequestRender) return;
+
+    this.detach();
+    this.tui = tui;
+    this.originalRequestRender = tui.requestRender.bind(tui);
+    tui.requestRender = ((force?: boolean) => {
+      this.requestRender(force);
+    }) as TUI["requestRender"];
+  }
+
+  setHandle(handle: OverlayHandle | null): void {
+    this.handle = handle;
+  }
+
+  detach(): void {
+    if (this.repairTimer) {
+      clearTimeout(this.repairTimer);
+      this.repairTimer = null;
+    }
+    if (this.tui && this.originalRequestRender) {
+      this.tui.requestRender = this.originalRequestRender;
+    }
+    this.tui = null;
+    this.handle = null;
+    this.originalRequestRender = null;
+    this.lastRenderAt = 0;
+    this.stdoutGuardUntil = 0;
+    this.foreignOutputDetected = false;
+  }
+
+  dispose(): void {
+    this.detach();
+    this.uninstallStdoutInterceptor();
+  }
+
+  /** Called by hooks when main agent activity is expected */
+  noteForegroundActivity(): void {
+    if (!this.tui || !this.handle) return;
+    if (this.handle.isHidden()) return;
+
+    this.foreignOutputDetected = true;
+    this.scheduleRepair();
+  }
+
+  private handleStdoutWrite(chunk: unknown): void {
+    if (!this.tui || !this.handle) return;
+    if (!hasRenderableOutput(chunk)) return;
+    if (Date.now() <= this.stdoutGuardUntil) return;
+    if (this.handle.isHidden()) return;
+
+    this.foreignOutputDetected = true;
+    this.scheduleRepair();
+  }
+
+  private scheduleRepair(): void {
+    if (this.repairTimer) clearTimeout(this.repairTimer);
+    this.repairTimer = setTimeout(() => {
+      this.repairTimer = null;
+      this.repair();
+    }, QUIET_PERIOD_MS);
+  }
+
+  private repair(): void {
+    if (!this.tui || !this.handle) return;
+    if (this.handle.isHidden()) return;
+    if (!this.foreignOutputDetected) return;
+
+    this.foreignOutputDetected = false;
+    this.flushRender(true);
+  }
+
+  requestRender(force = false): void {
+    if (!this.originalRequestRender) return;
+    if (this.handle?.isHidden()) return;
+
+    const now = Date.now();
+    if (!force) {
+      const elapsed = now - this.lastRenderAt;
+      if (elapsed < RENDER_THROTTLE_MS) {
+        // Skip this render, repair timer will catch up
+        return;
+      }
+    }
+
+    this.flushRender(force);
+  }
+
+  private flushRender(force: boolean): void {
+    if (!this.originalRequestRender) return;
+    if (this.handle?.isHidden()) return;
+
+    this.lastRenderAt = Date.now();
+    this.stdoutGuardUntil = this.lastRenderAt + STDOUT_GUARD_MS;
+    this.originalRequestRender(force);
+  }
+}

package/package.json

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