@keyou007/agent-bot 0.1.2 → 0.1.3

package/src/cli.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import qrcode from "qrcode-terminal";
 import { loadConfig } from "./config/loadConfig.js";
-import { sendControlRequest, isServerReachable, isServerRunning } from "./cli/LocalControlClient.js";
+import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
   controlEndpoint,
   type ControlResponse,
@@ -30,11 +30,22 @@ import {
   type FeishuConfigurationChallenge,
 } from "./cli/FeishuAppConfiguration.js";
 import { renderCliHelp } from "./cli/help.js";
-import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
+import { applyExplicitProfile, parseGlobalOptions } from "./cli/profile.js";
+import {
+  startInitializedServer,
+  startServer,
+  type InitializationServerResult,
+  type ServerStartResult,
+} from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
 import { StateStore, type SessionRecord } from "./state/StateStore.js";
+import {
+  nodeDiagnosticReportArguments,
+  prepareCrashReportDirectory,
+  resolveSupervisorDiagnosticsPaths,
+} from "./supervision/SupervisorDiagnostics.js";
 
 const args = process.argv.slice(2);
 
@@ -45,7 +56,8 @@ void main(args).catch((error: unknown) => {
 
 async function main(input: string[]): Promise<void> {
   const parsed = parseGlobalOptions(input);
-  if (parsed.configPath) process.env.AGENT_BOT_CONFIG = parsed.configPath;
+  if (parsed.profilePath) applyExplicitProfile(parsed.profilePath);
+  else if (parsed.configPath) process.env.AGENT_BOT_CONFIG = parsed.configPath;
   const [command, ...rest] = parsed.args;
   if (!command || command === "help" || command === "--help" || command === "-h") {
     printHelp();
@@ -86,6 +98,7 @@ interface InitCommandResult extends InitializationResult {
     appId?: string;
     configuration?: EnsureFeishuAppConfigurationResult;
   };
+  server: InitializationServerResult;
 }
 
 async function initCommand(input: string[], configPath?: string): Promise<void> {
@@ -103,18 +116,24 @@ async function initCommand(input: string[], configPath?: string): Promise<void>
   if (!json) printInitializationPaths(paths);
   const initializationLock = acquireInitializationLock(paths.home.path);
 
+  let initialized: Omit<InitCommandResult, "server">;
   try {
     cleanupFeishuCredentialTemporaryFiles(paths.env.path);
     const feishu = await initializeFeishu(
       paths,
       { json, skipFeishu, reconfigureFeishu },
     );
-    const result: InitCommandResult = { ...paths, feishu };
-    if (json) printJson(result);
-    else printInitializationResult(result);
+    initialized = { ...paths, feishu };
   } finally {
     initializationLock.release();
   }
+
+  if (!json) printInitializationResult(initialized);
+  if (!json && !skipFeishu) process.stdout.write("\n正在启动 Agent Bot server...\n");
+  const server = await startInitializedServer({ skipFeishu, configPath });
+  const result: InitCommandResult = { ...initialized, server };
+  if (json) printJson(result);
+  else printInitializationServerResult(server);
 }
 
 async function initializeFeishu(
@@ -140,6 +159,7 @@ async function initializeFeishu(
       credentials = {
         appId: existing.appId!,
         appSecret: existing.appSecret!,
+        userOpenId: existing.userOpenId,
       };
       status = "existing";
     } else {
@@ -220,7 +240,12 @@ async function consoleCommand(input: string[]): Promise<void> {
     throw new Error("agent-bot server 正在运行。为避免争用同一任务状态，请先停止 server，或明确使用 --force。");
   }
   const entry = fileURLToPath(new URL("./index.js", import.meta.url));
-  const result = spawnSync(process.execPath, [entry], {
+  const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
+  prepareCrashReportDirectory(reportDirectory);
+  const result = spawnSync(process.execPath, [
+    ...nodeDiagnosticReportArguments(reportDirectory),
+    entry,
+  ], {
     cwd: process.cwd(),
     stdio: "inherit",
     env: { ...process.env, AGENT_BOT_CONSOLE_ONLY: "1" },
@@ -247,29 +272,7 @@ async function serverCommand(input: string[]): Promise<void> {
     return;
   }
   if (action === "start") {
-    requireServerFeishuTransport(config.feishu);
-    if (await isServerRunning(endpoint)) {
-      process.stdout.write("agent-bot server 已在运行。\n");
-      return;
-    }
-    if (await isServerReachable(endpoint)) {
-      const running = await waitForServer(endpoint, 45_000);
-      if (!running) throw new Error("agent-bot server 已启动，但未能连接飞书机器人。请检查日志。");
-      process.stdout.write("agent-bot server 已启动。\n");
-      return;
-    }
-    const entry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
-    const child = spawn(process.execPath, [entry], {
-      cwd: process.cwd(),
-      detached: true,
-      windowsHide: true,
-      stdio: "ignore",
-      env: { ...process.env, AGENT_BOT_RESTART_REASON: "通过 agent-bot CLI 启动" },
-    });
-    child.unref();
-    const running = await waitForServer(endpoint, 45_000);
-    if (!running) throw new Error("已启动 Supervisor，但 server 未在 45 秒内连接飞书机器人。请检查日志。");
-    process.stdout.write("agent-bot server 已启动。\n");
+    printServerStartResult(await startServer(config));
     return;
   }
   if (action === "stop") {
@@ -374,16 +377,6 @@ async function taskCommand(input: string[]): Promise<void> {
   }
 }
 
-function parseGlobalOptions(input: string[]): { configPath?: string; args: string[] } {
-  const args = [...input];
-  const configIndex = args.indexOf("--config");
-  if (configIndex < 0) return { args };
-  const configPath = args[configIndex + 1];
-  if (!configPath) throw new Error("--config 需要配置文件路径。");
-  args.splice(configIndex, 2);
-  return { configPath, args };
-}
-
 function filterSessions(sessions: SessionRecord[], args: string[]): SessionRecord[] {
   const context = optionValue(args, "--context");
   const status = optionValue(args, "--status");
@@ -481,7 +474,7 @@ function printInitializationPaths(result: InitializationResult): void {
   process.stdout.write(`日志目录：${result.logs.path}（${initializationStatusLabel(result.logs.status)}）\n`);
 }
 
-function printInitializationResult(result: InitCommandResult): void {
+function printInitializationResult(result: Omit<InitCommandResult, "server">): void {
   process.stdout.write("\nAgent Bot 初始化完成。\n");
   if (result.feishu.status === "created") {
     process.stdout.write(`飞书应用：已创建并保存凭证（${result.feishu.appId}）\n`);
@@ -511,7 +504,22 @@ function printInitializationResult(result: InitCommandResult): void {
     process.stdout.write("飞书配置：权限、事件和回调均已就绪\n");
   }
   process.stdout.write(`配置文件：${result.config.path}\n`);
-  process.stdout.write("下一步：运行 agent-bot server start。\n");
+}
+
+function printInitializationServerResult(result: InitCommandResult["server"]): void {
+  if (result.status === "skipped") {
+    process.stdout.write("Agent Bot server：已跳过（未配置飞书，可使用 Console 模式）\n");
+    return;
+  }
+  printServerStartResult(result);
+}
+
+function printServerStartResult(result: ServerStartResult): void {
+  process.stdout.write(
+    result.status === "already-running"
+      ? "agent-bot server 已在运行。\n"
+      : "agent-bot server 已启动。\n",
+  );
 }
 
 function printFeishuVerification(challenge: FeishuAppRegistrationChallenge, json: boolean): void {
@@ -617,15 +625,6 @@ function optionValue(args: string[], name: string): string | undefined {
   return index >= 0 ? args[index + 1] : undefined;
 }
 
-async function waitForServer(endpoint: string, timeoutMs: number): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await isServerRunning(endpoint)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-  return false;
-}
-
 function printJson(value: unknown): void {
   process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }

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/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);
@@ -224,7 +231,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") {

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,