pi-claude-supervisor 0.5.2 → 0.5.4

package/src/decision-worker.ts

@@ -12,7 +12,8 @@ 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 }
-  | { action: "verify" | "retry" | "stop" | "ask_human" | "noop"; reason: string; question?: string; confidence?: number };
+  | { action: "verify" | "stop" | "park" | "ask_human" | "noop"; reason: string; question?: string; confidence?: number }
+  | { action: "retry"; reason: string; message?: string; confidence?: number };
 
 export interface DecisionContext {
   taskId: string;
@@ -130,12 +131,7 @@ export class PiDecisionWorker implements DecisionWorkerLike {
       const first = this.#seenEvents.values().next().value;
       if (first) this.#seenEvents.delete(first);
     }
-    this.#tail = this.#tail.then(async () => {
-      if (!this.#session || this.#closed) return;
-      const text = await askDecision(this.#session, event, this.#context, this.#timeoutMs);
-      const action = parseDecision(text, event);
-      await this.#options.onAction(action, event);
-    }).catch(async (error) => {
+    this.#tail = this.#tail.then(() => this.#processEvent(event)).catch(async (error) => {
       try {
         if (this.#options.onFailure) await this.#options.onFailure(event, error);
       } catch {
@@ -144,6 +140,29 @@ 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;
+    let attempt = 0;
+    while (true) {
+      let text: string;
+      try {
+        text = await askDecision(this.#session, event, this.#context, this.#timeoutMs);
+      } catch (error) {
+        if (attempt >= maxRetries || this.#closed) throw error;
+        attempt += 1;
+        await new Promise<void>((resolve) => setTimeout(resolve, Math.min(1_000, 100 * attempt)));
+        if (!this.#session || this.#closed) return;
+        continue;
+      }
+      const action = parseDecision(text, event);
+      // 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);
+      return;
+    }
+  }
+
   get sessionFile(): string | undefined {
     return this.#sessionFile;
   }
@@ -181,14 +200,20 @@ Current repair round: ${context.repairRound ?? 0}
 Task specification: ${boundedJson(context.spec ?? { goal: context.task })}
 
 Return exactly one JSON object and no markdown:
-{"action":"continue|redirect|answer|allow_permission|deny_permission|verify|retry|stop|ask_human|noop",...}
+{"action":"continue|redirect|answer|allow_permission|deny_permission|verify|retry|stop|park|noop",...}
 For continue/redirect/answer include message and reason. For permission actions include
-requestId and toolUseId. For ask_human optionally include question. Never choose allow_permission unless the request is low-risk, directly required by the task, and the policy evidence supports it.
-For AskUserQuestion, prefer deny_permission when the question can be converted into ordinary Claude text;
-then use answer on the resulting turn only when the task and repository make the answer unambiguous.
-Use verify when a turn result indicates the task is complete, even if Claude says it will stop; choose stop only for an explicit human stop, unrecoverable failure, or a safety reason.
-Use ask_human for product ambiguity, architecture tradeoffs with material risk, unknown tools,
-secrets, deployment, or any uncertainty. Never invent missing information.`;
+requestId and toolUseId. Retry may include a corrective message. Never choose allow_permission
+for a command that crosses the remote push or main/integration merge boundary; the deterministic
+policy will deny it.
+For AskUserQuestion, choose deny_permission when the question can be converted into ordinary
+Claude text, then use answer on the resulting turn. For product ambiguity or an architecture
+choice, inspect the repository and task evidence, select the best task-compatible option, state
+the assumption in reason, and instruct Claude Code with answer or redirect. Do not ask a human
+for ordinary uncertainty. 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.
+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.`;
 }
 
 async function askDecision(session: AgentSession, event: WorkerEvent, context: DecisionContext, timeoutMs: number): Promise<string> {
@@ -249,12 +274,12 @@ function textFromMessage(content: unknown): string {
 
 function parseDecision(text: string, event: WorkerEvent): DecisionAction {
   const candidate = text.trim();
-  if (!candidate) return { action: "ask_human", reason: "Decision Worker returned no JSON action" };
+  if (!candidate) return { action: "park", reason: "Decision Worker returned no JSON action" };
   try {
     const value = JSON.parse(candidate) as Record<string, unknown>;
     const action = value.action;
     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"]);
+    const allowed = new Set(["continue", "redirect", "answer", "allow_permission", "deny_permission", "verify", "retry", "stop", "park", "ask_human", "noop"]);
     if (!allowed.has(action)) throw new Error(`unsupported action: ${action}`);
     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
@@ -271,9 +296,12 @@ 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" ? boundedDecisionText(value.question, "question") : undefined, confidence };
+    if (action === "retry") {
+      return { action, reason, message: typeof value.message === "string" ? boundedDecisionText(value.message, "message") : undefined, confidence };
+    }
+    return { action: action as "verify" | "stop" | "park" | "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)}` };
+    return { action: "park", reason: `invalid Decision Worker action: ${error instanceof Error ? error.message : String(error)}` };
   }
 }
 

package/src/index.ts

@@ -7,11 +7,12 @@ 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 { automaticWorkerEnvironment } from "./worker/environment.ts";
 import { TmuxWorkerAdapter, attachCommand } from "./worker/tmux-adapter.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";
+import { autonomyDefaults, loadSupervisorEnvironment } from "./config.ts";
 import { DecisionSessionStore, type DecisionSessionRecord } from "./decision-session-store.ts";
 import { CwdLeaseStore, type CwdLeaseHandle, pathsOverlap, workerIdentity } from "./cwd-lease.ts";
 import { normalizeTaskSpec } from "./acceptance.ts";
@@ -38,19 +39,19 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   if (!["off", "auto", "required"].includes(cgroupMode)) {
     throw new Error(`Unsupported PI_CLAUDE_SUPERVISOR_CGROUP_MODE: ${cgroupMode}; expected off, auto, or required`);
   }
-  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 (transport === "tmux" && cgroupMode === "required" && !automation) {
+    throw new Error("PI_CLAUDE_SUPERVISOR_CGROUP_MODE=required is unsupported with manual tmux; use automatic mode or cgroup mode 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");
+  if (automation && !["jsonl", "tmux"].includes(transport)) {
+    throw new Error("automatic supervision requires PI_CLAUDE_SUPERVISOR_TRANSPORT=jsonl or tmux; process-pipe is manual-only");
   }
   const adapter = transport === "tmux"
-    ? new TmuxWorkerAdapter({ stateDir })
+    ? new TmuxWorkerAdapter({ stateDir, cgroupMode: automation ? "required" : cgroupMode as "off" | "auto" | "required" })
     : new ProcessWorkerAdapter({
       // Automatic decisions require Claude's structured event stream. The pipe
       // transport remains available for manual/compatibility sessions.
       mode: automation || transport === "jsonl" ? "claude-jsonl" : "process-pipe",
-      cgroupMode: cgroupMode as "off" | "auto" | "required",
+      cgroupMode: automation ? "required" : cgroupMode as "off" | "auto" | "required",
     });
   const humanWebhook = new HumanWebhookNotifier({
     url: process.env.PI_CLAUDE_SUPERVISOR_HUMAN_WEBHOOK_URL,
@@ -115,7 +116,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
   };
   const releaseSettledReservations = async (): Promise<void> => {
     for (const [taskId, session] of sessions) {
-      const terminal = ["completed", "stopped", "failed"].includes(session.state);
+      const terminal = ["completed", "blocked", "stopped", "failed"].includes(session.state);
       const detached = session.released;
       if (!terminal && !detached) continue;
       if (!session.handle) {
@@ -165,7 +166,7 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
       await session.release(reason);
       return;
     }
-    if (!handle && ["failed", "completed", "stopped"].includes(session.state)) return;
+    if (!handle && ["failed", "completed", "blocked", "stopped"].includes(session.state)) return;
     let lifecycleError: unknown;
     try {
       await session.stop(reason, { preserveDecisionSession });
@@ -228,24 +229,20 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           }
           const tmuxSession = operation === "adopt-tmux" ? rest.shift() : undefined;
           const task = rest.join(" ").trim();
-          const spec = specPath ? await readTaskSpecFile(specPath, ctx.cwd) : undefined;
-          const goal = spec?.goal ?? task;
+          const fileSpec = specPath ? await readTaskSpecFile(specPath, ctx.cwd) : undefined;
+          const spec = fileSpec ?? { autonomy: autonomyDefaults() };
+          const goal = fileSpec?.goal ?? task;
+          // Adopted sessions are explicit manual compatibility controls. They
+          // never enter the automatic Reviewer/decision loop, even when the
+          // extension is globally configured for unattended starts.
+          const taskAutomation = operation !== "adopt-tmux" && automation && spec.autonomy.unattended;
           if (!goal) throw new Error(operation === "adopt-tmux" ? "Usage: /supervise adopt-tmux [--spec <file>] <tmux-session> <task>" : "Usage: /supervise start [--spec <file>] <task>");
           if (operation === "adopt-tmux" && adapter.capabilities().transport !== "tmux") throw new Error("/supervise adopt-tmux requires PI_CLAUDE_SUPERVISOR_TRANSPORT=tmux");
           const [command, ...workerArgs] = parseCommand(process.env.PI_CLAUDE_SUPERVISOR_WORKER ?? "claude");
           if (!command) throw new Error("PI_CLAUDE_SUPERVISOR_WORKER must contain an executable");
           const policy = evaluateCommand(command, workerArgs);
-          let approval: { actor: "human"; reason: string } | undefined;
+          const approval: { actor: "human"; reason: string } | undefined = undefined;
           if (policy.decision === "deny") throw new Error(`Worker command denied: ${policy.reason}`);
-          if (policy.decision === "review") {
-            if (!ctx.hasUI) throw new Error(`Worker command requires interactive approval: ${policy.reason}`);
-            const approved = await ctx.ui.confirm(
-              "Approve Claude worker command?",
-              `${redactText([command, ...workerArgs].join(" "))}\n\nReason: ${redactText(policy.reason)}`,
-            );
-            if (!approved) throw new Error("Worker command not approved");
-            approval = { actor: "human", reason: policy.reason };
-          }
           if (shuttingDown) throw new Error("Pi session is shutting down");
           const cwdKey = await canonicalCwd(ctx.cwd);
           await releaseSettledReservations();
@@ -265,17 +262,12 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           }
           pendingCwds.add(cwdKey);
           const session = new Supervisor(adapter, events, {
-            reviewer,
-            onHumanRequired: async (notice) => {
-              if (ctx.hasUI) notify(ctx, `Claude Worker needs human intervention: ${notice.reason}`, "warning");
+            reviewer: taskAutomation ? reviewer : undefined,
+            onCandidate: async (notice) => {
+              if (ctx.hasUI) notify(ctx, `Candidate ${notice.status}: ${notice.reason}`, notice.status === "ready" ? "info" : "warning");
               if (humanWebhook.enabled) {
-                try {
-                  await humanWebhook.notify(notice);
-                } catch (error) {
-                  console.error(`pi-claude-supervisor human webhook failed: ${redactText(error instanceof Error ? error.message : String(error))}`);
-                }
-              } else {
-                console.error(`pi-claude-supervisor human intervention required: ${redactText(notice.reason)}`);
+                try { await humanWebhook.notifyCandidate(notice); }
+                catch (error) { console.error(`pi-claude-supervisor candidate webhook failed: ${redactText(error instanceof Error ? error.message : String(error))}`); }
               }
             },
           });
@@ -291,9 +283,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 cwd: cwdKey,
                 command,
                 args: workerArgs,
-                env: selectedWorkerEnvironment(),
+                env: selectedWorkerEnvironment(taskAutomation),
                 approval,
-                automation,
+                automation: taskAutomation,
                 tmuxSession,
                 tmuxSocket: process.env.PI_CLAUDE_SUPERVISOR_TMUX_SOCKET,
                 tmuxExpectedIdentity: tmuxSession && lease.record.worker ? {
@@ -321,6 +313,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                     deadlineMs: info.deadlineMs,
                     noOutputTimeoutMs: info.noOutputTimeoutMs,
                     startedAt: info.startedAt,
+                    ...(info.baseCommit ? { baseCommit: info.baseCommit } : {}),
+                    ...(info.baseBranch ? { baseBranch: info.baseBranch } : {}),
+                    ...(info.resolvedExecutable ? { resolvedExecutable: info.resolvedExecutable } : {}),
                     turn: info.turn,
                     repairRound: info.repairRound,
                     ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
@@ -455,16 +450,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           }
           const policy = evaluateCommand(record.command, record.args);
           if (policy.decision === "deny") throw new Error(`Worker command denied: ${policy.reason}`);
-          let approval = record.approval;
-          if (policy.decision === "review" && !approval) {
-            if (!ctx.hasUI) throw new Error(`Worker command requires interactive approval: ${policy.reason}`);
-            const approved = await ctx.ui.confirm(
-              "Approve recovered Claude worker command?",
-              `${redactText([record.command, ...record.args].join(" "))}\n\nReason: ${redactText(policy.reason)}`,
-            );
-            if (!approved) throw new Error("Worker command not approved");
-            approval = { actor: "human", reason: policy.reason };
-          }
+          const automaticRecovery = record.spec?.autonomy.unattended !== false;
+          if (automaticRecovery && !record.resolvedExecutable) throw new Error("automatic recovery requires a persisted resolved Claude executable identity");
+          const approval = record.approval;
           const lease = await cwdLeaseStore.acquire(cwdKey, record.taskId, adapter.capabilities().transport, takeover
             ? {
               takeover: {
@@ -490,14 +478,12 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
           }
           pendingCwds.add(cwdKey);
           const session = new Supervisor(adapter, events, {
-            reviewer,
-            onHumanRequired: async (notice) => {
-              if (ctx.hasUI) notify(ctx, `Claude Worker needs human intervention: ${notice.reason}`, "warning");
+            reviewer: automaticRecovery ? reviewer : undefined,
+            onCandidate: async (notice) => {
+              if (ctx.hasUI) notify(ctx, `Candidate ${notice.status}: ${notice.reason}`, notice.status === "ready" ? "info" : "warning");
               if (humanWebhook.enabled) {
-                try { await humanWebhook.notify(notice); }
-                catch (error) { console.error(`pi-claude-supervisor human webhook failed: ${redactText(error instanceof Error ? error.message : String(error))}`); }
-              } else {
-                console.error(`pi-claude-supervisor human intervention required: ${redactText(notice.reason)}`);
+                try { await humanWebhook.notifyCandidate(notice); }
+                catch (error) { console.error(`pi-claude-supervisor candidate webhook failed: ${redactText(error instanceof Error ? error.message : String(error))}`); }
               }
             },
           });
@@ -518,13 +504,16 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                 cwd: cwdKey,
                 command: record.command,
                 args: record.args,
-                env: selectedWorkerEnvironment(),
+                env: selectedWorkerEnvironment(automaticRecovery),
                 approval,
-                automation: true,
+                automation: automaticRecovery,
+                ...(automaticRecovery && record.resolvedExecutable ? { expectedClaudeExecutable: record.resolvedExecutable } : {}),
                 maxTurns: record.maxTurns,
                 deadlineMs: record.deadlineMs,
                 noOutputTimeoutMs: record.noOutputTimeoutMs,
                 startedAt: record.startedAt,
+                baseCommit: record.baseCommit,
+                baseBranch: record.baseBranch,
                 initialTurn: record.turn,
                 initialRepairRound: record.repairRound,
                 initialFindingSignature: record.lastFindingSignature,
@@ -546,6 +535,9 @@ export default function piClaudeSupervisor(pi: ExtensionAPI): void {
                     deadlineMs: info.deadlineMs,
                     noOutputTimeoutMs: info.noOutputTimeoutMs,
                     startedAt: info.startedAt,
+                    ...(info.baseCommit ? { baseCommit: info.baseCommit } : {}),
+                    ...(info.baseBranch ? { baseBranch: info.baseBranch } : {}),
+                    ...(info.resolvedExecutable ? { resolvedExecutable: info.resolvedExecutable } : {}),
                     turn: info.turn,
                     repairRound: info.repairRound,
                     ...(info.lastFindingSignature ? { lastFindingSignature: info.lastFindingSignature } : {}),
@@ -775,7 +767,7 @@ function formatSessions(sessions: Map<string, Supervisor>, recoverable: Decision
   return [...active, ...pending].join("\n") || "No task sessions.";
 }
 
-function selectedWorkerEnvironment(): NodeJS.ProcessEnv {
+function selectedWorkerEnvironment(automatic = false): NodeJS.ProcessEnv {
   const result: NodeJS.ProcessEnv = {};
   const names = (process.env.PI_CLAUDE_SUPERVISOR_WORKER_ENV ?? "")
     .split(",")
@@ -784,7 +776,7 @@ function selectedWorkerEnvironment(): NodeJS.ProcessEnv {
   for (const name of names) {
     if (process.env[name] !== undefined) result[name] = process.env[name];
   }
-  return result;
+  return automatic ? automaticWorkerEnvironment(result) : result;
 }
 
 async function readTaskSpecFile(path: string, cwd: string): Promise<TaskSpec> {

package/src/notifications.ts

@@ -1,5 +1,5 @@
 import { createHmac, randomUUID } from "node:crypto";
-import type { HumanInterventionNotice } from "./supervisor.ts";
+import type { CandidateNotice, HumanInterventionNotice } from "./supervisor.ts";
 import { redactSensitive } from "./redaction.ts";
 
 export interface HumanWebhookOptions {
@@ -9,7 +9,7 @@ export interface HumanWebhookOptions {
   timeoutMs?: number;
 }
 
-/** Outbound-only human escalation. Approval still happens through Pi/manual control. */
+/** Optional outbound candidate delivery. It never grants permission or controls the Worker. */
 export class HumanWebhookNotifier {
   readonly #url?: string;
   readonly #format: "generic" | "wecom";
@@ -28,42 +28,60 @@ export class HumanWebhookNotifier {
   async notify(notice: HumanInterventionNotice): Promise<void> {
     if (!this.#url) return;
     const body = this.#format === "wecom" ? JSON.stringify(toWeCom(notice)) : JSON.stringify(toGeneric(notice));
+    await this.#send(body);
+  }
+
+  async notifyCandidate(notice: CandidateNotice): Promise<void> {
+    if (!this.#url) return;
+    const body = this.#format === "wecom" ? JSON.stringify(toWeCom(notice)) : JSON.stringify(toGeneric(notice));
+    await this.#send(body);
+  }
+
+  async #send(body: string): Promise<void> {
     const headers: Record<string, string> = { "content-type": "application/json", "user-agent": "pi-claude-supervisor/0.1" };
     if (this.#secret) headers["x-pi-supervisor-signature"] = `sha256=${createHmac("sha256", this.#secret).update(body).digest("hex")}`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.#timeoutMs);
     try {
-      const response = await fetch(this.#url, { method: "POST", headers, body, signal: controller.signal });
-      if (!response.ok) throw new Error(`human webhook returned HTTP ${response.status}`);
+      const response = await fetch(this.#url!, { method: "POST", headers, body, signal: controller.signal });
+      if (!response.ok) throw new Error(`candidate webhook returned HTTP ${response.status}`);
     } finally {
       clearTimeout(timer);
     }
   }
 }
 
-function toGeneric(notice: HumanInterventionNotice): Record<string, unknown> {
+function toGeneric(notice: HumanInterventionNotice | CandidateNotice): Record<string, unknown> {
+  const candidate = "status" in notice;
   return {
-    schema: "pi-claude-supervisor/human-intervention/v1",
+    schema: candidate ? "pi-claude-supervisor/candidate/v1" : "pi-claude-supervisor/human-intervention/v1",
     eventId: randomUUID(),
-    event: "human_intervention_required",
+    event: candidate ? "candidate_status" : "human_intervention_required",
     occurredAt: new Date().toISOString(),
     task: { id: sanitize(notice.taskId), goal: sanitize(notice.task), cwd: sanitize(notice.cwd) },
     worker: { id: sanitize(notice.workerId) },
     reason: sanitize(notice.reason),
     question: sanitize(notice.question),
     permission: notice.permission ? sanitize(notice.permission) : undefined,
-    actions: ["approve_or_deny_permission", "send_instruction", "stop_worker", "takeover"],
-    note: "This is an outbound notification. Use the Pi session or a separately authenticated callback service to approve actions.",
+    ...(candidate ? { status: notice.status, deliverable: notice.deliverable } : { actions: ["approve_or_deny_permission", "send_instruction", "stop_worker", "takeover"] }),
+    note: candidate
+      ? "This is an optional candidate notification. It does not grant remote push or main/integration merge permission."
+      : "This is an outbound notification. Use the Pi session or a separately authenticated callback service to approve actions.",
   };
 }
 
-function toWeCom(notice: HumanInterventionNotice): Record<string, unknown> {
+function toWeCom(notice: HumanInterventionNotice | CandidateNotice): Record<string, unknown> {
+  const candidate = "status" in notice;
   const permission = notice.permission ? `\n工具: ${safeText(notice.permission.toolName)}\n请求 ID: ${safeText(notice.permission.requestId)}` : "";
   const question = notice.question ? `\n问题: ${safeText(notice.question)}` : "";
+  const title = candidate ? "Claude Supervisor 候选状态" : "Claude Supervisor 需要人工介入";
+  const suffix = candidate
+    ? `\n> 状态: ${safeText(notice.status)}\n> 可交付: ${notice.deliverable ? "yes" : "no"}\n\n该通知不授予远程 push 或 main/integration merge 权限。`
+    : "\n\n请在 Pi 中执行对应的 approve/deny、send、stop 或 takeover 操作。";
   return {
     msgtype: "markdown",
     markdown: {
-      content: `### Claude Supervisor 需要人工介入\n> 任务: ${safeText(notice.task)}\n> Task ID: ${safeText(notice.taskId)}\n> 原因: ${safeText(notice.reason)}${escapeMarkdown(question)}${escapeMarkdown(permission)}\n\n请在 Pi 中执行对应的 approve/deny、send、stop 或 takeover 操作。`,
+      content: `### ${title}\n> 任务: ${safeText(notice.task)}\n> Task ID: ${safeText(notice.taskId)}\n> 原因: ${safeText(notice.reason)}${escapeMarkdown(question)}${escapeMarkdown(permission)}${suffix}`,
     },
   };
 }