@keyou007/agent-bot 0.1.2 → 0.1.4

package/src/config/loadConfig.ts

@@ -3,12 +3,18 @@ import path from "node:path";
 import { config as loadDotEnv } from "dotenv";
 import YAML from "yaml";
 import { appConfigSchema, type AppConfig } from "./schema.js";
-import { defaultConfigPath, defaultDotEnvPath, resolveUserPath } from "./paths.js";
+import {
+  AGENT_BOT_EXPLICIT_PROFILE_ENV,
+  defaultConfigPath,
+  defaultDotEnvPath,
+  resolveUserPath,
+} from "./paths.js";
 
 const ENV_PATTERN = /\$\{([A-Z0-9_]+)\}/gi;
 const DEFAULT_CONFIG = `feishu:
   appId: "\${FEISHU_APP_ID}"
   appSecret: "\${FEISHU_APP_SECRET}"
+  userOpenId: "\${FEISHU_USER_OPEN_ID}"
 
 console:
   enabled: true
@@ -65,7 +71,11 @@ logging:
 export function loadConfig(
   configPath?: string,
 ): AppConfig {
-  loadDotEnv({ path: defaultDotEnvPath(), quiet: true });
+  loadDotEnv({
+    path: defaultDotEnvPath(),
+    quiet: true,
+    override: process.env[AGENT_BOT_EXPLICIT_PROFILE_ENV] === "1",
+  });
 
   const configuredPath = firstNonBlank(configPath, process.env.AGENT_BOT_CONFIG);
   const absolutePath = resolveUserPath(configuredPath ?? defaultConfigPath());

package/src/config/paths.ts

@@ -2,6 +2,7 @@ import os from "node:os";
 import path from "node:path";
 
 export const AGENT_BOT_HOME_ENV = "AGENT_BOT_HOME";
+export const AGENT_BOT_EXPLICIT_PROFILE_ENV = "AGENT_BOT_EXPLICIT_PROFILE";
 export const DEFAULT_CONFIG_FILE = "config.yaml";
 export const DEFAULT_ENV_FILE = ".env";
 export const DEFAULT_SQLITE_PATH = "./data/agent-bot.sqlite";

package/src/config/schema.ts

@@ -21,6 +21,7 @@ export const appConfigSchema = z.object({
     transport: z.enum(["auto", "sdk", "console"]).default("auto"),
     appId: z.string().optional(),
     appSecret: z.string().optional(),
+    userOpenId: z.string().optional(),
     useConsoleWhenMissingCredentials: z.boolean().default(false),
   }),
   agents: z.record(z.string().min(1), agentConfigSchema).refine(

package/src/feishu/CardRenderer.ts

@@ -33,8 +33,9 @@ export interface StartupStatusView {
 }
 
 export interface SafeRestartStatusView {
+  scheduleId: number;
   reason: string;
-  phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting";
+  phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting" | "cancelled";
   remainingMs?: number;
   pendingFinalDeliveries: number;
   waitingTasks: Array<{
@@ -270,6 +271,8 @@ export class CardRenderer {
       ? `${Math.max(0, Math.ceil((view.remainingMs ?? 0) / 1_000))}s`
       : view.phase === "restarting"
         ? "0s"
+        : view.phase === "cancelled"
+          ? "已取消"
         : "等待阻塞项清空后开始";
     const status = view.phase === "waiting_tasks"
       ? "🟠 等待任务完成"
@@ -277,7 +280,9 @@ export class CardRenderer {
         ? "🟠 等待最终结果投递"
         : view.phase === "countdown"
           ? "🟡 空闲确认中"
-          : "🔄 正在重启";
+          : view.phase === "restarting"
+            ? "🔄 正在重启"
+            : "⚪ 已取消";
     const lines = [
       `**状态**：${status}`,
       `**重启原因**：${inlineCode(view.reason)}`,
@@ -296,7 +301,24 @@ export class CardRenderer {
     } else {
       elements.push({ tag: "hr" }, markdown("**当前等待的任务**：无"));
     }
-    return sectionCard("Agent Bot 安全重启", elements, view.phase === "restarting" ? "blue" : "orange");
+    if (view.phase !== "restarting" && view.phase !== "cancelled") {
+      elements.push(
+        { tag: "hr" },
+        taskActionRow([{
+          text: "Cancel",
+          value: {
+            action: "safe_restart_cancel",
+            scheduleId: String(view.scheduleId),
+          },
+        }]),
+      );
+    }
+    const template = view.phase === "restarting"
+      ? "blue"
+      : view.phase === "cancelled"
+        ? "grey"
+        : "orange";
+    return sectionCard("Agent Bot 安全重启", elements, template);
   }
 
   renderStartupStatus(view: StartupStatusView): Record<string, unknown> {

package/src/feishu/FeishuConnector.ts

@@ -3,18 +3,11 @@ import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
 import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
-const DEFAULT_CONNECT_TIMEOUT_MS = 30_000;
-
-interface FeishuConnectorOptions {
-  connectTimeoutMs?: number;
-}
-
 export class FeishuConnector {
   constructor(
     private readonly config: AppConfig,
     private readonly handler: FeishuEventHandler,
     private readonly logger: Logger,
-    private readonly options: FeishuConnectorOptions = {},
   ) {}
 
   async start(): Promise<void> {
@@ -83,86 +76,12 @@ export class FeishuConnector {
         };
       },
     });
-    const connected = createConnectionWaiter(this.logger, this.options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
-    try {
-      const wsClient = new lark.WSClient({
-        appId,
-        appSecret,
-        logger: connected.sdkLogger,
-        loggerLevel: lark.LoggerLevel.debug,
-      });
-      await wsClient.start({ eventDispatcher });
-      await connected.promise;
-      this.logger.info("Feishu WebSocket connector connected.");
-    } finally {
-      connected.dispose();
-    }
-  }
-}
-
-function createConnectionWaiter(
-  logger: Logger,
-  timeoutMs: number,
-): {
-  promise: Promise<void>;
-  sdkLogger: {
-    error: (...messages: unknown[]) => void;
-    warn: (...messages: unknown[]) => void;
-    info: (...messages: unknown[]) => void;
-    debug: (...messages: unknown[]) => void;
-    trace: (...messages: unknown[]) => void;
-  };
-  dispose: () => void;
-} {
-  let resolveConnected!: () => void;
-  let rejectConnected!: (error: Error) => void;
-  let lastError: string | undefined;
-  let settled = false;
-  const promise = new Promise<void>((resolve, reject) => {
-    resolveConnected = resolve;
-    rejectConnected = reject;
-  });
-  const timer = setTimeout(() => {
-    if (settled) return;
-    settled = true;
-    const detail = lastError ? ` Last SDK error: ${lastError}` : "";
-    rejectConnected(new Error(`Timed out after ${timeoutMs}ms waiting for the Feishu WebSocket connection.${detail}`));
-  }, timeoutMs);
-  const logValues = (messages: unknown[]): string => messages.map(formatSdkLogValue).join(" ");
-  const sdkLogger = {
-    error: (...messages: unknown[]) => {
-      lastError = logValues(messages);
-      logger.error({ component: "feishu-websocket", sdkMessage: lastError }, "Feishu SDK error.");
-    },
-    warn: (...messages: unknown[]) => {
-      logger.warn({ component: "feishu-websocket", sdkMessage: logValues(messages) }, "Feishu SDK warning.");
-    },
-    info: (...messages: unknown[]) => {
-      logger.debug({ component: "feishu-websocket", sdkMessage: logValues(messages) }, "Feishu SDK status.");
-    },
-    debug: (...messages: unknown[]) => {
-      if (!messages.some((message) => message === "ws connect success")) return;
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolveConnected();
-    },
-    trace: () => undefined,
-  };
-  return {
-    promise,
-    sdkLogger,
-    dispose: () => clearTimeout(timer),
-  };
-}
-
-function formatSdkLogValue(value: unknown): string {
-  if (typeof value === "string") return value;
-  if (value instanceof Error) return value.message;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+    const wsClient = new lark.WSClient({
+      appId,
+      appSecret,
+    });
+    await wsClient.start({ eventDispatcher });
+    this.logger.info("Feishu WebSocket connector started.");
   }
 }
 

package/src/feishu/transport.ts

@@ -8,7 +8,7 @@ type FeishuTransportConfig = Pick<
 export function requireServerFeishuTransport(config: FeishuTransportConfig): "sdk" {
   if (!config.appId || !config.appSecret) {
     throw new Error(
-      "飞书机器人尚未配置。请先运行 agent-bot init 完成初始化；仅需本地调试时请使用 agent-bot console。",
+      "The Lark bot is not configured. Run agent-bot init first, or use agent-bot console for local-only testing.",
     );
   }
   return "sdk";

package/src/index.ts

@@ -29,6 +29,11 @@ import { STOP_EXIT_CODE } from "./supervision/restartPolicy.js";
 import { replacementSupervisorEnvironment } from "./supervision/replacementSupervisor.js";
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import { SafeRestartNotifier } from "./supervision/SafeRestartNotifier.js";
+import {
+  nodeDiagnosticReportArguments,
+  prepareCrashReportDirectory,
+  resolveSupervisorDiagnosticsPaths,
+} from "./supervision/SupervisorDiagnostics.js";
 
 const processStartedAt = new Date();
 const supervised = process.env.AGENT_BOT_SUPERVISED === "1";
@@ -78,6 +83,7 @@ if (feishuOutbound) {
     defaultAgentTitle: defaultAgent?.title ?? defaultAgentName,
     cwd: path.resolve(config.defaults.cwd),
     workspaceKind: defaultAgent?.kind === "codex" ? "projectless" : "project",
+    defaultUserOpenId: config.feishu.userOpenId,
   }, metadataHydrator);
   safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger);
 }
@@ -96,16 +102,17 @@ if (routes.length === 0) throw new Error("Neither Feishu nor console input is en
 const outbound = new OutboundRouter(routes);
 let shuttingDown = false;
 let restartRequested = false;
-const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
-  supervised,
-  restart: requestRestart,
-});
 const safeRestart = new SafeRestartScheduler({
   readActivity: () => store.getServerActivityState(),
   onReady: (reason) => initiateRestart(reason),
   onStatus: (status) => safeRestartNotifier?.update(status),
   onStatusError: (error) => logger.warn({ error }, "Failed to publish safe restart status."),
 });
+const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
+  supervised,
+  restart: requestRestart,
+  cancelSafeRestart: (scheduleId) => safeRestart.cancelScheduled(scheduleId),
+});
 
 if (feishuOutbound) feishuConnector = new FeishuConnector(config, controller, logger);
 if (consoleEnabled) consoleConnector = new ConsoleConnector(controller, logger);
@@ -170,6 +177,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           pid: process.pid,
           startedAt: processStartedAt.toISOString(),
           supervised,
+          feishuAppId: config.feishu.appId ?? null,
           safeRestartScheduled: safeRestart.scheduled,
           safeRestartReason: safeRestart.pendingReason,
           activity: store.getServerActivityState(),
@@ -181,16 +189,16 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
         return {
           ok: true,
           message: newlyScheduled
-            ? "已安排安全重启；将在全部任务完成并持续空闲 15 秒后执行。"
-            : "安全重启已在等待中，已更新重启原因。",
+            ? "Safe restart scheduled. It will run after all tasks finish and the server stays idle for 15 seconds."
+            : "A safe restart is already pending. Its reason has been updated.",
         };
       }
       setTimeout(() => void initiateRestart(request.reason), 25);
-      return { ok: true, message: "已请求立即重启。" };
+      return { ok: true, message: "Immediate restart requested." };
     case "server_stop":
       safeRestart.cancel();
       setTimeout(() => void shutdown(STOP_EXIT_CODE), 25);
-      return { ok: true, message: "已请求停止 Agent Bot server。" };
+      return { ok: true, message: "Agent Bot server stop requested." };
     case "task_status":
       return { ok: true, data: await controller.controlGetTaskStatus(request.localSessionId) };
     case "task_stop":
@@ -224,7 +232,12 @@ async function shutdown(exitCode: number, restartReason?: string): Promise<void>
 
 function startReplacementSupervisor(restartReason: string): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
-  const supervisor = spawn(process.execPath, [supervisorEntry], {
+  const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
+  prepareCrashReportDirectory(reportDirectory);
+  const supervisor = spawn(process.execPath, [
+    ...nodeDiagnosticReportArguments(reportDirectory),
+    supervisorEntry,
+  ], {
     cwd: process.cwd(),
     detached: true,
     windowsHide: true,

package/src/proxy/ProxySessionController.ts

@@ -123,6 +123,7 @@ interface CreatedFeishuGroupContext {
 export interface ProxyLifecycle {
   supervised?: boolean;
   restart(contextKey: string): Promise<void>;
+  cancelSafeRestart?(scheduleId: number): Promise<boolean>;
 }
 
 export type ShellCommandExecutor = (command: string, cwd: string) => Promise<ShellCommandResult>;
@@ -176,9 +177,8 @@ export class ProxySessionController {
   }
 
   async onMessage(message: IncomingMessage): Promise<void> {
-    if (message.chatId && message.chatType) {
-      this.store.recordChatContext(baseChatContextKey(message.contextKey), message.chatType);
-    }
+    // The durable deduplication claim is the only operation allowed before acknowledgement.
+    // It prevents event retries from adding duplicate reactions.
     if (!this.store.claimInboundEvent(message.messageId, "message")) return;
     try {
       const reactionId = await this.outbound.addReaction(
@@ -195,6 +195,9 @@ export class ProxySessionController {
         "Failed to acknowledge the incoming Feishu message with a reaction.",
       );
     }
+    if (message.chatId && message.chatType) {
+      this.store.recordChatContext(baseChatContextKey(message.contextKey), message.chatType);
+    }
     const replyTarget = message.replyInThread
       ? { messageId: message.messageId, replyInThread: true as const }
       : undefined;
@@ -323,6 +326,18 @@ export class ProxySessionController {
           await this.cancelSession(this.requireSession(contextKey, sessionId));
         } else if (kind === "queued_prompt_cancel") {
           await this.cancelQueuedPrompt(scopedAction);
+        } else if (kind === "safe_restart_cancel") {
+          const scheduleId = Number(scopedAction.value.scheduleId);
+          if (!Number.isSafeInteger(scheduleId) || scheduleId <= 0) {
+            throw new Error("安全重启卡片无效，请使用最新的状态卡片。");
+          }
+          if (!this.lifecycle?.cancelSafeRestart) {
+            throw new Error("当前运行方式不支持取消安全重启。");
+          }
+          const cancelled = await this.lifecycle.cancelSafeRestart(scheduleId);
+          if (!cancelled) {
+            await this.outbound.sendText(contextKey, "该安全重启计划已失效，请查看最新状态卡片。");
+          }
         } else if (kind === "session_more") {
           await this.refreshSessionsCardFromAction(scopedAction, undefined, true);
         } else if (kind === "session_switch") {
@@ -400,9 +415,9 @@ export class ProxySessionController {
 
   async controlStopTask(localSessionId: string): Promise<string> {
     const record = this.store.getSession(localSessionId);
-    if (!record || record.status === "closed") throw new Error(`找不到任务：${localSessionId}`);
+    if (!record || record.status === "closed") throw new Error(`Task not found: ${localSessionId}`);
     await this.cancelSession(record);
-    return `已请求停止任务：${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
+    return `Task stop requested: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
   }
 
   async controlGetTaskStatus(localSessionId: string): Promise<{
@@ -411,7 +426,7 @@ export class ProxySessionController {
     remote?: RemoteSessionSummary;
   }> {
     const record = this.store.getSession(localSessionId);
-    if (!record) throw new Error(`找不到任务：${localSessionId}`);
+    if (!record) throw new Error(`Task not found: ${localSessionId}`);
     let remote: RemoteSessionSummary | undefined;
     if (record.remoteSessionId) {
       const runtime = this.runtimes.forAgent(this.ensureAgent(record.agentName));
@@ -432,9 +447,9 @@ export class ProxySessionController {
 
   async controlSetTaskTitle(localSessionId: string, title: string): Promise<string> {
     const normalizedTitle = normalizeTaskTitle(title);
-    if (!normalizedTitle) throw new Error("任务标题不能为空。");
+    if (!normalizedTitle) throw new Error("The task title cannot be empty.");
     const record = this.store.getSession(localSessionId);
-    if (!record || record.status === "closed") throw new Error(`找不到任务：${localSessionId}`);
+    if (!record || record.status === "closed") throw new Error(`Task not found: ${localSessionId}`);
     const loaded = await this.loadSession(record);
     if (loaded.runtime.setTitle) await loaded.runtime.setTitle(record.localSessionId, normalizedTitle);
     else loaded.session.title = normalizedTitle;
@@ -445,14 +460,14 @@ export class ProxySessionController {
       title: normalizedTitle,
       source: "cli",
     });
-    return `任务标题已修改为：${normalizedTitle}`;
+    return `Task title changed to: ${normalizedTitle}`;
   }
 
   async controlSendTaskPrompt(localSessionId: string, text: string): Promise<string> {
     const promptText = text.trim();
-    if (!promptText) throw new Error("Prompt 不能为空。");
+    if (!promptText) throw new Error("The Prompt cannot be empty.");
     const record = this.store.getSession(localSessionId);
-    if (!record || record.status === "closed") throw new Error(`找不到任务：${localSessionId}`);
+    if (!record || record.status === "closed") throw new Error(`Task not found: ${localSessionId}`);
     const runtime = this.runtimes.forAgent(this.ensureAgent(record.agentName));
     const activeTurnId = runtime.getSession(localSessionId)?.activeTurnId;
     const routedContextKey = this.outbound.getSessionContextKey(localSessionId);
@@ -472,7 +487,7 @@ export class ProxySessionController {
       ?? lastSnapshot?.replyTarget
       ?? routedReplyTarget;
     if (isThreadContextKey(responseContextKey) && !existingReplyTarget) {
-      throw new Error("无法确定目标任务的话题回复位置，未发送 Prompt。");
+      throw new Error("Could not resolve the target task's thread reply location. The Prompt was not sent.");
     }
     const scopedRecord = this.store.getSessionForContext(localSessionId, responseContextKey)
       ?? { ...record, contextKey: responseContextKey };
@@ -506,7 +521,7 @@ export class ProxySessionController {
     } finally {
       if (this.messageQueues.get(responseContextKey) === next) this.messageQueues.delete(responseContextKey);
     }
-    return `已通过机器人向原会话发送 Prompt，并提交给任务：${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
+    return `The Prompt was posted to the original chat and submitted to the task: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
   }
 
   private cardActionContextKey(action: CardAction): string {

package/src/startup/StartupNotifier.ts

@@ -2,19 +2,25 @@ import type { Logger } from "pino";
 import { detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
 import { CardRenderer } from "../feishu/CardRenderer.js";
 import type { FeishuOutbound } from "../feishu/types.js";
-import type { SessionRecord, StateStore } from "../state/StateStore.js";
+import type { SessionRecord, StateStore, UserContextRecord } from "../state/StateStore.js";
 
 export interface StartupNotificationOptions {
   defaultAgentName: string;
   defaultAgentTitle: string;
   cwd: string;
   workspaceKind?: "project" | "projectless";
+  defaultUserOpenId?: string;
 }
 
 export interface StartupTaskMetadataHydrator {
   hydrate(session: SessionRecord): Promise<SessionRecord>;
 }
 
+interface StartupNotificationTarget {
+  contextKey: string;
+  context?: UserContextRecord;
+}
+
 export class StartupNotifier {
   constructor(
     private readonly store: StateStore,
@@ -26,7 +32,7 @@ export class StartupNotifier {
   ) {}
 
   async notify(startedAt: Date, restartReason: string): Promise<void> {
-    let targets;
+    let targets: StartupNotificationTarget[];
     try {
       const activeGroupSince = new Date(startedAt.getTime() - 3 * 60 * 1_000);
       const chats = [
@@ -40,10 +46,16 @@ export class StartupNotifier {
       }));
     } catch (error) {
       this.logger.warn({ error }, "Failed to load startup notification targets.");
-      return;
+      throw new Error("Failed to load startup notification targets.", { cause: error });
     }
 
-    await Promise.all(targets.map(async ({ contextKey, context }) => {
+    if (targets.length === 0) {
+      const defaultUserOpenId = this.options.defaultUserOpenId?.trim();
+      if (!defaultUserOpenId) return;
+      targets = [{ contextKey: `open_id:${defaultUserOpenId}` }];
+    }
+
+    const deliveries = await Promise.all(targets.map(async ({ contextKey, context }) => {
       let session = context?.currentSessionId ? this.store.getSession(context.currentSessionId) : undefined;
       if (session && this.metadataHydrator) {
         try {
@@ -81,12 +93,17 @@ export class StartupNotifier {
       });
       try {
         await this.outbound.sendInteractiveCard(contextKey, card);
+        return true;
       } catch (error) {
         this.logger.warn(
           { error, contextKey },
           "Failed to send startup status notification.",
         );
+        return false;
       }
     }));
+    if (deliveries.length > 0 && !deliveries.some(Boolean)) {
+      throw new Error("Failed to send any startup status notification.");
+    }
   }
 }

package/src/startup/startFeishu.ts

@@ -16,6 +16,6 @@ export async function startFeishu(
 ): Promise<void> {
   await prepare?.();
   await connector.start();
-  onConnected?.();
   await notifier.notify(startedAt, restartReason);
+  onConnected?.();
 }

package/src/supervision/SafeRestartNotifier.ts

@@ -14,6 +14,7 @@ export class SafeRestartNotifier {
   private readonly messageIds = new Map<string, string>();
   private readonly cardHashes = new Map<string, string>();
   private activeScheduleId?: number;
+  private terminalScheduleId?: number;
   private pendingInitialStatus?: SafeRestartStatus;
   private initialCardTimer?: NodeJS.Timeout;
   private queue = Promise.resolve();
@@ -27,13 +28,24 @@ export class SafeRestartNotifier {
   ) {}
 
   update(status: SafeRestartStatus): Promise<void> {
+    if (this.terminalScheduleId !== undefined && status.scheduleId <= this.terminalScheduleId) {
+      if (status.phase !== "cancelled") return Promise.resolve();
+    }
+    if (this.activeScheduleId !== undefined && status.scheduleId < this.activeScheduleId) {
+      return Promise.resolve();
+    }
+    if (status.phase === "cancelled") {
+      this.terminalScheduleId = Math.max(this.terminalScheduleId ?? 0, status.scheduleId);
+    }
     if (this.activeScheduleId !== status.scheduleId) {
       this.activeScheduleId = status.scheduleId;
       this.messageIds.clear();
       this.cardHashes.clear();
       this.clearInitialCardTimer();
       this.pendingInitialStatus = status;
-      const delayMs = this.options.initialCardDelayMs ?? DEFAULT_INITIAL_CARD_DELAY_MS;
+      const delayMs = status.phase === "cancelled"
+        ? 0
+        : this.options.initialCardDelayMs ?? DEFAULT_INITIAL_CARD_DELAY_MS;
       if (delayMs <= 0) return this.publishPendingInitialStatus();
       this.initialCardTimer = setTimeout(() => {
         this.initialCardTimer = undefined;
@@ -79,13 +91,16 @@ export class SafeRestartNotifier {
   private async publish(status: SafeRestartStatus): Promise<void> {
     const targets = this.store.listChatContexts("p2p");
     if (targets.length === 0) return;
-    const waitingTasks = this.store.listAllSessions()
-      .filter((session) => session.status === "running" || this.store.countQueuedPrompts(session.localSessionId) > 0)
-      .map((session) => ({
-        id: session.remoteSessionId ?? session.localSessionId,
-        title: session.title,
-      }));
+    const waitingTasks = status.phase === "cancelled"
+      ? []
+      : this.store.listAllSessions()
+        .filter((session) => session.status === "running" || this.store.countQueuedPrompts(session.localSessionId) > 0)
+        .map((session) => ({
+          id: session.remoteSessionId ?? session.localSessionId,
+          title: session.title,
+        }));
     const card = this.renderer.renderSafeRestartStatus({
+      scheduleId: status.scheduleId,
       reason: status.reason,
       phase: status.phase,
       remainingMs: status.remainingMs,

package/src/supervision/SafeRestartScheduler.ts

@@ -4,7 +4,12 @@ export interface ServerActivityState {
   latestInboundAt?: string;
 }
 
-export type SafeRestartPhase = "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting";
+export type SafeRestartPhase =
+  | "waiting_tasks"
+  | "waiting_delivery"
+  | "countdown"
+  | "restarting"
+  | "cancelled";
 
 export interface SafeRestartStatus {
   scheduleId: number;
@@ -56,6 +61,24 @@ export class SafeRestartScheduler {
   }
 
   cancel(): void {
+    this.clear();
+  }
+
+  async cancelScheduled(expectedScheduleId: number): Promise<boolean> {
+    const reason = this.reason;
+    if (!reason || this.scheduleId !== expectedScheduleId) return false;
+    const activity = this.options.readActivity();
+    this.clear();
+    await this.emitStatus({
+      scheduleId: expectedScheduleId,
+      reason,
+      phase: "cancelled",
+      activity,
+    });
+    return true;
+  }
+
+  private clear(): void {
     if (this.timer) clearInterval(this.timer);
     this.timer = undefined;
     this.reason = undefined;
@@ -117,8 +140,9 @@ export class SafeRestartScheduler {
       }
       return;
     }
-    await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "restarting", activity: confirmed, remainingMs: 0 });
-    this.cancel();
+    const scheduleId = this.scheduleId;
+    this.clear();
+    await this.emitStatus({ scheduleId, reason, phase: "restarting", activity: confirmed, remainingMs: 0 });
     await this.options.onReady(reason);
   }