pi-claude-supervisor 0.5.1 → 0.5.2

package/src/decision-worker.ts

@@ -6,6 +6,9 @@ import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager,
 import type { TaskSpec, WorkerEvent } from "./types.ts";
 import { redactSensitive } from "./redaction.ts";
 
+const MAX_DECISION_RESPONSE_BYTES = 32 * 1024;
+const MAX_DECISION_FIELD_BYTES = 8 * 1024;
+
 export type DecisionAction =
   | { action: "continue" | "redirect" | "answer"; message: string; reason: string; confidence?: number }
   | { action: "allow_permission" | "deny_permission"; requestId: string; toolUseId: string; reason: string; confidence?: number }
@@ -189,10 +192,37 @@ secrets, deployment, or any uncertainty. Never invent missing information.`;
 }
 
 async function askDecision(session: AgentSession, event: WorkerEvent, context: DecisionContext, timeoutMs: number): Promise<string> {
-  let text = "";
+  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") text += record.assistantMessageEvent.delta ?? "";
+    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_DECISION_RESPONSE_BYTES) {
+        currentTooLarge = true;
+        return;
+      }
+      current += delta;
+      return;
+    }
+    if (record.type === "message_end" && role === "assistant") {
+      finalMessage = current || textFromMessage(record.message?.content);
+      finalTooLarge = currentTooLarge;
+      current = "";
+      currentTooLarge = false;
+      capturingAssistant = false;
+    }
   });
   try {
     try {
@@ -204,11 +234,21 @@ async function askDecision(session: AgentSession, event: WorkerEvent, context: D
   } finally {
     unsubscribe();
   }
-  return text;
+  if (finalTooLarge) return "";
+  return finalMessage || current;
+}
+
+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("");
 }
 
 function parseDecision(text: string, event: WorkerEvent): DecisionAction {
-  const candidate = text.match(/\{[\s\S]*\}/u)?.[0];
+  const candidate = text.trim();
   if (!candidate) return { action: "ask_human", reason: "Decision Worker returned no JSON action" };
   try {
     const value = JSON.parse(candidate) as Record<string, unknown>;
@@ -216,11 +256,13 @@ function parseDecision(text: string, event: WorkerEvent): DecisionAction {
     if (typeof action !== "string") throw new Error("missing action");
     const allowed = new Set(["continue", "redirect", "answer", "allow_permission", "deny_permission", "verify", "retry", "stop", "ask_human", "noop"]);
     if (!allowed.has(action)) throw new Error(`unsupported action: ${action}`);
-    const reason = typeof value.reason === "string" && value.reason.trim() ? value.reason : "no reason provided";
-    const confidence = typeof value.confidence === "number" ? value.confidence : undefined;
+    const reason = typeof value.reason === "string" && value.reason.trim() ? boundedDecisionText(value.reason, "reason") : "no reason provided";
+    const confidence = value.confidence === undefined ? undefined : typeof value.confidence === "number" && Number.isFinite(value.confidence) && value.confidence >= 0 && value.confidence <= 1
+      ? value.confidence
+      : (() => { throw new Error("confidence must be a finite number between 0 and 1"); })();
     if (["continue", "redirect", "answer"].includes(action)) {
       if (typeof value.message !== "string" || !value.message.trim()) throw new Error("message required");
-      return { action: action as "continue" | "redirect" | "answer", message: value.message, reason, confidence };
+      return { action: action as "continue" | "redirect" | "answer", message: boundedDecisionText(value.message, "message"), reason, confidence };
     }
     if (["allow_permission", "deny_permission"].includes(action)) {
       const permission = event.type === "permission_request" ? event.request : undefined;
@@ -229,12 +271,17 @@ function parseDecision(text: string, event: WorkerEvent): DecisionAction {
       if (!requestId || !toolUseId) throw new Error("permission requestId/toolUseId required");
       return { action: action as "allow_permission" | "deny_permission", requestId, toolUseId, reason, confidence };
     }
-    return { action: action as "verify" | "retry" | "stop" | "ask_human" | "noop", reason, question: typeof value.question === "string" ? value.question : undefined, confidence };
+    return { action: action as "verify" | "retry" | "stop" | "ask_human" | "noop", reason, question: typeof value.question === "string" ? boundedDecisionText(value.question, "question") : undefined, confidence };
   } catch (error) {
     return { action: "ask_human", reason: `invalid Decision Worker action: ${error instanceof Error ? error.message : String(error)}` };
   }
 }
 
+function boundedDecisionText(value: string, field: string): string {
+  if (Buffer.byteLength(value, "utf8") > MAX_DECISION_FIELD_BYTES) throw new Error(`${field} exceeds ${MAX_DECISION_FIELD_BYTES} bytes`);
+  return value;
+}
+
 function eventKey(event: WorkerEvent): string {
   if (event.type === "permission_request") return `${event.handle.id}:permission:${event.request.requestId}`;
   if (event.type === "turn_completed") return `${event.handle.id}:result:${event.sequence}`;

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, type DecisionSessionClosedInfo } 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";
@@ -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>();
@@ -83,6 +90,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   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> => {
@@ -275,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,
@@ -496,6 +507,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
             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.
@@ -719,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();
   });
@@ -796,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);
   }
 }