pi-messenger 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [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:
 
@@ -332,7 +334,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/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/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.1",
   "description": "Inter-agent messaging and file reservation system for pi coding agent",
   "type": "module",
   "author": "Nico Bailon",