pi-claude-supervisor 0.9.0 → 0.9.2

package/src/cwd-lease.ts

@@ -187,7 +187,20 @@ export class CwdLeaseStore {
               continue;
             }
           }
-          throw new Error(`working-directory lease is held by task ${existing.taskId}: ${redactText(existing.cwd)}`);
+          // A crash leaves the lease of a task that no longer exists
+          // anywhere. When its owner and its Worker are provably gone and
+          // it holds no cleanup boundary (cgroup, tmux server) that recovery
+          // still has to prove empty, it blocks nothing real: drop it rather
+          // than strand the directory behind a record no command can free.
+          if (await leaseAbandoned(existing)) {
+            await rm(this.#path(existing.leaseId), { force: true });
+            console.error(`pi-claude-supervisor released an abandoned cwd lease of task ${existing.taskId}: its Pi (pid ${existing.ownerPid}) and Worker are gone`);
+            continue;
+          }
+          const ownerGone = !existing.pendingCleanup && !await processIdentityLive(existing.ownerPid, existing.ownerStartTime);
+          throw new Error(ownerGone
+            ? `working-directory lease is held by task ${existing.taskId}: ${redactText(existing.cwd)}; its Pi (pid ${existing.ownerPid}) is gone but its Worker (a cgroup or tmux session) may still be running. For an automatic task run /supervise recover --takeover ${existing.taskId}; for a manual one, stop or re-adopt its Worker, then delete ${redactText(this.#path(existing.leaseId))}; or use another worktree`
+            : `working-directory lease is held by task ${existing.taskId}: ${redactText(existing.cwd)}`);
         }
         if (takeoverLease && takeoverProof) {
           if (takeoverProof.startupOnly) {
@@ -656,6 +669,26 @@ export async function leaseOwnerLive(lease: CwdLeaseRecord): Promise<boolean> {
   return processIdentityLive(lease.ownerPid, lease.ownerStartTime);
 }
 
+/**
+ * A lease nobody can still be using: its owning Pi is gone (pid and start
+ * time), no takeover transaction is pending, and its Worker either never
+ * started or ran without a cgroup and is dead along with its whole process
+ * group — the same evidence the adapter's own cleanup relies on in that mode
+ * — with no tmux server left. A Worker that had a cgroup boundary is never
+ * reclaimed here: only an explicit, record-backed `recover --takeover` may
+ * prove that boundary empty.
+ */
+async function leaseAbandoned(lease: CwdLeaseRecord): Promise<boolean> {
+  if (lease.pendingCleanup || await processIdentityLive(lease.ownerPid, lease.ownerStartTime)) return false;
+  const worker = lease.worker;
+  if (!worker) return true;
+  // A tmux session is meant to outlive its Pi and be re-adopted or handed
+  // off by identity; that record is evidence, never garbage.
+  if (worker.transport === "tmux" || worker.ownership === "adopted" || worker.cgroupPath || worker.retainCgroupUntilLeaseRelease) return false;
+  if (worker.pid === undefined) return Boolean(lease.pendingStartup) && !worker.workerId;
+  return !await processExists(worker.pid) && !await processGroupExists(worker.pid);
+}
+
 async function canTakeoverLease(lease: CwdLeaseRecord): Promise<TakeoverProof | undefined> {
   // The old supervisor owner must be gone. A dead owner is not enough when
   // the detached Worker itself is still alive. Compare start time as well as

package/src/decision-session-store.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { currentLockOwner, lockOwnerAlive } from "./lock-owner.ts";
 import { redactSensitive } from "./redaction.ts";
 import { normalizeTaskSpec } from "./acceptance.ts";
 import type { TaskSpec } from "./types.ts";
@@ -363,10 +364,7 @@ export class DecisionSessionStore {
     while (true) {
       try {
         await mkdir(lockPath, { mode: 0o700 });
-        await writeFile(join(lockPath, "owner.json"), JSON.stringify({
-          pid: process.pid,
-          at: new Date().toISOString(),
-        }), { encoding: "utf8", mode: 0o600 });
+        await writeFile(join(lockPath, "owner.json"), JSON.stringify(await currentLockOwner()), { encoding: "utf8", mode: 0o600 });
         break;
       } catch (error) {
         if (!(error instanceof Error) || !/EEXIST/u.test(error.message)) throw error;
@@ -554,17 +552,10 @@ async function removeStaleLock(lockPath: string): Promise<boolean> {
         throw error;
       }
     }
-    let owner: { pid?: unknown } = {};
-    try { owner = JSON.parse(await readFile(ownerPath, "utf8")) as { pid?: unknown }; }
+    let owner: unknown;
+    try { owner = JSON.parse(await readFile(ownerPath, "utf8")); }
     catch { /* an old/incomplete lock is reclaimable after the grace period */ }
-    if (typeof owner.pid === "number" && Number.isSafeInteger(owner.pid) && owner.pid > 0) {
-      try {
-        process.kill(owner.pid, 0);
-        return false;
-      } catch (error) {
-        if (error instanceof Error && /EPERM/u.test(error.message)) return false;
-      }
-    }
+    if (await lockOwnerAlive(owner)) return false;
     await rm(lockPath, { recursive: true, force: true });
     return true;
   } catch (error) {

package/src/decision-worker.ts

@@ -4,6 +4,7 @@ import { dirname, resolve } from "node:path";
 import { lstat, open, rename, rm, writeFile, type FileHandle } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, type AgentSession } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_MAX_DECISION_RETRIES } from "./config.ts";
 import { extractJsonObjects } from "./json-extract.ts";
 import type { PiUsageSample, TaskSpec, WorkerEvent } from "./types.ts";
 import { redactSensitive } from "./redaction.ts";
@@ -28,6 +29,18 @@ export interface DecisionContext {
   spec?: TaskSpec;
   /** Wall-clock budget of the task; absent when no deadline is configured. */
   deadline?: DecisionDeadlineContext;
+  /** Outcome of the most recent acceptance/Review round, if one has run. */
+  lastVerification?: DecisionVerificationSummary;
+}
+
+/** A compact view of the last verification: what failed and what the Reviewer asked for. */
+export interface DecisionVerificationSummary {
+  ok: boolean;
+  /** The Worker turn it judged: turns after it are not reflected in it. */
+  atTurn?: number;
+  failedChecks: string[];
+  reviewVerdict?: string;
+  findings: string[];
 }
 
 export interface DecisionDeadlineContext {
@@ -81,6 +94,16 @@ export interface DecisionWorkerOptions {
 export type PiModel = NonNullable<NonNullable<Parameters<typeof createAgentSession>[0]>["model"]>;
 
 const DEFAULT_COMPACTION_TOKENS = 60_000;
+/**
+ * Worker turns after a failed verification before the Supervisor verifies on
+ * its own: the Decision Worker only sees that failure as it was, so left to
+ * itself it can keep sending "it still fails" guidance to a Worker that has
+ * already fixed it. The first of these turns is the repair turn itself.
+ */
+export const STALE_VERIFICATION_TURNS = 3;
+/** First retry wait; each later wait triples, capped at MAX_DECISION_RETRY_BACKOFF_MS. */
+const DEFAULT_DECISION_RETRY_BACKOFF_MS = 5_000;
+const MAX_DECISION_RETRY_BACKOFF_MS = 60_000;
 
 /**
  * A persistent Pi SDK session used only for supervision decisions.
@@ -97,6 +120,8 @@ export class PiDecisionWorker implements DecisionWorkerLike {
   #sessionFile?: string;
   #context: DecisionContext;
   readonly #timeoutMs: number;
+  /** Ends a startup retry backoff early; set only while one is waiting. */
+  #wakeStartupBackoff?: () => void;
   readonly #retryBackoffMs: number;
   readonly #compactionTokens: number;
   /** Set after a compaction; the next primary decision prompt re-sends the startup instructions once. */
@@ -106,7 +131,7 @@ export class PiDecisionWorker implements DecisionWorkerLike {
     this.#options = options;
     this.#context = { ...options.context };
     this.#timeoutMs = options.timeoutMs ?? 120_000;
-    this.#retryBackoffMs = options.retryBackoffMs ?? 500;
+    this.#retryBackoffMs = options.retryBackoffMs ?? DEFAULT_DECISION_RETRY_BACKOFF_MS;
     this.#compactionTokens = options.compactionTokens ?? DEFAULT_COMPACTION_TOKENS;
   }
 
@@ -149,11 +174,31 @@ export class PiDecisionWorker implements DecisionWorkerLike {
       await this.#options.onSessionReady({ sessionFile: this.#sessionFile, sessionId: session.sessionId, restored });
     }
     if (!restored) {
-      try {
-        await promptForText(session, decisionInstructions(this.#context), this.#timeoutMs, "Decision Worker startup", MAX_DECISION_RESPONSE_BYTES, { role: "decision", onUsage: this.#options.onUsage });
-      } catch (error) {
-        try { await this.#options.onStartupFailure?.(error); } catch { /* preserve the original startup failure */ }
-        throw error;
+      // A provider hiccup (503 overload, 429) here would otherwise fail the
+      // whole task before its first turn: retry it like any decision.
+      const maxRetries = this.#context.spec?.autonomy.maxDecisionRetries ?? DEFAULT_MAX_DECISION_RETRIES;
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          await promptForText(session, decisionInstructions(this.#context), this.#timeoutMs, "Decision Worker startup", MAX_DECISION_RESPONSE_BYTES, { role: "decision", onUsage: this.#options.onUsage });
+          break;
+        } catch (error) {
+          // Closed by the Supervisor (an operator stop): not a startup
+          // failure to report, whatever the interrupted prompt returned.
+          if (this.#closed) throw closedDuringStartup();
+          // Only a provider error is worth another attempt: a timeout already
+          // spent the whole prompt budget and would only multiply it.
+          const retryable = error instanceof Error && error.name === "DecisionWorkerApiError";
+          if (attempt >= maxRetries || !retryable) {
+            try { await this.#options.onStartupFailure?.(error); } catch { /* preserve the original startup failure */ }
+            throw error;
+          }
+          // close() wakes this wait, so a stop does not sit out the backoff.
+          await new Promise<void>((resolveWait) => {
+            const timer = setTimeout(() => { this.#wakeStartupBackoff = undefined; resolveWait(); }, Math.min(MAX_DECISION_RETRY_BACKOFF_MS, this.#retryBackoffMs * 3 ** (attempt + 1)));
+            this.#wakeStartupBackoff = () => { clearTimeout(timer); this.#wakeStartupBackoff = undefined; resolveWait(); };
+          });
+          if (this.#closed) throw closedDuringStartup();
+        }
       }
     }
   }
@@ -188,7 +233,7 @@ export class PiDecisionWorker implements DecisionWorkerLike {
 
   async #processEvent(event: WorkerEvent): Promise<void> {
     if (!this.#session || this.#closed) return;
-    const maxRetries = this.#context.spec?.autonomy.maxDecisionRetries ?? 2;
+    const maxRetries = this.#context.spec?.autonomy.maxDecisionRetries ?? DEFAULT_MAX_DECISION_RETRIES;
     let attempt = 0;
     // undefined selects the primary decision question; a bounded re-prompt
     // (below) switches this to a corrective follow-up on the same session.
@@ -216,7 +261,8 @@ export class PiDecisionWorker implements DecisionWorkerLike {
         if (error instanceof Error && error.name === "AbortError") throw error;
         if (attempt >= maxRetries) throw error;
         attempt += 1;
-        await new Promise<void>((resolveWait) => setTimeout(resolveWait, Math.min(30_000, this.#retryBackoffMs * 2 ** attempt)));
+        // 429/529 overloads last minutes, not seconds: 15s, 45s, then 60s.
+        await new Promise<void>((resolveWait) => setTimeout(resolveWait, Math.min(MAX_DECISION_RETRY_BACKOFF_MS, this.#retryBackoffMs * 3 ** attempt)));
         if (!this.#session || this.#closed) return;
         continue;
       }
@@ -231,6 +277,13 @@ export class PiDecisionWorker implements DecisionWorkerLike {
         prompt = `Your previous reply was not a single valid JSON action (${action.reason}). Return exactly one JSON object now and nothing else.`;
         continue;
       }
+      // `noop` on a completed turn or a pending permission leaves the Worker
+      // idle forever; the Supervisor parks it. Ask once for a concrete action.
+      if (!repromptAttempted && action.action === "noop" && (event.type === "turn_completed" || event.type === "permission_request")) {
+        repromptAttempted = true;
+        prompt = `noop is not a valid action for a ${event.type} event: the Worker is waiting on you and nothing will happen. Choose a concrete action (for example continue, redirect or verify for a completed turn, or allow_permission/deny_permission for a permission request) and return exactly one JSON object now.`;
+        continue;
+      }
       // An action handler may stop or close the session. Do not replay an
       // already-decoded action if the handler itself fails.
       await this.#options.onAction(action, event);
@@ -249,11 +302,15 @@ export class PiDecisionWorker implements DecisionWorkerLike {
     const tokens = this.#session.getContextUsage?.()?.tokens;
     if (typeof tokens !== "number" || tokens <= this.#compactionTokens) return;
     try {
-      await this.#session.compact(
+      // Bounded like any other Decision Worker request: compaction runs on the
+      // serialized decision tail, so a stalled summarization would otherwise
+      // block every later decision.
+      await withTimeout(this.#session.compact(
         "Preserve: the task specification, the policy rules for permissions and boundaries, the current state, and the last three decisions with their reasons.",
-      );
+      ), this.#timeoutMs, "Decision Worker compaction");
       this.#instructionsStale = true;
     } catch {
+      try { this.#session?.abortCompaction?.(); } catch { /* best effort */ }
       // A compaction failure must not fail the decision that already succeeded.
     }
   }
@@ -274,6 +331,7 @@ export class PiDecisionWorker implements DecisionWorkerLike {
     // Do not await #tail here: onAction may be closing the worker from inside
     // the same queued decision, which would otherwise deadlock shutdown.
     this.#closed = true;
+    this.#wakeStartupBackoff?.();
     const session = this.#session;
     this.#session = undefined;
     if (session) await session.abort().catch(() => {});
@@ -281,6 +339,12 @@ export class PiDecisionWorker implements DecisionWorkerLike {
   }
 }
 
+function closedDuringStartup(): Error {
+  const error = new Error("Decision Worker was closed during startup");
+  error.name = "AbortError";
+  return error;
+}
+
 function decisionInstructions(context: DecisionContext): string {
   return `You are the persistent Pi Decision Worker for a Claude Code implementation task.
 Your job is to inspect evidence and choose the next typed action. Do not edit files,
@@ -311,8 +375,21 @@ as the answer and continues. A turn_completed whose result has subtype "error" o
 means the Worker's own API/model call failed mid-turn: choose retry (optionally with a short
 corrective message) or continue to resume it, and park only after repeated failures; a subtype
 "idle" result means the turn ended without a normal stop signal, so inspect the repository and
-decide as for any other turn. Use verify when a turn result indicates the task is complete, even if
+decide as for any other turn. CURRENT CONTEXT.lastVerification, when present, is the last acceptance
+and Review round (failed check ids, Reviewer verdict and findings) as of Worker turn atTurn. It
+does not change until verification runs again: it is not evidence that the failures remain after
+Claude's later turns. Use it to judge whether Claude's reply addresses those failures; once
+Claude reports them fixed, choose verify rather than re-judging the old result. (After a failed
+verification the Supervisor verifies by itself once ${STALE_VERIFICATION_TURNS} Worker turns, the repair turn included,
+have passed without one; do not rely on it.)
+A continue, redirect or answer message is sent verbatim to Claude Code as its next instruction:
+write it as a direct instruction to Claude, not a description of what you will do yourself (use
+your own read-only tools to inspect the repository before deciding).
+Use verify when a turn result indicates the task is complete, even if
 Claude says it will stop; choose stop only for an explicit stop or technical containment reason.
+In an unattended task without remote authority, a stop on a completed turn stops the Worker
+and then still verifies its work, but no repair round can follow, so a fixable problem would
+be lost: when the work looks done, choose verify.
 Use park only when the task cannot safely produce a candidate because required evidence,
 authority, or runtime capability is unavailable. A parked candidate is asynchronous and must not
 wait for a human to be online. For an exited event choose verify, park or stop; a noop on an exited event is treated as
@@ -390,6 +467,7 @@ async function askDecision(
         ? { closeOutRemainingMinutes: Math.round(context.deadline.closeOutRemainingMs / 60_000) }
         : {}),
     } : {}),
+    ...(context.lastVerification ? { lastVerification: context.lastVerification } : {}),
   };
   const prompt = `${options.instructionsPrefix ?? ""}UNTRUSTED SUPERVISOR EVENT:\n${boundedEventJson(event)}\n\nCURRENT CONTEXT:\n${boundedJson(currentContext)}\n\nChoose one action now.`;
   return promptForText(session, prompt, timeoutMs, "Decision Worker request", MAX_DECISION_RESPONSE_BYTES, { role: "decision", onUsage: options.onUsage });

package/src/events.ts

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { appendFile, chmod, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { currentLockOwner, lockOwnerAlive } from "./lock-owner.ts";
 import { redactSensitive } from "./redaction.ts";
 
 export interface SupervisorEvent {
@@ -71,7 +72,7 @@ export class EventLog {
     while (true) {
       try {
         await mkdir(lockPath);
-        await writeFile(`${lockPath}/owner.json`, JSON.stringify({ pid: process.pid, at: new Date().toISOString() }));
+        await writeFile(`${lockPath}/owner.json`, JSON.stringify(await currentLockOwner()));
         break;
       } catch (error) {
         if (!(error instanceof Error) || !/EEXIST/u.test(error.message)) throw error;
@@ -91,21 +92,14 @@ export class EventLog {
     try {
       const info = await stat(`${lockPath}/owner.json`);
       if (Date.now() - info.mtimeMs < STALE_LOCK_MS) return false;
-      let owner: { pid?: unknown };
+      let owner: unknown;
       try {
-        owner = JSON.parse(await readFile(`${lockPath}/owner.json`, "utf8")) as { pid?: unknown };
+        owner = JSON.parse(await readFile(`${lockPath}/owner.json`, "utf8"));
       } catch {
         await rm(lockPath, { recursive: true, force: true });
         return true;
       }
-      if (typeof owner.pid === "number") {
-        try {
-          process.kill(owner.pid, 0);
-          return false;
-        } catch (error) {
-          if (error instanceof Error && /EPERM/u.test(error.message)) return false;
-        }
-      }
+      if (await lockOwnerAlive(owner)) return false;
       await rm(lockPath, { recursive: true, force: true });
       return true;
     } catch (error) {

package/src/hooks/install.ts

@@ -2,20 +2,11 @@ import { randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { HOOK_TIMEOUT_SECONDS, type ClaudeHookEventName } from "./types.ts";
+import { CLAUDE_HOOK_EVENT_NAMES, HOOK_TIMEOUT_SECONDS, type ClaudeHookEventName } from "./types.ts";
 import { HOOK_RELAY_SCRIPT, hookRelayCommand } from "./relay.ts";
 import { hookSocketDirectory } from "./server.ts";
 
-const HOOK_EVENT_NAMES: readonly ClaudeHookEventName[] = [
-  "SessionStart",
-  "SessionEnd",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "Stop",
-  "StopFailure",
-  "Notification",
-];
+const HOOK_EVENT_NAMES: readonly ClaudeHookEventName[] = CLAUDE_HOOK_EVENT_NAMES;
 
 /** Substring that marks a hook command entry as ours, regardless of which stateDir produced it. */
 const RELAY_MARKER = "/hooks/relay.js";

package/src/hooks/server.ts

@@ -3,19 +3,11 @@ import { createServer, type Server, type Socket } from "node:net";
 import { chmod, lstat, mkdir, readdir, readlink, realpath, rename, rm, symlink, unlink } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import type { ClaudeHookEvent, ClaudeHookEventName, HookEventSource, HookRelayReply, HookRelayRequest } from "./types.ts";
+import { CLAUDE_HOOK_EVENT_NAMES, type ClaudeHookEvent, type ClaudeHookEventName, type HookEventSource, type HookRelayReply, type HookRelayRequest } from "./types.ts";
 
 const MAX_LINE_BYTES = 1024 * 1024;
 
-const VALID_EVENT_NAMES: ReadonlySet<string> = new Set<ClaudeHookEventName>([
-  "SessionStart",
-  "SessionEnd",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "Stop",
-  "Notification",
-]);
+const VALID_EVENT_NAMES: ReadonlySet<string> = new Set<ClaudeHookEventName>(CLAUDE_HOOK_EVENT_NAMES);
 
 type HookHandler = (request: HookRelayRequest) => Promise<HookRelayReply | undefined>;
 

package/src/hooks/settings.ts

@@ -1,18 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { HOOK_TIMEOUT_SECONDS, type ClaudeHookEventName } from "./types.ts";
+import { CLAUDE_HOOK_EVENT_NAMES, HOOK_TIMEOUT_SECONDS, type ClaudeHookEventName } from "./types.ts";
 
-const HOOK_EVENT_NAMES: readonly ClaudeHookEventName[] = [
-  "SessionStart",
-  "SessionEnd",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "Stop",
-  "StopFailure",
-  "Notification",
-];
+const HOOK_EVENT_NAMES: readonly ClaudeHookEventName[] = CLAUDE_HOOK_EVENT_NAMES;
 
 interface HookCommandEntry {
   type: "command";

package/src/hooks/types.ts

@@ -5,15 +5,23 @@
  * event over a unix socket and prints the reply as Claude's hook output.
  */
 
-export type ClaudeHookEventName =
-  | "SessionStart"
-  | "SessionEnd"
-  | "UserPromptSubmit"
-  | "PreToolUse"
-  | "PermissionRequest"
-  | "Stop"
-  | "StopFailure"
-  | "Notification";
+/**
+ * Every hook event the Supervisor consumes. The one list that the installed
+ * hook settings, the per-session settings and the server's request parser all
+ * derive from, so an event cannot be registered and then dropped on arrival.
+ */
+export const CLAUDE_HOOK_EVENT_NAMES = [
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest",
+  "Stop",
+  "StopFailure",
+  "Notification",
+] as const;
+
+export type ClaudeHookEventName = typeof CLAUDE_HOOK_EVENT_NAMES[number];
 
 /** The subset of Claude Code hook input the Supervisor consumes (all fields untrusted). */
 export interface ClaudeHookEvent {

package/src/index.ts

@@ -73,6 +73,11 @@ async function userHooksInstalled(settingsPath: string): Promise<boolean> {
  * sessions may run concurrently, but active sessions must use different
  * working directories so workers cannot silently overwrite one another.
  */
+/** The first message a recovered Worker gets: it is a fresh process that never saw the task. */
+function recoveryContinuation(goal: string): string {
+  return `The Supervisor restarted this task after an interruption; you are a fresh session and earlier work may already be in the repository. First inspect git status, git log and the uncommitted diff to see what was done. Then continue the original task to completion, run the relevant checks and commit locally. Original task:\n${goal}`;
+}
+
 export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   loadSupervisorEnvironment();
   const automation = process.env.PI_CLAUDE_SUPERVISOR_MODE === "auto" || process.env.PI_CLAUDE_SUPERVISOR_AUTOMATION === "1";
@@ -185,6 +190,8 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     return new PiReadOnlyReviewer({ timeoutMs: reviewTimeoutMs(), model: await reviewerPiModelPromise });
   };
   const sessions = new Map<string, Supervisor>();
+  /** The last few tasks that finished and were released, newest last, for `status`/`sessions`. */
+  const finishedSessions = new Map<string, { finishedAt: number; detail: string }>();
   const cwdLeases = new Map<string, CwdLeaseHandle>();
   const cleanupRequiredTasks = new Set<string>();
   const reservedCwds = new Map<string, string>();
@@ -230,6 +237,14 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
     }
   };
   const forgetSession = (taskId: string): void => {
+    // Keep what a finished task ended as: after an overnight run, `status`
+    // is exactly where the operator looks, and the live session is gone.
+    const finished = sessions.get(taskId);
+    if (finished) {
+      finishedSessions.delete(taskId);
+      finishedSessions.set(taskId, { finishedAt: Date.now(), detail: formatSessionDetail(taskId, finished, tmuxModeLabel()) });
+      while (finishedSessions.size > MAX_FINISHED_SESSIONS) finishedSessions.delete(finishedSessions.keys().next().value!);
+    }
     sessions.delete(taskId);
     reservedCwds.delete(taskId);
     cleanupRequiredTasks.delete(taskId);
@@ -885,6 +900,34 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 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`;
+              // `--extend` is an explicit request to carry on unattended: hand
+              // the task back to automation instead of leaving it under
+              // takeover. `--extend 0` needs no message — the close-out
+              // verifies the idle Worker on the next watchdog tick; a real
+              // extension sends a continuation, since the fresh Worker does
+              // not remember the task. A failure here leaves the recovered
+              // Worker idle under takeover, exactly as a plain recover would.
+              if (automaticRecovery && extendMs !== undefined) {
+                const turnBefore = session.turn;
+                try {
+                  await session.resumeAutomation();
+                  if (extendMs > 0) await session.send(recoveryContinuation(record.spec?.goal ?? record.task));
+                  message = extendMs > 0
+                    ? `Worker recovered: task=${record.taskId} worker=${handle.id}; automation resumed with a continuation of the original task; ${formatDurationMs(Math.max(0, recoveryDeadlineMs - elapsedMs))} of budget from now`
+                    : `Worker recovered: task=${record.taskId} worker=${handle.id}; automation resumed; the close-out verifies and reviews the repository as it stands`;
+                } catch (error) {
+                  const detail = redactText(error instanceof Error ? error.message : String(error));
+                  if (session.turn > turnBefore) {
+                    // The continuation reached the Worker (only its audit
+                    // record failed): it is working under automation now,
+                    // and taking it over would leave that turn undecided.
+                    message = `Worker recovered: task=${record.taskId} worker=${handle.id}; automation resumed with a continuation of the original task (warning: ${detail})`;
+                  } else {
+                    await session.takeover().catch(() => {});
+                    message = `${message} (automatic resume failed: ${detail})`;
+                  }
+                }
+              }
             } catch (error) {
               const handle = session.handle ?? startedHandle;
               let cleanupConfirmed = !handle;
@@ -960,15 +1003,22 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
         } else if (operation === "sessions") {
           const recoverable = await decisionStore.list({ activeOnly: true });
           message = formatSessions(sessions, recoverable, tmuxModeLabel());
+          if (finishedSessions.size > 0) message += `\nRecently finished:\n${formatFinishedSessions(finishedSessions)}`;
           const quarantined = await cwdLeaseStore.quarantined();
           if (quarantined.length > 0) {
             message += `\nQuarantined cwd lease records (${quarantined.length}) in ${leaseDir}/quarantine: ${redactText(quarantined.join(", "))}`;
           }
         } else if (operation === "status") {
-          const { session, sessionId } = resolveSession(sessions, activeTaskId, rest, true);
-          message = session
-            ? `task=${sessionId} state=${session.state} worker=${session.handle?.id ?? "none"}${tmuxModeLabel() ? ` mode=${tmuxModeLabel()}` : ""}${formatDeadline(session.deadline)} ${formatUsageDetail(session.usage)}`
-            : formatSessions(sessions, await decisionStore.list({ activeOnly: true }), tmuxModeLabel());
+          const finished = rest[0] && !sessions.has(rest[0]) ? finishedSessions.get(rest[0]) : undefined;
+          if (finished) {
+            message = `finished ${formatDurationMs(Date.now() - finished.finishedAt)} ago: ${finished.detail}`;
+          } else {
+            const { session, sessionId } = resolveSession(sessions, activeTaskId, rest, true);
+            message = session && sessionId
+              ? formatSessionDetail(sessionId, session, tmuxModeLabel())
+              : formatSessions(sessions, await decisionStore.list({ activeOnly: true }), tmuxModeLabel())
+                + (finishedSessions.size > 0 ? `\nRecently finished:\n${formatFinishedSessions(finishedSessions)}` : "");
+          }
         } else if (operation === "capabilities") {
           message = JSON.stringify(adapter.capabilities(), null, 2);
         } else if (operation === "install-hooks" || operation === "uninstall-hooks") {
@@ -1149,6 +1199,35 @@ function formatDeadline(deadline: Supervisor["deadline"]): string {
   return ` deadline=close-out (${formatDurationMs(deadline.closeOutRemainingMs ?? 0)} left)`;
 }
 
+const MAX_FINISHED_SESSIONS = 20;
+
+/**
+ * One task's state in a line: what it is doing, how far it got, and — the
+ * question an operator of an unattended run actually has — whether it is
+ * waiting on them.
+ */
+function formatSessionDetail(taskId: string, session: Supervisor, tmuxModeLabel?: string): string {
+  const task = session.task;
+  const parts = [`task=${taskId}`, `state=${session.state}`, `worker=${session.handle?.id ?? "none"}`];
+  if (tmuxModeLabel) parts.push(`mode=${tmuxModeLabel}`);
+  if (session.humanRequired) parts.push("automation=paused(resume-auto)");
+  if (session.candidateParked) parts.push("candidate=parked");
+  if (task) {
+    parts.push(`turn=${session.turn}/${task.maxTurns}`);
+    if (session.repairRound > 0) parts.push(`repair=${session.repairRound}`);
+    const startedAt = Date.parse(task.startedAt);
+    if (Number.isFinite(startedAt)) parts.push(`elapsed=${formatDurationMs(Math.max(0, Date.now() - startedAt))}`);
+  }
+  const verification = session.lastVerification;
+  if (verification) parts.push(`lastVerify=${verification.ok ? "pass" : "fail"}${verification.review ? `(review=${verification.review.verdict})` : ""}`);
+  const terminal = ["completed", "blocked", "stopped", "failed"].includes(session.state);
+  return `${parts.join(" ")}${terminal ? "" : formatDeadline(session.deadline)} ${formatUsageDetail(session.usage)}`;
+}
+
+function formatFinishedSessions(finished: Map<string, { finishedAt: number; detail: string }>): string {
+  return [...finished.values()].reverse().map((entry) => `  ${formatDurationMs(Date.now() - entry.finishedAt)} ago: ${entry.detail}`).join("\n");
+}
+
 function formatSessions(sessions: Map<string, Supervisor>, recoverable: DecisionSessionRecord[] = [], tmuxModeLabel?: string): string {
   const modeSuffix = tmuxModeLabel ? ` mode=${tmuxModeLabel}` : "";
   const active = [...sessions.entries()]

package/src/json-extract.ts

@@ -4,7 +4,12 @@
  * objects: prose is harmless, but ambiguity must remain non-publishable.
  */
 export function extractJsonObjects(text: string): unknown[] {
-  const objects: unknown[] = [];
+  return extractJsonObjectSpans(text).map((span) => span.value);
+}
+
+/** The same objects, each with the exact source text it was parsed from. */
+export function extractJsonObjectSpans(text: string): Array<{ value: unknown; source: string }> {
+  const objects: Array<{ value: unknown; source: string }> = [];
   let offset = 0;
   while (offset < text.length) {
     const start = text.indexOf("{", offset);
@@ -17,7 +22,7 @@ export function extractJsonObjects(text: string): unknown[] {
     const candidate = text.slice(start, end + 1);
     try {
       const value = JSON.parse(candidate) as unknown;
-      if (value && typeof value === "object" && !Array.isArray(value)) objects.push(value);
+      if (value && typeof value === "object" && !Array.isArray(value)) objects.push({ value, source: candidate });
       offset = end + 1;
     } catch {
       offset = start + 1;
@@ -47,3 +52,37 @@ export function balancedObjectEnd(text: string, start: number): number {
   }
   return -1;
 }
+
+/**
+ * True when any object in this (already valid) JSON text names a key twice.
+ * `JSON.parse` silently keeps the last value, so a duplicate is how text
+ * spliced into a string can override a field it was never meant to touch.
+ * Keys are compared decoded, so `"\u0076erdict"` duplicates `"verdict"`.
+ */
+export function jsonHasDuplicateKeys(json: string): boolean {
+  const scopes: Array<Set<string> | undefined> = [];
+  let index = 0;
+  while (index < json.length) {
+    const character = json[index];
+    if (character === '"') {
+      let end = index + 1;
+      while (end < json.length && json[end] !== '"') end += json[end] === "\\" ? 2 : 1;
+      const token = json.slice(index, end + 1);
+      index = end + 1;
+      let next = index;
+      while (next < json.length && /\s/u.test(json[next]!)) next += 1;
+      const scope = scopes.at(-1);
+      if (json[next] === ":" && scope) {
+        const key = JSON.parse(token) as string;
+        if (scope.has(key)) return true;
+        scope.add(key);
+      }
+      continue;
+    }
+    if (character === "{") scopes.push(new Set());
+    else if (character === "[") scopes.push(undefined);
+    else if (character === "}" || character === "]") scopes.pop();
+    index += 1;
+  }
+  return false;
+}