@keyou007/agent-bot 0.1.16 → 0.1.17-alpha.1

package/src/cli.ts

@@ -100,6 +100,7 @@ import {
 } from "./cli/taskListOutput.js";
 import {
   resolveCurrentTaskFromEnvironment,
+  resolveRestartNotificationTask,
   resolveTask,
   resolveTaskCommandTarget,
 } from "./cli/taskTarget.js";
@@ -1186,33 +1187,28 @@ function resolveRestartNotificationSessionId(sqlitePath: string, args: string[])
   const store = new StateStore(sqlitePath);
   try {
     const sessions = store.listAllSessions();
+    let explicitReference: string | undefined;
     if (args.includes("--task")) {
       const reference = optionValue(args, "--task")?.trim();
       if (!reference || reference.startsWith("--")) throw new Error(cliText(
         "server restart --task requires a task number or task ID.",
         "server restart --task 需要任务序号或任务 ID。",
       ));
-      const session = resolveTask(sessions, reference);
-      if (
-        isThreadContextKey(session.contextKey)
-        && !store.findLatestMessageIdForSession(session.localSessionId, session.contextKey)
-        && !store.findLatestMessageIdForContext(session.contextKey)
-      ) {
-        throw new Error(cliText(
-          "The task topic has no message anchor for restart notifications. Send /restart in that topic instead.",
-          "该任务话题没有可用于重启通知的消息锚点，请直接在该话题中发送 /restart。",
-        ));
-      }
-      return session.localSessionId;
+      explicitReference = reference;
     }
-    const runningContexts = new Set(
-      sessions.filter((session) => session.status === "running").map((session) => session.contextKey),
-    );
-    if (runningContexts.size > 1) throw new Error(cliText(
-      "Multiple conversations are running. Pass --task <task> so restart notifications return to the requester.",
-      "当前有多个会话正在运行。请传入 --task <任务>，确保重启通知返回发起会话。",
-    ));
-    return undefined;
+    const session = resolveRestartNotificationTask(sessions, explicitReference);
+    if (!session) return undefined;
+    if (
+      isThreadContextKey(session.contextKey)
+      && !store.findLatestMessageIdForSession(session.localSessionId, session.contextKey)
+      && !store.findLatestMessageIdForContext(session.contextKey)
+    ) {
+      throw new Error(cliText(
+        "The task topic has no message anchor for restart notifications. Send /restart in that topic instead.",
+        "该任务话题没有可用于重启通知的消息锚点，请直接在该话题中发送 /restart。",
+      ));
+    }
+    return session.localSessionId;
   } finally {
     store.close();
   }

package/src/codex/CodexProcessManager.ts

