pi-harness-runtime 1.1.95 → 1.1.97

package/packages/write-review/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwEH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IAC1B,MAAM,EAAE,QAAQ,EAAE,oCAAoC;IACtD,QAAQ,EAAE,UAAU,EAAE,gCAAgC;IACtD,MAAM,EAAE,QAAQ,EAAE,+BAA+B;CACxC,CAAC;AAIX;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,KAAkB;IACjD,OAAO,KAAK,KAAK,UAAU,IAAI,KAAK,KAAK,SAAS,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAkB;IAC7C,OAAO,KAAK,KAAK,gBAAgB,IAAI,KAAK,KAAK,WAAW,CAAC;AAC5D,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAkB;IAC1C,OAAO,CACN,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,mBAAmB,CACxE,CAAC;AACH,CAAC"}

package/packages/write-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/write-review",
-  "version": "1.1.95",
+  "version": "1.1.97",
   "description": "Two-agent write-review loop with blackboard coordination",
   "type": "module",
   "main": "src/index.ts",

package/packages/write-review/src/event-bus.ts

@@ -0,0 +1,351 @@
+/**
+ * Ping-Pong Event Bus
+ * 
+ * Lightweight event bus for two-agent coordination.
+ * Watches blackboard status.json for state changes.
+ * Emits events and notifies agents via ExtensionAPI.
+ * 
+ * NO AI NEEDED - deterministic file watching + state machine.
+ */
+
+import { existsSync, readFileSync, watch } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Ping-Pong Events
+ */
+export enum PingPongEvent {
+  SESSION_STARTED = "session_started",
+  WRITING_STARTED = "writing_started",
+  WRITER_DONE = "writer_done",
+  REVIEW_NEEDED = "review_needed",
+  REVIEW_STARTED = "review_started",
+  REVIEW_COMPLETE = "review_complete",
+  APPROVED = "approved",
+  CHANGES_REQUESTED = "changes_requested",
+  BLOCKED = "blocked",
+  SESSION_ENDED = "session_ended",
+}
+
+/**
+ * Event payload
+ */
+export interface PingPongEventPayload {
+  event: PingPongEvent;
+  phase: string;
+  iteration: number;
+  timestamp: string;
+  data?: Record<string, unknown>;
+}
+
+/**
+ * Event listener callback
+ */
+export type PingPongListener = (payload: PingPongEventPayload) => void | Promise<void>;
+
+/**
+ * Phase to event mapping
+ */
+const PHASE_TO_EVENT: Record<string, PingPongEvent> = {
+  idle: PingPongEvent.SESSION_STARTED,
+  writing: PingPongEvent.WRITING_STARTED,
+  pending_review: PingPongEvent.REVIEW_NEEDED,
+  reviewing: PingPongEvent.REVIEW_STARTED,
+  approved: PingPongEvent.APPROVED,
+  blocked: PingPongEvent.BLOCKED,
+  changes_requested: PingPongEvent.CHANGES_REQUESTED,
+};
+
+/**
+ * Simple Event Bus for ping-pong coordination
+ */
+export class PingPongEventBus {
+  private listeners: Map<PingPongEvent, Set<PingPongListener>> = new Map();
+  private watchers: Map<string, ReturnType<typeof watch>> = new Map();
+  private lastStatusHash: string | null = null;
+  private pi: ExtensionAPI | null = null;
+  private projectPath: string | null = null;
+
+  /**
+   * Register an event listener
+   */
+  on(event: PingPongEvent, listener: PingPongListener): () => void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event)!.add(listener);
+    
+    // Return unsubscribe function
+    return () => {
+      this.listeners.get(event)?.delete(listener);
+    };
+  }
+
+  /**
+   * Register a listener for all events
+   */
+  onAny(listener: PingPongListener): () => void {
+    const wrappedListener = (payload: PingPongEventPayload) => {
+      return listener(payload);
+    };
+    
+    // Listen to all events
+    for (const event of Object.values(PingPongEvent)) {
+      this.on(event, wrappedListener);
+    }
+    
+    // Return unsubscribe for all
+    return () => {
+      for (const event of Object.values(PingPongEvent)) {
+        this.listeners.get(event)?.delete(wrappedListener);
+      }
+    };
+  }
+
+  /**
+   * Emit an event
+   */
+  private emit(event: PingPongEvent, payload: Omit<PingPongEventPayload, "event">): void {
+    const fullPayload: PingPongEventPayload = {
+      event,
+      ...payload,
+    };
+
+    // Call specific listeners
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          const result = listener(fullPayload);
+          if (result instanceof Promise) {
+            result.catch((err) => {
+              console.error(`[PingPong] Listener error:`, err);
+            });
+          }
+        } catch (err) {
+          console.error(`[PingPong] Listener error:`, err);
+        }
+      }
+    }
+
+    // Notify via ExtensionAPI if available
+    if (this.pi) {
+      this.notifyAgents(fullPayload);
+    }
+
+    // Log for debugging
+    console.error(
+      `[PingPong] Event: ${event}, phase=${payload.phase}, iteration=${payload.iteration}`
+    );
+  }
+
+  /**
+   * Notify agents via ExtensionAPI
+   */
+  private notifyAgents(payload: PingPongEventPayload): void {
+    if (!this.pi) return;
+
+    const { event, phase, iteration } = payload;
+
+    // Map events to user-facing notifications
+    const messages: Record<PingPongEvent, string> = {
+      [PingPongEvent.SESSION_STARTED]: `Write-review session started`,
+      [PingPongEvent.WRITING_STARTED]: `Writer agent started (iteration ${iteration})`,
+      [PingPongEvent.WRITER_DONE]: `Writer done! Code ready for review`,
+      [PingPongEvent.REVIEW_NEEDED]: `Review needed - iteration ${iteration}`,
+      [PingPongEvent.REVIEW_STARTED]: `Reviewer agent started`,
+      [PingPongEvent.REVIEW_COMPLETE]: `Review complete - verdict: ${phase}`,
+      [PingPongEvent.APPROVED]: `APPROVED! Code ready to build/commit`,
+      [PingPongEvent.CHANGES_REQUESTED]: `Changes requested - iteration ${iteration}`,
+      [PingPongEvent.BLOCKED]: `BLOCKED - human intervention needed`,
+      [PingPongEvent.SESSION_ENDED]: `Write-review session ended`,
+    };
+
+    const message = messages[event];
+    if (message) {
+      const level = event === PingPongEvent.APPROVED 
+        ? "success" 
+        : event === PingPongEvent.BLOCKED 
+          ? "error" 
+          : "info";
+      
+      // Use ui.notify if available on ExtensionContext
+      try {
+        // SAFETY: ExtensionAPI doesn't export ui type, we access it via dynamic lookup
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ui = (this.pi as any)?.ui;
+        if (ui?.notify) {
+          ui.notify(message, level);
+        }
+      } catch {
+        // ExtensionAPI ui.notify not available
+      }
+    }
+  }
+
+  /**
+   * Start watching a blackboard status.json
+   */
+  startWatching(blackboardPath: string): void {
+    // Stop any existing watcher
+    this.stopWatching();
+
+    const statusPath = join(blackboardPath, "status.json");
+    this.projectPath = blackboardPath.replace("/.write-review", "");
+
+    if (!existsSync(statusPath)) {
+      console.error(`[PingPong] status.json not found at ${statusPath}`);
+      return;
+    }
+
+    // Read initial status
+    this.readAndEmit(statusPath);
+
+    // Watch for changes
+    try {
+      const watcher = watch(blackboardPath, { persistent: true }, (_eventType, filename) => {
+        if (filename === "status.json") {
+          this.readAndEmit(statusPath);
+        }
+      });
+
+      this.watchers.set(statusPath, watcher);
+      console.error(`[PingPong] Started watching ${blackboardPath}`);
+    } catch (err) {
+      console.error(`[PingPong] Failed to watch ${statusPath}:`, err);
+    }
+  }
+
+  /**
+   * Read status.json and emit events if changed
+   */
+  private readAndEmit(statusPath: string): void {
+    try {
+      const content = readFileSync(statusPath, "utf-8");
+      const status = JSON.parse(content);
+
+      // Check if status changed
+      const statusHash = JSON.stringify({
+        phase: status.phase,
+        writerDone: status.writerDone,
+        iteration: status.iteration,
+        verdict: status.verdict,
+      });
+
+      if (statusHash === this.lastStatusHash) {
+        return; // No change
+      }
+
+      const previousHash = this.lastStatusHash;
+      this.lastStatusHash = statusHash;
+
+      // Emit events based on phase transition
+      const phase = status.phase as string;
+      const iteration = status.iteration || 1;
+
+      // Detect writer done (was false, now true)
+      const wasWriterDone = previousHash ? previousHash.includes('"writerDone":true') : false;
+      if (status.writerDone && !wasWriterDone) {
+        this.emit(PingPongEvent.WRITER_DONE, {
+          phase,
+          iteration,
+          timestamp: new Date().toISOString(),
+          data: { writerMessage: status.writerMessage },
+        });
+      }
+
+      // Emit phase event
+      const event = PHASE_TO_EVENT[phase];
+      if (event) {
+        this.emit(event, {
+          phase,
+          iteration,
+          timestamp: new Date().toISOString(),
+          data: { verdict: status.verdict, verdictMessage: status.verdictMessage },
+        });
+      }
+
+    } catch (err) {
+      console.error(`[PingPong] Failed to read status.json:`, err);
+    }
+  }
+
+  /**
+   * Stop watching
+   */
+  stopWatching(): void {
+    for (const [path, watcher] of this.watchers) {
+      watcher.close();
+      this.watchers.delete(path);
+    }
+    console.error(`[PingPong] Stopped watching`);
+  }
+
+  /**
+   * Set ExtensionAPI for notifications
+   */
+  setExtensionAPI(pi: ExtensionAPI): void {
+    this.pi = pi;
+  }
+
+  /**
+   * Get current status hash
+   */
+  getLastStatusHash(): string | null {
+    return this.lastStatusHash;
+  }
+
+  /**
+   * Clean up
+   */
+  destroy(): void {
+    this.stopWatching();
+    this.listeners.clear();
+    this.pi = null;
+  }
+}
+
+// Singleton instance
+let globalEventBus: PingPongEventBus | null = null;
+
+/**
+ * Get global event bus instance
+ */
+export function getPingPongEventBus(): PingPongEventBus {
+  if (!globalEventBus) {
+    globalEventBus = new PingPongEventBus();
+  }
+  return globalEventBus;
+}
+
+/**
+ * Create a new event bus instance
+ */
+export function createPingPongEventBus(): PingPongEventBus {
+  return new PingPongEventBus();
+}
+
+/**
+ * Helper: Check if status changed from previous
+ */
+export function hasStatusChanged(
+  current: Record<string, unknown>,
+  previous: string | null
+): boolean {
+  const currentHash = JSON.stringify({
+    phase: current.phase,
+    writerDone: current.writerDone,
+    iteration: current.iteration,
+    verdict: current.verdict,
+  });
+
+  return currentHash !== previous;
+}
+
+/**
+ * Helper: Format event for logging
+ */
+export function formatPingPongEvent(event: PingPongEventPayload): string {
+  return `[PingPong:${event.event}] phase=${event.phase}, iteration=${event.iteration}, time=${event.timestamp}`;
+}

