pi-claude-supervisor 0.5.0 → 0.5.2

package/src/index.ts

@@ -2,12 +2,13 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { accessSync, chmodSync, constants as fsConstants, lstatSync, mkdirSync } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { EventLog } from "./events.ts";
 import { redactSensitive } from "./redaction.ts";
 import { ProcessWorkerAdapter } from "./worker/process-adapter.ts";
 import { TmuxWorkerAdapter, attachCommand } from "./worker/tmux-adapter.ts";
-import { Supervisor } from "./supervisor.ts";
+import { Supervisor, type DecisionSessionClosedInfo, type SupervisorProgress } from "./supervisor.ts";
 import { evaluateCommand } from "./policy.ts";
 import { HumanWebhookNotifier } from "./notifications.ts";
 import { loadSupervisorEnvironment } from "./config.ts";
@@ -15,7 +16,7 @@ import { DecisionSessionStore, type DecisionSessionRecord } from "./decision-ses
 import { CwdLeaseStore, type CwdLeaseHandle, pathsOverlap, workerIdentity } from "./cwd-lease.ts";
 import { normalizeTaskSpec } from "./acceptance.ts";
 import { PiReadOnlyReviewer } from "./reviewer.ts";
-import type { TaskSpec } from "./types.ts";
+import type { TaskSpec, WorkerHandle } from "./types.ts";
 
 /**
  * Pi Claude Supervisor.
@@ -40,6 +41,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   if (transport === "tmux" && cgroupMode === "required") {
     throw new Error("PI_CLAUDE_SUPERVISOR_CGROUP_MODE=required is unsupported with tmux; use process-pipe/jsonl or set cgroup mode to auto/off");
   }
+  if (automation && transport === "process-pipe") {
+    throw new Error("automatic supervision requires PI_CLAUDE_SUPERVISOR_TRANSPORT=jsonl or tmux; explicit process-pipe is manual-only");
+  }
   const adapter = transport === "tmux"
     ? new TmuxWorkerAdapter({ stateDir })
     : new ProcessWorkerAdapter({
@@ -53,9 +57,12 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     format: process.env.PI_CLAUDE_SUPERVISOR_HUMAN_WEBHOOK_FORMAT === "wecom" ? "wecom" : "generic",
     secret: process.env.PI_CLAUDE_SUPERVISOR_HUMAN_WEBHOOK_SECRET,
   });
+  const leaseDir = process.env.PI_CLAUDE_SUPERVISOR_CWD_LEASE_DIR ?? join(homedir(), ".pi", "agent", "claude-supervisor", "cwd-leases");
+  assertRuntimeDirectory(stateDir, "state");
+  assertRuntimeDirectory(leaseDir, "lease");
   const events = new EventLog(join(stateDir, "events.jsonl"));
   const decisionStore = new DecisionSessionStore(join(stateDir, "decision-sessions"));
-  const cwdLeaseStore = new CwdLeaseStore(process.env.PI_CLAUDE_SUPERVISOR_CWD_LEASE_DIR ?? join(homedir(), ".pi", "agent", "claude-supervisor", "cwd-leases"));
+  const cwdLeaseStore = new CwdLeaseStore(leaseDir);
   const reviewer = automation ? new PiReadOnlyReviewer() : undefined;
   const sessions = new Map<string, Supervisor>();
   const cwdLeases = new Map<string, CwdLeaseHandle>();
@@ -69,9 +76,23 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   let shutdownPromise: Promise<void> | undefined;
   let detachedLeaseSweepTimer: NodeJS.Timeout | undefined;
 
+  const handleDecisionSessionClosed = async (taskId: string, info: DecisionSessionClosedInfo): Promise<void> => {
+    const record = await decisionStore.load(taskId);
+    if (!record || record.state !== "active") return;
+    const terminal = info.reason === "completed" || info.reason === "human_stop";
+    if (terminal && info.cleanupConfirmed) {
+      await decisionStore.close(taskId);
+      return;
+    }
+    await decisionStore.markRecoveryInterrupted(taskId);
+  };
+
   const notify = (ctx: ExtensionContext, message: string, type: "info" | "warning" = "info") => {
     if (ctx.hasUI) ctx.ui.notify(redactText(message), type);
   };
+  const progress = (ctx: ExtensionContext) => (info: SupervisorProgress) => {
+    notify(ctx, `Worker progress: task=${info.taskId} phase=${info.phase} ${info.message}`, info.phase === "human" || info.phase === "failed" ? "warning" : "info");
+  };
   const activeSessions = () => [...sessions.entries()].filter(([, session]) =>
     ["starting", "running", "waiting", "paused"].includes(session.state));
   const releaseLease = async (taskId: string): Promise<boolean> => {
@@ -121,7 +142,18 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     });
   }, 1_000);
   detachedLeaseSweepTimer.unref();
-  const stopSession = async (session: Supervisor, reason: string, releasePersistent = false): Promise<void> => {
+  const workerCleanupConfirmed = async (handle: NonNullable<Supervisor["handle"]>): Promise<boolean> => {
+    try {
+      const status = await adapter.getStatus(handle);
+      return !status.running
+        && status.processGroupCleaned === true
+        && !status.cleanupError
+        && (!status.cgroupError || status.cgroupRequired === false);
+    } catch {
+      return false;
+    }
+  };
+  const stopSession = async (session: Supervisor, reason: string, releasePersistent = false, preserveDecisionSession = false): Promise<void> => {
     const handle = session.handle;
     const persistent = adapter.capabilities().persistentSession && Boolean(handle);
     const taskId = session.task?.taskId;
@@ -136,7 +168,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     if (!handle && ["failed", "completed", "stopped"].includes(session.state)) return;
     let lifecycleError: unknown;
     try {
-      await session.stop(reason);
+      await session.stop(reason, { preserveDecisionSession });
     } catch (error) {
       lifecycleError = error;
     }
@@ -253,6 +285,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
             try {
               const handle = await session.start({
                 taskId,
+                onProgress: progress(ctx),
                 task: goal,
                 spec,
                 cwd: cwdKey,
@@ -273,26 +306,34 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 } : undefined,
                 sendInitialInput: !tmuxSession,
                 decisionSessionDir: decisionStore.directory,
-                onDecisionSessionReady: (info) => decisionStore.save({
-                  taskId: info.taskId,
-                  task: info.task,
-                  spec: info.spec,
-                  cwd: info.cwd,
-                  command,
-                  args: workerArgs,
-                  approval,
-                  decisionSessionFile: info.sessionFile,
-                  maxTurns: info.maxTurns,
-                  deadlineMs: info.deadlineMs,
-                  noOutputTimeoutMs: info.noOutputTimeoutMs,
-                  startedAt: info.startedAt,
-                  turn: info.turn,
-                  repairRound: info.repairRound,
-                  ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
-                  state: "active",
-                }),
+                onDecisionSessionReady: async (info) => {
+                  const current = await decisionStore.load(info.taskId);
+                  await decisionStore.save({
+                    taskId: info.taskId,
+                    task: info.task,
+                    spec: info.spec,
+                    cwd: info.cwd,
+                    command,
+                    args: workerArgs,
+                    approval,
+                    decisionSessionFile: info.sessionFile,
+                    maxTurns: info.maxTurns,
+                    deadlineMs: info.deadlineMs,
+                    noOutputTimeoutMs: info.noOutputTimeoutMs,
+                    startedAt: info.startedAt,
+                    turn: info.turn,
+                    repairRound: info.repairRound,
+                    ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
+                    state: "active",
+                    recoveryState: current?.recoveryState ?? "ready",
+                    recoveryAttempt: current?.recoveryAttempt ?? 0,
+                    ...(current?.recoveryOwnerPid !== undefined ? { recoveryOwnerPid: current.recoveryOwnerPid } : {}),
+                    ...(current?.recoveryOwnerStartTime ? { recoveryOwnerStartTime: current.recoveryOwnerStartTime } : {}),
+                    ...(current?.recoveryWorker ? { recoveryWorker: current.recoveryWorker } : {}),
+                  });
+                },
                 onDecisionSessionProgress: (info) => decisionStore.update(info.taskId, { turn: info.turn, repairRound: info.repairRound, ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}) }),
-                onDecisionSessionClosed: (taskId) => decisionStore.close(taskId),
+                onDecisionSessionClosed: handleDecisionSessionClosed,
               });
               const startedTaskId = session.task?.taskId;
               if (!startedTaskId) throw new Error("worker started without a task id");
@@ -318,6 +359,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 }
                 throw registrationError;
               }
+              if (lease.replacedTaskId) await decisionStore.close(lease.replacedTaskId);
               // Register immediately after spawn so shutdown can retry cleanup if
               // the first stop attempt fails.
               sessions.set(startedTaskId, session);
@@ -325,7 +367,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
               activeTaskId = startedTaskId;
               if (shuttingDown) {
                 try {
-                  await stopSession(session, "Pi session shutdown during worker start", true);
+                  await stopSession(session, "Pi session shutdown during worker start", true, true);
                   sessions.delete(startedTaskId);
                   reservedCwds.delete(startedTaskId);
                 } finally {
@@ -392,12 +434,15 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
             pendingCwds.delete(cwdKey);
           }
         } else if (operation === "recover") {
-          const taskId = rest[0];
-          if (!taskId) throw new Error("Usage: /supervise recover <task-id>");
+          const takeover = rest.includes("--takeover");
+          const taskId = rest.find((value) => value !== "--takeover");
+          if (!taskId || rest.some((value) => value !== "--takeover" && value !== taskId)) throw new Error("Usage: /supervise recover [--takeover] <task-id>");
           if (shuttingDown) throw new Error("Pi session is shutting down");
           if (sessions.has(taskId)) throw new Error(`Task session is already loaded: ${taskId}`);
           const record = await decisionStore.load(taskId);
           if (!record || record.state !== "active") throw new Error(`No recoverable Decision Worker session: ${taskId}`);
+          const staleRecovery = !["ready", "interrupted"].includes(record.recoveryState);
+          if (staleRecovery && !takeover) throw new Error(`Decision Worker recovery is stale (${record.recoveryState}); retry with --takeover only after verifying the old Worker is gone: ${taskId}`);
           if (!await decisionStore.sessionFileExists(taskId)) throw new Error(`Decision Worker session file is missing or unsafe: ${taskId}`);
           if (record.maxTurns > 0 && record.turn >= record.maxTurns) throw new Error(`Cannot recover task after its turn budget was exhausted: ${taskId}`);
           if (record.deadlineMs > 0 && Date.now() - Date.parse(record.startedAt) >= record.deadlineMs) throw new Error(`Cannot recover task after its wall-clock deadline: ${taskId}`);
@@ -420,11 +465,28 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
             if (!approved) throw new Error("Worker command not approved");
             approval = { actor: "human", reason: policy.reason };
           }
-          const lease = await cwdLeaseStore.acquire(cwdKey, record.taskId, adapter.capabilities().transport);
+          const lease = await cwdLeaseStore.acquire(cwdKey, record.taskId, adapter.capabilities().transport, takeover
+            ? {
+              takeover: {
+                taskId: record.taskId,
+                ...(staleRecovery ? { beforeReplace: () => decisionStore.reconcileStaleRecovery(record.taskId) } : {}),
+              },
+            }
+            : {});
+          if (staleRecovery && lease.replacedTaskId !== record.taskId) {
+            await lease.release();
+            throw new Error(`Stale Decision Worker recovery has no verified old lease to take over: ${record.taskId}`);
+          }
           cwdLeases.set(record.taskId, lease);
-          if (shuttingDown) {
+          let recoveryClaimed = false;
+          try {
+            await decisionStore.beginRecovery(record.taskId);
+            recoveryClaimed = true;
+            if (shuttingDown) throw new Error("Pi session is shutting down");
+          } catch (error) {
+            if (recoveryClaimed) await decisionStore.markRecoveryInterrupted(record.taskId).catch(() => {});
             await releaseLease(record.taskId);
-            throw new Error("Pi session is shutting down");
+            throw error;
           }
           pendingCwds.add(cwdKey);
           const session = new Supervisor(adapter, events, {
@@ -440,11 +502,12 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
             },
           });
           pendingStartSessions.add(session);
-          let recoveryCleanupCompleted = false;
           const recoveryOperation = (async () => {
+            let startedHandle: WorkerHandle | undefined;
             try {
               const handle = await session.start({
                 taskId: record.taskId,
+                onProgress: progress(ctx),
                 // Claude session resume is not supported by this adapter. Start
                 // idle so recovery never replays the original task; the operator
                 // must explicitly send the next instruction.
@@ -467,72 +530,100 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 initialFindingSignature: record.lastFindingSignature,
                 decisionSessionFile: record.decisionSessionFile,
                 decisionSessionDir: decisionStore.directory,
-                onDecisionSessionReady: (info) => decisionStore.save({
-                  taskId: info.taskId,
-                  task: info.task,
-                  spec: info.spec,
-                  cwd: info.cwd,
-                  command: record.command,
-                  args: record.args,
-                  approval,
-                  decisionSessionFile: info.sessionFile,
-                  maxTurns: info.maxTurns,
-                  deadlineMs: info.deadlineMs,
-                  noOutputTimeoutMs: info.noOutputTimeoutMs,
-                  startedAt: info.startedAt,
-                  turn: info.turn,
-                  repairRound: info.repairRound,
-                  ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
-                  state: "active",
-                }),
+                onDecisionSessionReady: async (info) => {
+                  const current = await decisionStore.load(info.taskId);
+                  if (!current || current.state !== "active") throw new Error("Decision Worker recovery record disappeared before session registration");
+                  await decisionStore.save({
+                    taskId: info.taskId,
+                    task: info.task,
+                    spec: info.spec,
+                    cwd: info.cwd,
+                    command: record.command,
+                    args: record.args,
+                    approval,
+                    decisionSessionFile: info.sessionFile,
+                    maxTurns: info.maxTurns,
+                    deadlineMs: info.deadlineMs,
+                    noOutputTimeoutMs: info.noOutputTimeoutMs,
+                    startedAt: info.startedAt,
+                    turn: info.turn,
+                    repairRound: info.repairRound,
+                    ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
+                    state: "active",
+                    recoveryState: current.recoveryState,
+                    recoveryAttempt: current.recoveryAttempt,
+                    ...(current.recoveryOwnerPid !== undefined ? { recoveryOwnerPid: current.recoveryOwnerPid } : {}),
+                    ...(current.recoveryOwnerStartTime ? { recoveryOwnerStartTime: current.recoveryOwnerStartTime } : {}),
+                    ...(current.recoveryWorker ? { recoveryWorker: current.recoveryWorker } : {}),
+                  });
+                },
                 onDecisionSessionProgress: (info) => decisionStore.update(info.taskId, { turn: info.turn, repairRound: info.repairRound, ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}) }),
-                onDecisionSessionClosed: (closedTaskId) => decisionStore.close(closedTaskId),
+                onDecisionSessionClosed: handleDecisionSessionClosed,
               });
-              try {
-                await lease.updateWorker({
-                  transport: adapter.capabilities().transport,
-                  ...(await workerIdentity(handle)),
-                  sessionName: handle.sessionName,
-                  tmuxSocket: handle.tmuxSocket,
-                  ownership: handle.ownership,
-                });
-              } catch (error) {
-                const registrationError = error instanceof Error ? error : new Error(String(error));
-                try {
-                  await stopSession(session, "cwd lease metadata registration failed");
-                  recoveryCleanupCompleted = await releaseLease(record.taskId);
-                } catch (cleanupError) {
-                  const message = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
-                  registrationError.message = `${registrationError.message}; worker cleanup failed: ${message}`;
-                  Object.defineProperty(registrationError, "workerCleanupRequired", { value: true, enumerable: false });
-                }
-                throw registrationError;
+              startedHandle = handle;
+              await lease.updateWorker({
+                transport: adapter.capabilities().transport,
+                ...(await workerIdentity(handle)),
+                sessionName: handle.sessionName,
+                tmuxSocket: handle.tmuxSocket,
+                ownership: handle.ownership,
+              });
+              await decisionStore.recordRecoveryWorker(record.taskId, {
+                id: handle.id,
+                pid: handle.pid,
+                startedAt: handle.startedAt,
+              });
+              const registered = await decisionStore.load(record.taskId);
+              if (!registered || registered.state !== "active" || registered.recoveryState !== "registered" || registered.recoveryWorker?.id !== handle.id) {
+                throw new Error("Recovered Worker registration was not durably confirmed");
               }
               sessions.set(record.taskId, session);
               reservedCwds.set(record.taskId, cwdKey);
               activeTaskId = record.taskId;
               await session.takeover();
+              await decisionStore.markRecoveryIdle(record.taskId);
+              const idle = await decisionStore.load(record.taskId);
+              if (!idle || idle.state !== "active" || idle.recoveryState !== "recovered_idle" || idle.recoveryWorker?.id !== handle.id) {
+                throw new Error("Recovered idle state was not durably confirmed");
+              }
               if (shuttingDown) {
-                await stopSession(session, "Pi session shutdown during recovery", true);
+                await stopSession(session, "Pi session shutdown during recovery", true, true);
                 throw new Error("Pi session shut down during recovery");
               }
               message = `Worker recovered idle: task=${record.taskId} worker=${handle.id}; original task was not replayed; send an explicit continuation, then use resume-auto`;
             } catch (error) {
-              const cleanupRequired = requiresWorkerCleanup(error);
-              if (cleanupRequired) cleanupRequiredTasks.add(record.taskId);
-              const retainHandle = !recoveryCleanupCompleted && session.handle
-                && (cleanupRequired || session.handle.ownership === "adopted");
-              if (retainHandle) {
-                sessions.set(record.taskId, session);
-                reservedCwds.set(record.taskId, cwdKey);
-                activeTaskId = record.taskId;
-              } else if (!cleanupRequired && !recoveryCleanupCompleted) {
+              const handle = session.handle ?? startedHandle;
+              let cleanupConfirmed = !handle;
+              const retainedWorker = handle?.ownership === "adopted";
+              if (handle && !retainedWorker) {
+                try {
+                  await stopSession(session, "Decision Worker recovery cleanup", false, true);
+                  cleanupConfirmed = await workerCleanupConfirmed(handle);
+                } catch {
+                  cleanupConfirmed = false;
+                }
+              }
+              if (!cleanupConfirmed) cleanupRequiredTasks.add(record.taskId);
+              try {
+                await decisionStore.markRecoveryInterrupted(record.taskId);
+              } catch (stateError) {
+                cleanupConfirmed = false;
+                console.error(`pi-claude-supervisor recovery state update failed: ${redactText(stateError instanceof Error ? stateError.message : String(stateError))}`);
+              }
+              if (cleanupConfirmed && !retainedWorker) {
                 const released = await releaseLease(record.taskId);
-                if (!released) {
+                if (released) {
+                  forgetSession(record.taskId);
+                } else {
+                  cleanupRequiredTasks.add(record.taskId);
                   sessions.set(record.taskId, session);
                   reservedCwds.set(record.taskId, cwdKey);
                   activeTaskId = record.taskId;
                 }
+              } else {
+                sessions.set(record.taskId, session);
+                reservedCwds.set(record.taskId, cwdKey);
+                activeTaskId = record.taskId;
               }
               throw error;
             }
@@ -595,7 +686,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           } else if (operation === "resume-auto") {
             await session.resumeAutomation(); message = `Automatic decisions resumed: ${sessionId}.`;
           } else {
-            throw new Error("Usage: /supervise start|adopt-tmux|recover|sessions|status|poll [all|taskId]|send [taskId]|pause [taskId]|resume [taskId]|stop [taskId]|verify [taskId]|approve [taskId] <allow|deny>|takeover [taskId]|resume-auto [taskId]|capabilities");
+            throw new Error("Usage: /supervise start|adopt-tmux|recover [--takeover]|sessions|status|poll [all|taskId]|send [taskId]|pause [taskId]|resume [taskId]|stop [taskId]|verify [taskId]|approve [taskId] <allow|deny>|takeover [taskId]|resume-auto [taskId]|capabilities");
           }
         }
         notify(ctx, message);
@@ -629,7 +720,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           startupFailures.push(...results.filter((result): result is PromiseRejectedResult => result.status === "rejected"));
         }
       }
-      const results = await Promise.allSettled([...sessions.values()].map((session) => stopSession(session, "Pi session shutdown", true)));
+      const results = await Promise.allSettled([...sessions.values()].map((session) => stopSession(session, "Pi session shutdown", true, true)));
       await releaseSettledReservations();
       const failures = [...startupFailures, ...results.filter((result): result is PromiseRejectedResult => result.status === "rejected")];
       if (failures.length > 0) {
@@ -640,11 +731,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     })();
     return shutdownPromise;
   };
-  const onSignal = (signal: NodeJS.Signals) => {
-    void shutdown().finally(() => process.exit(signal === "SIGTERM" ? 143 : 130));
-  };
-  process.once("SIGTERM", onSignal);
-  process.once("SIGINT", onSignal);
+  // Pi owns process signal handling and invokes session_shutdown. Installing a
+  // second extension-level process.exit() handler races Pi's terminal restore and
+  // other extension shutdown hooks.
   pi.on("session_shutdown", async () => {
     await shutdown();
   });
@@ -682,7 +771,7 @@ function formatSessions(sessions: Map<string, Supervisor>, recoverable: Decision
     .map(([taskId, session]) => `${taskId} state=${session.state} cwd=${session.task?.cwd ?? "-"} worker=${session.handle?.id ?? "-"}`);
   const pending = recoverable
     .filter((record) => !sessions.has(record.taskId))
-    .map((record) => `${record.taskId} state=recoverable cwd=${record.cwd} worker=-`);
+    .map((record) => `${record.taskId} state=recoverable recovery=${record.recoveryState} cwd=${record.cwd} worker=${record.recoveryWorker?.id ?? "-"}`);
   return [...active, ...pending].join("\n") || "No task sessions.";
 }
 
@@ -717,6 +806,18 @@ function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function assertRuntimeDirectory(path: string, label: string): void {
+  try {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    const info = lstatSync(path);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`${label} directory is not a real directory`);
+    chmodSync(path, 0o700);
+    accessSync(path, fsConstants.R_OK | fsConstants.W_OK | fsConstants.X_OK);
+  } catch (error) {
+    throw new Error(`${label} directory preflight failed for ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+
 function redactText(value: string): string {
   return String(redactSensitive(value));
 }

package/src/redaction.ts

@@ -10,8 +10,9 @@ export function redactSensitive(value: unknown, key?: string): unknown {
       .replace(/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/gu, "[REDACTED]")
       .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[REDACTED]")
       .replace(/\b(Bearer\s+)[^\s]+/giu, "$1[REDACTED]")
+      .replace(/\b((?:authorization)\s*:\s*(?:[A-Za-z]+\s+)?)[^\s,;)}\]]+/giu, "$1[REDACTED]")
+      .replace(/\b((?:x-api-key|api[-_]?key|token|secret|password|credential)\s*[:=]\s*)[^\s,;)}\]]+/giu, "$1[REDACTED]")
       .replace(/\b((?:AWS_ACCESS_KEY_ID|AWS_SECRET_ACCESS_KEY|AWS_SESSION_TOKEN|[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)))=([^\s]+)/gu, "$1=[REDACTED]")
-      .replace(/\b((?:authorization|x-api-key|api-key)\s*:\s*)[^\s]+/giu, "$1[REDACTED]")
       .replace(/(--?(?:token|api[-_]?key|secret|password|authorization)(?:=|\s+))[^\s]+/giu, "$1[REDACTED]");
   }
   if (Array.isArray(value)) return value.map((item) => redactSensitive(item, key));

package/src/reviewer.ts

@@ -15,6 +15,8 @@ export interface ReviewInput {
   workerOutput?: string;
   workerResult?: Record<string, unknown>;
   round: number;
+  /** Abort a review when the operator stops or shuts down the Supervisor. */
+  signal?: AbortSignal;
 }
 
 export interface TaskReviewer {
@@ -38,6 +40,9 @@ export class PiReadOnlyReviewer implements TaskReviewer {
   }
 
   async review(input: ReviewInput): Promise<ReviewReport> {
+    if (input.evidence.complete === false || input.evidence.truncated === true) {
+      return invalidReview("repository evidence is incomplete or truncated", input.round, new Date().toISOString());
+    }
     const resourceLoader = new DefaultResourceLoader({
       cwd: input.cwd,
       agentDir: getAgentDir(),
@@ -55,20 +60,40 @@ export class PiReadOnlyReviewer implements TaskReviewer {
       thinkingLevel: "low",
       tools: ["read", "grep", "find", "ls"],
     });
-    let text = "";
-    let responseTooLarge = false;
+    let current = "";
+    let finalMessage = "";
+    let capturingAssistant = false;
+    let currentTooLarge = false;
+    let finalTooLarge = false;
     const unsubscribe = session.subscribe((value) => {
-      const record = value as unknown as { type?: string; assistantMessageEvent?: { type?: string; delta?: string } };
-      if (record.type !== "message_update" || record.assistantMessageEvent?.type !== "text_delta" || responseTooLarge) return;
-      const delta = record.assistantMessageEvent.delta ?? "";
-      if (Buffer.byteLength(text, "utf8") + Buffer.byteLength(delta, "utf8") > MAX_REVIEW_RESPONSE_BYTES) {
-        responseTooLarge = true;
+      const record = value as unknown as { type?: string; message?: { role?: string; content?: unknown }; assistantMessageEvent?: { type?: string; delta?: string } };
+      const role = record.message?.role;
+      if (record.type === "message_start" && role === "assistant") {
+        current = "";
+        currentTooLarge = false;
+        capturingAssistant = true;
+        return;
+      }
+      if (record.type === "message_update" && record.assistantMessageEvent?.type === "text_delta" && (capturingAssistant || role === "assistant" || role === undefined)) {
+        capturingAssistant = true;
+        const delta = record.assistantMessageEvent.delta ?? "";
+        if (Buffer.byteLength(current, "utf8") + Buffer.byteLength(delta, "utf8") > MAX_REVIEW_RESPONSE_BYTES) {
+          currentTooLarge = true;
+          return;
+        }
+        current += delta;
         return;
       }
-      text += delta;
+      if (record.type === "message_end" && role === "assistant") {
+        finalMessage = current || textFromMessage(record.message?.content);
+        finalTooLarge = currentTooLarge;
+        current = "";
+        currentTooLarge = false;
+        capturingAssistant = false;
+      }
     });
     try {
-      await withTimeout(session.prompt(reviewPrompt(input)), this.#timeoutMs, "independent Reviewer");
+      await withTimeout(session.prompt(reviewPrompt(input)), this.#timeoutMs, "independent Reviewer", input.signal);
     } catch (error) {
       await session.abort().catch(() => {});
       throw error;
@@ -76,9 +101,9 @@ export class PiReadOnlyReviewer implements TaskReviewer {
       unsubscribe();
       session.dispose();
     }
-    return responseTooLarge
+    return finalTooLarge
       ? invalidReview(`Reviewer response exceeded ${MAX_REVIEW_RESPONSE_BYTES} bytes`, input.round, new Date().toISOString())
-      : parseReview(text, input.round);
+      : parseReview(finalMessage || current, input.round);
   }
 }
 
@@ -103,10 +128,17 @@ ACCEPTANCE REPORT:
 ${boundedJson(input.acceptance)}
 
 REPOSITORY STATUS:
-${boundText(input.evidence.status, 8_000)}
+${boundText(redactText(input.evidence.status), 8_000)}
+
+REPOSITORY DIFF (HEAD-RELATIVE, UNTRUSTED):
+${boundText(redactText(input.evidence.diff), 16_000)}
 
-REPOSITORY DIFF (UNTRUSTED):
-${boundText(input.evidence.diff, 16_000)}
+UNTRACKED FILE EVIDENCE (UNTRUSTED):
+${boundText(redactText(input.evidence.untracked ?? "(none)"), 16_000)}
+
+EVIDENCE COMPLETE:
+${String(input.evidence.complete !== false && input.evidence.truncated !== true)}
+If repository evidence is incomplete or truncated, do not return pass; return human and explain which evidence is unavailable.
 
 WORKER OUTPUT (UNTRUSTED):
 ${boundTailText(redactSensitive(input.workerOutput ?? "(none)"), 8_000)}
@@ -118,6 +150,15 @@ REVIEW ROUND:
 ${input.round}`;
 }
 
+function textFromMessage(content: unknown): string {
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((block): block is { type?: unknown; text?: unknown } => Boolean(block && typeof block === "object"))
+    .filter((block) => block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text as string)
+    .join("");
+}
+
 export function parseReview(text: string, round: number): ReviewReport {
   const checkedAt = new Date().toISOString();
   if (Buffer.byteLength(text, "utf8") > MAX_REVIEW_RESPONSE_BYTES) return invalidReview(`Reviewer response exceeded ${MAX_REVIEW_RESPONSE_BYTES} bytes`, round, checkedAt);
@@ -179,16 +220,28 @@ function redactText(value: string): string {
   return String(redactSensitive(value));
 }
 
-async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string, signal?: AbortSignal): Promise<T> {
   let timer: NodeJS.Timeout | undefined;
+  let onAbort: (() => void) | undefined;
   const timeout = new Promise<never>((_, reject) => {
     timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
     timer.unref();
   });
+  const aborted = new Promise<never>((_, reject) => {
+    if (!signal) return;
+    onAbort = () => {
+      const error = new Error(`${label} aborted`);
+      error.name = "AbortError";
+      reject(error);
+    };
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
   try {
-    return await Promise.race([promise, timeout]);
+    return await Promise.race([promise, timeout, aborted]);
   } finally {
     if (timer) clearTimeout(timer);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
   }
 }