@@ -29,10 +29,12 @@ export class CodexProcessManager implements AppServerClientProvider {
   async getClient(): Promise<AppServerClient> {
     if (this.client) return this.client;
     this.version = undefined;
+    const environmentContext = this.environmentContext();
     const child = spawnStdioCommand(
       this.command,
       this.args,
-      agentBotEnvironment(process.env, this.env, this.environmentContext()),
+      agentBotEnvironment(process.env, this.env, environmentContext),
+      environmentContext.profilePath ?? os.homedir(),
     );
     this.child = child;
     const client = new AppServerConnection(child, this.logger.child({ component: "codex-app-server" }));

package/src/codex/CodexRuntime.ts

@@ -191,7 +191,7 @@ export class CodexRuntime implements AgentRuntime {
     const session = this.requireSession(sessionId);
     const client = await this.client();
     await this.ensureSessionResumed(session, client);
-    const response = await client.request<{ turn: { id: string } }>("turn/start", {
+    const start = () => client.request<{ turn: { id: string } }>("turn/start", {
       threadId: session.remoteSessionId,
       input: codexUserInput(prompt),
       cwd: session.cwd,
@@ -200,6 +200,19 @@ export class CodexRuntime implements AgentRuntime {
       summary: "auto",
       approvalPolicy: session.permissionMode === "auto" ? "never" : "on-request",
     }, SESSION_REQUEST_TIMEOUT_MS);
+    let response: { turn: { id: string } };
+    try {
+      response = await start();
+    } catch (error) {
+      if (!isInvalidWorkingDirectoryError(error)) throw error;
+      this.logger.warn(
+        { error, sessionId: session.localSessionId, cwd: session.cwd },
+        "App Server rejected the task working directory; refreshing the current thread before retrying.",
+      );
+      await this.resumeAppServerSession(session, client);
+      session.needsResume = false;
+      response = await start();
+    }
     if (session.activeTurnId !== response.turn.id) {
       this.adoptTurn(session, response.turn.id, Date.now());
     }
@@ -746,6 +759,11 @@ export class CodexRuntime implements AgentRuntime {
 
   private async ensureSessionResumed(session: CodexSession, client: AppServerClient): Promise<void> {
     if (!session.needsResume) return;
+    await this.resumeAppServerSession(session, client);
+    session.needsResume = false;
+  }
+
+  private async resumeAppServerSession(session: CodexSession, client: AppServerClient): Promise<void> {
     await client.request("thread/resume", {
       threadId: session.remoteSessionId,
       excludeTurns: true,
@@ -755,7 +773,6 @@ export class CodexRuntime implements AgentRuntime {
       ...threadLifecycleParams(session.cwd),
       ...permissionParams(session.permissionMode),
     }, SESSION_REQUEST_TIMEOUT_MS);
-    session.needsResume = false;
   }
 
   private async synchronizeSessionNow(sessionId: string): Promise<RuntimeSession> {
@@ -1084,6 +1101,12 @@ function isUnsupportedExcludeTurnsError(error: unknown): boolean {
     || /unknown|unrecognized|unexpected|unsupported|not supported|experimental/i.test(details);
 }
 
+function isInvalidWorkingDirectoryError(error: unknown): boolean {
+  return error instanceof AppServerRequestError
+    && error.method === "turn/start"
+    && /invalid cwd/i.test(`${error.serverMessage} ${error.data === undefined ? "" : JSON.stringify(error.data)}`);
+}
+
 function isUnsupportedRecencySortError(error: unknown): boolean {
   if (!(error instanceof AppServerRequestError) || error.method !== "thread/list") return false;
   const data = typeof error.data === "string"
@@ -1112,6 +1135,18 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
   const lastText = [...(lastTurn?.items ?? [])]
     .reverse()
     .find((item) => typeof item.text === "string" && item.text.trim())?.text?.trim();
+  const completedTurns = (thread.turns ?? []).flatMap((turn) => {
+    if (turn.status !== "completed") return [];
+    const startedAt = remoteTurnStartedAt(turn);
+    return [{
+      id: turn.id,
+      prompt: extractTurnUserPrompt(turn),
+      startedAt,
+      completedAt: startedAt === undefined
+        ? undefined
+        : startedAt + Math.max(0, turn.durationMs ?? 0),
+    }];
+  });
   return {
     id: thread.id,
     title: normalizeTaskTitle(thread.name) ?? normalizeTaskTitle(thread.preview),
@@ -1136,25 +1171,41 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     lastTurnCompletedToolCount: toolCounts?.completed,
     lastTurnFailedToolCount: toolCounts?.failed,
     lastTurnRunningToolCount: toolCounts?.running,
+    completedTurns,
   };
 }
 
 function extractLastUserPrompt(turns: CodexTurnSnapshot[] | undefined): string | undefined {
   for (const turn of [...(turns ?? [])].reverse()) {
-    for (const item of [...(turn.items ?? [])].reverse()) {
-      if (item.type !== "userMessage") continue;
-      const text = item.content
-        ?.filter((content) => content.type === "text" && typeof content.text === "string")
-        .map((content) => content.text!.trim())
-        .filter(Boolean)
-        .join("\n\n")
-        || item.text?.trim();
-      if (text) return text;
-    }
+    const prompt = extractTurnUserPrompt(turn);
+    if (prompt) return prompt;
+  }
+  return undefined;
+}
+
+function extractTurnUserPrompt(turn: CodexTurnSnapshot): string | undefined {
+  for (const item of [...(turn.items ?? [])].reverse()) {
+    if (item.type !== "userMessage") continue;
+    const text = item.content
+      ?.filter((content) => content.type === "text" && typeof content.text === "string")
+      .map((content) => content.text!.trim())
+      .filter(Boolean)
+      .join("\n\n")
+      || item.text?.trim();
+    if (text) return text;
   }
   return undefined;
 }
 
+function remoteTurnStartedAt(turn: CodexTurnSnapshot): number | undefined {
+  return remoteTimestampMs(turn.startedAt ?? undefined);
+}
+
+function remoteTimestampMs(value: number | undefined): number | undefined {
+  if (value === undefined || !Number.isFinite(value)) return undefined;
+  return value >= 10_000_000_000 ? value : value * 1_000;
+}
+
 function summarizeTurnTools(turn: CodexTurnSnapshot): {
   total: number;
   completed: number;

package/src/config/AgentExecutionDefaultsStore.ts

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isMap, parseDocument } from "yaml";
+import type { AgentExecutionDefaults } from "./schema.js";
+
+const DEFAULT_KEYS = ["modelProvider", "model", "reasoningEffort", "permissionMode"] as const;
+
+export function writeAgentExecutionDefaults(
+  configPath: string,
+  agentName: string,
+  defaults: AgentExecutionDefaults,
+): boolean {
+  const original = fs.readFileSync(configPath, "utf8");
+  const document = parseDocument(original);
+  if (document.errors.length > 0) {
+    throw new Error(`Could not update configuration file ${configPath}: ${document.errors[0]?.message ?? "invalid YAML"}`);
+  }
+  if (!isMap(document.contents)) {
+    throw new Error(`Configuration file must contain a YAML mapping: ${configPath}`);
+  }
+  const agent = document.getIn(["agents", agentName], true);
+  if (!isMap(agent)) {
+    throw new Error(`Cannot save defaults for an Agent that is not configured: ${agentName}`);
+  }
+  const existingDefaults = agent.get("defaults", true);
+  if (existingDefaults !== undefined && !isMap(existingDefaults)) {
+    throw new Error(`Configuration agents.${agentName}.defaults must contain a YAML mapping: ${configPath}`);
+  }
+  if (!isMap(existingDefaults)) agent.set("defaults", {});
+  const target = agent.get("defaults", true);
+  if (!isMap(target)) throw new Error(`Could not create defaults for Agent: ${agentName}`);
+
+  for (const key of DEFAULT_KEYS) {
+    const value = defaults[key];
+    if (value !== undefined) target.set(key, value);
+  }
+
+  const updated = document.toString();
+  if (updated === original) return false;
+  writeFileAtomically(configPath, updated);
+  return true;
+}
+
+function writeFileAtomically(filePath: string, contents: string): void {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  let temporaryFile: number | undefined;
+  try {
+    temporaryFile = fs.openSync(temporaryPath, "wx", fs.statSync(filePath).mode);
+    fs.writeFileSync(temporaryFile, contents, "utf8");
+    fs.fsyncSync(temporaryFile);
+    fs.closeSync(temporaryFile);
+    temporaryFile = undefined;
+    fs.renameSync(temporaryPath, filePath);
+    syncDirectory(path.dirname(filePath));
+  } finally {
+    if (temporaryFile !== undefined) fs.closeSync(temporaryFile);
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
+
+function syncDirectory(directory: string): void {
+  let handle: number | undefined;
+  try {
+    handle = fs.openSync(directory, "r");
+    fs.fsyncSync(handle);
+  } catch (error) {
+    if (process.platform !== "win32") throw error;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+  }
+}

package/src/config/loadConfig.ts

@@ -38,6 +38,12 @@ agents:
       - "--listen"
       - "stdio://"
     env: {}
+    # Updated automatically by the Provider, Model, Thinking, and Permission settings.
+    defaults:
+      # modelProvider: "openai"
+      # model: "gpt-5"
+      # reasoningEffort: "high"
+      permissionMode: "auto"
 
   traex:
     kind: "app-server"
@@ -48,6 +54,8 @@ agents:
       - "--listen"
       - "stdio://"
     env: {}
+    defaults:
+      permissionMode: "auto"
 
 defaults:
   agent: "codex"

package/src/config/schema.ts

@@ -40,12 +40,20 @@ const agentKindSchema = z.union([
   z.literal("codex").transform(() => "app-server" as const),
 ]).default("acp");
 
+export const agentExecutionDefaultsSchema = z.object({
+  modelProvider: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  reasoningEffort: z.string().min(1).optional(),
+  permissionMode: z.enum(["auto", "confirm"]).optional(),
+}).default({});
+
 export const agentConfigSchema = z.object({
   kind: agentKindSchema,
   title: z.string().min(1),
   command: z.string().min(1),
   args: z.array(z.string()).default([]),
   env: envRecordSchema,
+  defaults: agentExecutionDefaultsSchema,
 });
 
 export const appConfigSchema = z.object({
@@ -84,6 +92,10 @@ export const appConfigSchema = z.object({
   }).default({ level: "info", path: DEFAULT_LOG_PATH }),
 });
 
-export type AgentConfig = z.infer<typeof agentConfigSchema>;
+export type AgentExecutionDefaults = z.infer<typeof agentExecutionDefaultsSchema>;
+type ParsedAgentConfig = z.infer<typeof agentConfigSchema>;
+export type AgentConfig = Omit<ParsedAgentConfig, "defaults"> & {
+  defaults?: AgentExecutionDefaults;
+};
 export type GroupNameFormatConfig = z.infer<typeof groupNameFormatSchema>;
 export type AppConfig = z.infer<typeof appConfigSchema>;

package/src/feishu/CardRenderer.ts

@@ -225,7 +225,9 @@ export interface ResetHistoryCardEntry extends TaskListCardEntry {
   sequence: number;
   graphNodeLine: string;
   graphConnectorLine?: string;
+  timestamp?: string;
   running?: boolean;
+  resetting?: boolean;
 }
 
 export interface ResetHistoryCardView {
@@ -1328,9 +1330,11 @@ export class CardRenderer {
           entry.graphNodeLine,
           entry.graphConnectorLine,
           entry.lines,
+          entry.timestamp,
           action,
           entry.current === true,
           entry.running === true,
+          entry.resetting === true,
         ));
       });
     }
@@ -2415,15 +2419,8 @@ function inlineCode(value: string): string {
 }
 
 function formatStartupTime(value: Date): string {
-  return new Intl.DateTimeFormat("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hourCycle: "h23",
-  }).format(value);
+  const pad = (part: number) => String(part).padStart(2, "0");
+  return `${value.getFullYear()}/${pad(value.getMonth() + 1)}/${pad(value.getDate())} ${pad(value.getHours())}:${pad(value.getMinutes())}:${pad(value.getSeconds())}`;
 }
 
 function permissionModeLabel(mode?: PermissionMode): string {
@@ -2633,16 +2630,30 @@ function resetHistoryEntryRow(
   graphNodeLine: string,
   graphConnectorLine: string | undefined,
   lines: string[],
+  timestamp: string | undefined,
   action: TaskListCardAction | undefined,
   current: boolean,
   running: boolean,
+  resetting: boolean,
 ): Record<string, unknown> {
+  const branchConnectorLine = graphConnectorLine && /[╱╲]/u.test(graphConnectorLine)
+    ? graphConnectorLine
+    : undefined;
   const graph = [
-    `<font color='${current ? "green" : running ? "orange" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
-    ...(graphConnectorLine
-      ? [`<font color='grey'>${escapeCardHtml(graphConnectorLine)}</font>`]
+    `<font color='${current ? "green" : running || resetting ? "orange" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
+    ...(branchConnectorLine
+      ? [`<font color='grey'>${escapeCardHtml(branchConnectorLine)}</font>`]
       : []),
   ].join("\n");
+  const trailingElements = current
+    ? [markdown("✅ 当前")]
+    : resetting
+      ? [markdown("⏳ 正在 Reset")]
+      : running
+        ? [markdown("⏳ 运行中")]
+        : action
+          ? [taskActionElement(action)]
+          : [];
   return {
     tag: "column_set",
     flex_mode: "none",
@@ -2664,25 +2675,22 @@ function resetHistoryEntryRow(
         weight: 1,
         vertical_align: "top",
         elements: [
-          markdown(lines[0] ?? ""),
+          markdown([
+            lines[0] ?? "",
+            ...(timestamp ? [`<font color='grey'>${escapeCardHtml(timestamp)}</font>`] : []),
+          ].join(" ")),
           ...lines.slice(1).map((line) => ({
             ...markdown(`<font color='grey'>${line}</font>`),
             text_size: "notation",
           })),
         ],
       },
-      {
+      ...(trailingElements.length > 0 ? [{
         tag: "column",
         width: "auto",
         vertical_align: "top",
-        elements: current
-          ? [markdown("✅ 当前")]
-          : running
-            ? [markdown("⏳ 运行中")]
-          : action
-            ? [taskActionElement(action)]
-            : [],
-      },
+        elements: trailingElements,
+      }] : []),
     ],
   };
 }

package/src/feishu/FeishuConnector.ts

@@ -1,4 +1,5 @@
 import type { Logger } from "pino";
+import type { WSClient as LarkWsClient, WSConnectionStatus } from "@larksuiteoapi/node-sdk";
 import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
 import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
@@ -9,7 +10,12 @@ import type { CardAction, ChatUpdatedEvent, FeishuEventHandler, IncomingMessage
 type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
 type BotOpenIdListener = (botOpenId: string) => void;
 
+const LARK_WS_PING_TIMEOUT_SECONDS = 60;
+const LARK_WS_HANDSHAKE_TIMEOUT_MS = 60_000;
+
 export class FeishuConnector {
+  private wsClient?: LarkWsClient;
+
   constructor(
     private readonly config: AppConfig,
     private readonly handler: FeishuEventHandler,
@@ -39,7 +45,12 @@ export class FeishuConnector {
   }
 
   stop(): void {
-    // SDK connector currently relies on process lifetime.
+    this.wsClient?.close();
+    this.wsClient = undefined;
+  }
+
+  getConnectionStatus(): WSConnectionStatus | undefined {
+    return this.wsClient?.getConnectionStatus();
   }
 
   private async startFeishuWs(
@@ -48,7 +59,7 @@ export class FeishuConnector {
     botOpenId?: string,
     requireMention = false,
   ): Promise<void> {
-    const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
+    const lark = await import("@larksuiteoapi/node-sdk");
     const eventDispatcher = new lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data: unknown) => {
         const senderOpenId = getFeishuEvent(data)?.sender?.sender_id?.open_id;
@@ -117,12 +128,66 @@ export class FeishuConnector {
         };
       },
     });
-    const wsClient = new lark.WSClient({
+    let resolveInitialConnection!: () => void;
+    let rejectInitialConnection!: (error: Error) => void;
+    let initialConnectionSettled = false;
+    const initialConnection = new Promise<void>((resolve, reject) => {
+      resolveInitialConnection = resolve;
+      rejectInitialConnection = reject;
+    });
+    let wsClient: LarkWsClient | undefined;
+    wsClient = new lark.WSClient({
       appId,
       appSecret,
+      handshakeTimeoutMs: LARK_WS_HANDSHAKE_TIMEOUT_MS,
+      wsConfig: {
+        pingTimeout: LARK_WS_PING_TIMEOUT_SECONDS,
+      },
+      onReady: () => {
+        if (initialConnectionSettled) return;
+        initialConnectionSettled = true;
+        resolveInitialConnection();
+      },
+      onError: (error) => {
+        this.logger.error(
+          { error, connectionStatus: wsClient?.getConnectionStatus() },
+          "Feishu WebSocket connection failed.",
+        );
+        if (initialConnectionSettled) return;
+        initialConnectionSettled = true;
+        rejectInitialConnection(error);
+      },
+      onReconnecting: () => {
+        this.logger.warn(
+          { connectionStatus: wsClient?.getConnectionStatus() },
+          "Feishu WebSocket connection lost; reconnecting.",
+        );
+      },
+      onReconnected: () => {
+        this.logger.info("Feishu WebSocket connection restored.");
+      },
     });
-    await wsClient.start({ eventDispatcher });
-    this.logger.info("Feishu WebSocket connector started.");
+    this.wsClient = wsClient;
+    try {
+      await wsClient.start({ eventDispatcher });
+      const initialStatus = wsClient.getConnectionStatus();
+      if ((initialStatus.state === "idle" || initialStatus.state === "failed") && !initialConnectionSettled) {
+        throw new Error(`Feishu WebSocket failed to start (state: ${initialStatus.state}).`);
+      }
+      await initialConnection;
+      const connectedStatus = wsClient.getConnectionStatus();
+      if (connectedStatus.state !== "connected") {
+        throw new Error(`Feishu WebSocket failed to become ready (state: ${connectedStatus.state}).`);
+      }
+      this.logger.info(
+        { connectionStatus: connectedStatus },
+        "Feishu WebSocket connector started.",
+      );
+    } catch (error) {
+      wsClient.close({ force: true });
+      if (this.wsClient === wsClient) this.wsClient = undefined;
+      throw error;
+    }
   }
 
   private deferCardAction(action: CardAction, receivedAt: number): void {

package/src/feishu/FeishuTurnPresenter.ts

@@ -54,7 +54,7 @@ export interface FeishuTurnPresenterOptions {
 
 const MAX_FINAL_TABLES_PER_CARD = 5;
 const DEFAULT_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
-const FINAL_RESPONSE_BRANDING_MIN_LENGTH = 1_000;
+const FINAL_RESPONSE_BRANDING_THRESHOLD = 600;
 
 interface TurnEntry {
   contextKey: string;
@@ -581,7 +581,7 @@ export class FeishuTurnPresenter {
 
 function brandedFinalChunks(response: string, maxLength: number): string[] {
   const chunks = splitMarkdown(response, maxLength, MAX_FINAL_TABLES_PER_CARD);
-  if (chunks.length <= 1 && response.length < FINAL_RESPONSE_BRANDING_MIN_LENGTH) return chunks;
+  if (chunks.length <= 1 && response.length <= FINAL_RESPONSE_BRANDING_THRESHOLD) return chunks;
 
   const last = chunks.pop();
   if (last === undefined) return chunks;

package/src/index.ts

@@ -6,6 +6,7 @@ import { controlEndpoint, type ControlRequest, type ControlResponse } from "./cl
 import { readPackageVersion } from "./cli/packageVersion.js";
 import { loadConfig } from "./config/loadConfig.js";
 import { persistFeishuUserOpenIdIfMissing } from "./config/FeishuUserOpenIdStore.js";
+import { writeAgentExecutionDefaults } from "./config/AgentExecutionDefaultsStore.js";
 import {
   agentBotHome,
   defaultConfigPath,
@@ -42,6 +43,7 @@ import {
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
 import { SafeRestartNotifier } from "./supervision/SafeRestartNotifier.js";
+import { privateRestartNotificationTarget } from "./supervision/restartNotificationTarget.js";
 import {
   nodeDiagnosticReportArguments,
   prepareCrashReportDirectory,
@@ -72,9 +74,10 @@ const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
 
 const configuredConfigPath = process.env.AGENT_BOT_CONFIG?.trim();
+const activeConfigPath = configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath();
 const agentEnvironmentContext: AgentEnvironmentContext = {
   profilePath: agentBotHome(),
-  configPath: configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath(),
+  configPath: activeConfigPath,
   larkAppId: config.feishu.appId,
   larkUserOpenId: config.feishu.userOpenId,
 };
@@ -156,6 +159,10 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
       "Stored the default Lark user Open ID from the first private chat message.",
     );
   },
+  persistAgentExecutionDefaults: (agentName, defaults) => {
+    const changed = writeAgentExecutionDefaults(activeConfigPath, agentName, defaults);
+    logger.info({ agentName, changed }, "Stored Agent execution defaults.");
+  },
 });
 
 if (feishuOutbound) {
@@ -362,7 +369,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       if (pendingSelfUpdatePlanPath) {
         return { ok: false, message: "An Agent Bot update is already pending." };
       }
-      const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
+      const notificationTarget = inferServerRestartTarget(request.notificationSessionId);
       if (request.mode === "safe") {
         const newlyScheduled = safeRestart.schedule(request.reason, notificationTarget);
         return {
@@ -571,6 +578,14 @@ function inferControlRestartTarget(notificationSessionId?: string): RestartNotif
   return session ? restartNotificationTargetForSession(session) : undefined;
 }
 
+function inferServerRestartTarget(notificationSessionId?: string): RestartNotificationTarget {
+  if (notificationSessionId?.trim()) {
+    const target = inferControlRestartTarget(notificationSessionId);
+    if (target) return target;
+  }
+  return privateRestartNotificationTarget(config.feishu.userOpenId);
+}
+
 function restartNotificationTargetForSession(
   session: { localSessionId: string; contextKey: string },
 ): RestartNotificationTarget {