package/packages/write-review/src/index.ts

@@ -63,3 +63,4 @@ export * from "./trigger.js";
 export * from "./injection.js";
 export * from "./gate.js";
 export * from "./review.js";
+export * from "./event-bus.js";

package/packages/write-review/src/injection.ts

@@ -113,7 +113,9 @@ export function getWriteReviewHints(projectPath: string): {
  * Register write-review extension with pi
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { BeforeAgentStartEventResult } from "@earendil-works/pi-coding-agent";
 import { createBlackboard } from "./blackboard.js";
+import { getPingPongEventBus, PingPongEvent } from "./event-bus.js";
 
 export function injectWriterInstructions(
 	pi: ExtensionAPI,
@@ -123,8 +125,25 @@ export function injectWriterInstructions(
 	let blackboard: ReturnType<typeof createBlackboard> | null = null;
 	let hintsInjected = false;
 
+	// Initialize event bus with ExtensionAPI
+	const eventBus = getPingPongEventBus();
+	eventBus.setExtensionAPI(pi);
+
+	// Register event listeners for debugging
+	eventBus.on(PingPongEvent.WRITER_DONE, (payload) => {
+		if (config?.debug) {
+			console.log(`[write-review] Writer done: ${JSON.stringify(payload)}`);
+		}
+	});
+
+	eventBus.on(PingPongEvent.REVIEW_NEEDED, (payload) => {
+		if (config?.debug) {
+			console.log(`[write-review] Review needed: ${JSON.stringify(payload)}`);
+		}
+	});
+
 	// System prompt injection
-	pi.on("before_agent_start", async (event) => {
+	pi.on("before_agent_start", async (event): Promise<BeforeAgentStartEventResult | undefined> => {
 		const cwd = findProjectRoot(process.cwd?.() ?? "/");
 		if (cwd !== currentProject) {
 			currentProject = cwd;
@@ -135,9 +154,10 @@ export function injectWriterInstructions(
 		if (!hintsInjected && blackboard) {
 			const status = blackboard.load();
 			if (status && status.phase !== "idle") {
-				event.systemPrompt += formatWriteReviewHint(cwd);
+				let systemPrompt = event.systemPrompt;
+				systemPrompt += formatWriteReviewHint(cwd);
 				if (status.phase !== "approved") {
-					event.systemPrompt += formatReviewReminder(cwd);
+					systemPrompt += formatReviewReminder(cwd);
 				}
 				hintsInjected = true;
 				if (config?.debug) {
@@ -145,8 +165,10 @@ export function injectWriterInstructions(
 						`[write-review] Hints injected for ${cwd}, phase: ${status.phase}`,
 					);
 				}
+				return { systemPrompt };
 			}
 		}
+		return undefined;
 	});
 
 	// Build gate

package/proactive-compact.ts

@@ -7,7 +7,7 @@ export const MAX_PROACTIVE_COMPACT_FAILURES = 3;
 export const OUTPUT_LIMIT_AUTO_RESUME_LIMIT = 3;
 export const OUTPUT_LIMIT_RESUME_PROMPT =
 	"Output token limit hit. Resume directly — no apology, no recap. Pick up mid-thought if the cut happened there. Break remaining work into smaller pieces.";
-export const PROVIDER_OVERLOAD_AUTO_RESUME_LIMIT = 3;
+export const PROVIDER_OVERLOAD_AUTO_RESUME_LIMIT = 100;
 export const PROVIDER_OVERLOAD_AUTO_RESUME_MIN_MS = 60_000;
 export const PROVIDER_OVERLOAD_AUTO_RESUME_MAX_MS = 5 * 60_000;
 export const PROVIDER_OVERLOAD_RESUME_PROMPT = "resume";
@@ -104,6 +104,43 @@ export function shouldQueueOutputLimitResume(
 	);
 }
 
+/**
+ * Check if this is a FRESH 529 overload error (not a "Retry failed" report)
+ * Fresh errors should trigger retries; "Retry failed" messages should NOT.
+ */
+export function isFreshProviderOverloadError(
+	message: AssistantStopLike,
+): boolean {
+	if (message.role !== "assistant") {
+		return false;
+	}
+	const text = readAssistantStopText(message);
+	// Fresh overload: contains overload indicator + 529 code
+	const isFreshOverload =
+		text.includes("overloaded_error") ||
+		text.includes("peak-hour surge") ||
+		text.includes("temporarily busy") ||
+		text.includes("server is temporarily busy") ||
+		text.includes("try again shortly");
+	// But NOT if it's a "Retry failed" report (that means our retry already failed)
+	const isRetryFailedReport = /Retry failed after \d+ attempts:/i.test(text);
+	// Extract request_id for logging
+	const requestIdMatch = text.match(/request_id[^"]*"([^"]+)"/i) || text.match(/request_id[^"]*([a-f0-9]+)/i);
+	const requestId = requestIdMatch ? requestIdMatch[1] : "unknown";
+	if (isFreshOverload) {
+		console.error(
+			`[pi-harness] Fresh 529 detected (request=${requestId}), retry_failed_report=${isRetryFailedReport}`,
+		);
+	} else if (text.includes("529") || text.includes("overload")) {
+		console.error(`[pi-harness] 529-related but NOT fresh (stopReason or other): ${text.slice(0, 100)}`);
+	}
+	return isFreshOverload && !isRetryFailedReport;
+}
+
+/**
+ * Legacy check - returns true for BOTH fresh overloads AND "Retry failed" reports
+ * @deprecated Use isFreshProviderOverloadError for retry logic
+ */
 export function isProviderOverloadAssistantMessage(
 	message: AssistantStopLike,
 ): boolean {
@@ -111,7 +148,7 @@ export function isProviderOverloadAssistantMessage(
 		return false;
 	}
 
-	return /overloaded_error|peak-hour surge|temporarily busy|server is temporarily busy|try again shortly|Retry failed after \d+ attempts:.*529|\b529\b|\b2064\b/i.test(
+	return /overloaded_error|peak-hour surge|temporarily busy|server is temporarily busy|try again shortly|\b529\b|\b2064\b/i.test(
 		readAssistantStopText(message),
 	);
 }
@@ -124,11 +161,18 @@ export function shouldQueueProviderOverloadResume(
 ): boolean {
 	const maxAttempts =
 		options?.maxAttempts ?? PROVIDER_OVERLOAD_AUTO_RESUME_LIMIT;
-	return (
-		isProviderOverloadAssistantMessage(message) &&
-		resumeAttempts < maxAttempts &&
-		!hasPendingMessages
-	);
+	const isFresh = isFreshProviderOverloadError(message);
+	const underLimit = resumeAttempts < maxAttempts;
+	const noPending = !hasPendingMessages;
+	const shouldQueue = isFresh && underLimit && noPending;
+
+	if (isFresh) {
+		console.error(
+			`[pi-harness] shouldQueue=${shouldQueue} attempts=${resumeAttempts}/${maxAttempts} hasPending=${hasPendingMessages}`,
+		);
+	}
+
+	return shouldQueue;
 }
 
 export function getProviderOverloadResumeDelayMs(options?: {